/** * Keep only those elements in a stream that are of a given type. * * * // (1, 2, 3) SequenceM.of(1, "a", 2, "b",3).ofType(Integer.class) * */ @SuppressWarnings("unchecked") public <U> SequenceM<U> ofType(Class<U> type) { return StreamUtils.sequenceM(StreamUtils.ofType(stream, type),reversable); } /**
/** * Cast all elements in a stream to a given type, possibly throwing a * {@link ClassCastException}. * * * // ClassCastException SequenceM.of(1, "a", 2, "b", 3).cast(Integer.class) * */ public <U> SequenceM<U> cast(Class<U> type) { return StreamUtils.sequenceM(StreamUtils.cast(stream, type),reversable); } /**
@Override public <U> SequenceM<T> distinct( Function<? super T, ? extends U> keyExtractor) { return StreamUtils.sequenceM(stream.distinct(keyExtractor),reversable); }
@Override public<C extends Collection<? super T>> SequenceM<C> batchUntil(Predicate<? super T> predicate, Supplier<C> factory) { return StreamUtils.sequenceM(StreamUtils.batchWhile(stream,predicate.negate(),factory), this.reversable); } @Override
@Override public <U extends Comparable<? super U>> SequenceM<T> sorted( Function<? super T, ? extends U> function) { return StreamUtils.sequenceM(stream.sorted(function),reversable); }
@Override public SequenceM<T> fixedDelay(long l, TimeUnit unit) { return StreamUtils.sequenceM(StreamUtils.fixedDelay(stream,l,unit), this.reversable); }
@Override public <S, R> SequenceM<R> zipAnyM(AnyM<? extends S> second, BiFunction<? super T, ? super S, ? extends R> zipper) { return StreamUtils.sequenceM(StreamUtils.zipAnyM(stream,second,zipper),reversable); }
@Override public SequenceM<T> limit(long time, TimeUnit unit) { return StreamUtils.sequenceM(StreamUtils.limit(stream,time,unit), this.reversable); }
@Override public SequenceM<List<T>> batchWhile(Predicate<? super T> predicate) { return StreamUtils.sequenceM(StreamUtils.batchWhile(stream,predicate), this.reversable); } @Override
@Override public <C extends Collection<T>> SequenceM<C> batchBySize(int size, Supplier<C> factory) { return StreamUtils.sequenceM(StreamUtils.batchBySize(stream, size,factory),this.reversable); }
@Override public <EX extends Throwable> SequenceM<T> recover(Class<EX> exceptionClass, Function<EX, ? extends T> fn) { return StreamUtils.sequenceM(StreamUtils.recover(stream,exceptionClass,fn),this.reversable); }
/** * Scan left * <pre> * {@code * assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(), is(4)); * } * </pre> */ public final <U> SequenceM<U> scanLeft(U seed, BiFunction<U, ? super T, U> function) { return StreamUtils.sequenceM(stream.scanLeft(seed, function),reversable); }
@Override public SequenceM<T> skip(long time, TimeUnit unit) { return StreamUtils.sequenceM(StreamUtils.skip(stream,time,unit), this.reversable); }
@Override public SequenceM<Streamable<T>> windowBySizeAndTime(int size, long time, TimeUnit t) { return StreamUtils.sequenceM(StreamUtils.windowBySizeAndTime(stream,size,time,t), this.reversable); }
@Override public SequenceM<Streamable<T>> windowStatefullyWhile( BiPredicate<Streamable<? super T>, ? super T> predicate) { return StreamUtils.sequenceM(StreamUtils.windowStatefullyWhile(stream, predicate), this.reversable); }
@Override public <C extends Collection<? super T>> SequenceM<C> batchBySizeAndTime(int size, long time, TimeUnit unit, Supplier<C> factory) { return StreamUtils.sequenceM(StreamUtils.batchBySizeAndTime(stream, size,time, unit, factory),this.reversable); }
/** * <pre> * {@code assertThat(SequenceM.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); } * </pre> * */ public final SequenceM<T> sorted() { return StreamUtils.sequenceM(stream.sorted(),reversable); }
@Override public SequenceM<T> jitter(long l) { return StreamUtils.sequenceM(StreamUtils.jitter(stream,l), this.reversable); }
@Override public<C extends Collection<? super T>> SequenceM<C> batchWhile(Predicate<? super T> predicate, Supplier<C> factory) { return StreamUtils.sequenceM(StreamUtils.batchWhile(stream,predicate,factory), this.reversable); } @Override
/** * Returns a stream with a given value interspersed between any two values * of this stream. * * * // (1, 0, 2, 0, 3, 0, 4) SequenceM.of(1, 2, 3, 4).intersperse(0) * */ public SequenceM<T> intersperse(T value) { return StreamUtils.sequenceM(stream.flatMap(t -> Stream.of(value,t)).skip(1l),reversable); } /**