vid-app-common/src/main/java/org/onap/vid/utils/Streams.java

   1 package org.onap.vid.utils;
   2
   3 import java.util.Iterator;
   4 import java.util.Spliterator;
   5 import java.util.Spliterators;
   6 import java.util.function.Consumer;
   7 import java.util.function.Predicate;
   8 import java.util.stream.Stream;
   9 import java.util.stream.StreamSupport;
  10
  11 public class Streams {
  12
  13     private Streams() {
  14         // hide the implicit public constructor
  15     }
  16
  17     public static <R> Predicate<R> not(Predicate<R> predicate) {
  18         return predicate.negate();
  19     }
  20
  21     public static <T> Stream<T> fromIterator(final Iterator<T> iterator) {
  22         Iterable<T> iterable = () -> iterator;
  23         return StreamSupport.stream(iterable.spliterator(), false);
  24     }
  25
  26     public static <T> Stream<T> fromIterable(final Iterable<T> iterable) {
  27         return StreamSupport.stream(iterable.spliterator(), false);
  28     }
  29
  30
  31     // https://stackoverflow.com/questions/20746429/limit-a-stream-by-a-predicate
  32     private static <T> Spliterator<T> takeWhile(
  33             Spliterator<T> splitr, Predicate<? super T> predicate) {
  34         return new Spliterators.AbstractSpliterator<T>(splitr.estimateSize(), 0) {
  35             boolean stillGoing = true;
  36             @Override public boolean tryAdvance(Consumer<? super T> consumer) {
  37                 if (stillGoing) {
  38                     boolean hadNext = splitr.tryAdvance(elem -> {
  39                         if (predicate.test(elem)) {
  40                             consumer.accept(elem);
  41                         } else {
  42                             stillGoing = false;
  43                         }
  44                     });
  45                     return hadNext && stillGoing;
  46                 }
  47                 return false;
  48             }
  49         };
  50     }
  51
  52     public static <T> Stream<T> takeWhile(Stream<T> stream, Predicate<? super T> predicate) {
  53         return StreamSupport.stream(takeWhile(stream.spliterator(), predicate), false);
  54     }
  55
  56 }