com.aol.cyclops2.internal.stream

Class SpliteratorBasedStream<T>

java.lang.Object

com.aol.cyclops2.internal.stream.BaseExtendedStream<T>

com.aol.cyclops2.internal.stream.SpliteratorBasedStream<T>

All Implemented Interfaces:

Convert<Higher<Witness.reactiveSeq,T>>, Higher<Witness.reactiveSeq,T>, Unit<T>, Filters<T>, CyclopsCollectable<T>, Folds<T>, To<ReactiveSeq<T>>, FilterableTransformable<T>, Transformable<T>, TransformerTraversable<T>, ReactiveStreamsTerminalOperations<T>, OnEmpty<T>, OnEmptySwitch<T,java.util.stream.Stream<T>>, ExtendedTraversable<T>, FoldableTraversable<T>, IterableFilterable<T>, Sequential<T>, Traversable<T>, Unwrapable, Zippable<T>, ReactiveSeq<T>, java.lang.AutoCloseable, java.lang.Iterable<T>, java.util.stream.BaseStream<T,java.util.stream.Stream<T>>, java.util.stream.Stream<T>, org.reactivestreams.Publisher<T>

Direct Known Subclasses:

OneShotStreamX, StreamX

public abstract class SpliteratorBasedStream<T>
extends BaseExtendedStream<T>

Nested Class Summary

Nested classes/interfaces inherited from interface cyclops.stream.ReactiveSeq

ReactiveSeq.Instances

Nested classes/interfaces inherited from interface java.util.stream.Stream

java.util.stream.Stream.Builder<T>

Constructor Summary

Constructors

Constructor and Description
SpliteratorBasedStream(java.util.Spliterator<T> stream, java.util.Optional<ReversableSpliterator> rev)
SpliteratorBasedStream(java.util.stream.Stream<T> stream)
SpliteratorBasedStream(java.util.stream.Stream<T> stream, java.util.Optional<ReversableSpliterator> rev)

Method Summary

Modifier and Type	Method and Description
ReactiveSeq<T>	append(java.lang.Iterable<? extends T> other)
ReactiveSeq<T>	append(T... other) Append values to the take of this ReactiveSeq
ReactiveSeq<T>	append(T other)
ReactiveSeq<T>	appendS(java.util.stream.Stream<? extends T> other) Append Stream to this ReactiveSeq
ReactiveSeq<T>	changes()
<R> ReactiveSeq<R>	coflatMap(java.util.function.Function<? super ReactiveSeq<T>,? extends R> fn) coflatMap pattern, can be used to perform maybe reductions / collections / folds and other terminal operations
org.jooq.lambda.Collectable<T>	collectors() Narrow this class to a Collectable
<A,R> ReactiveSeq<R>	collectSeq(java.util.stream.Collector<? super T,A,R> c)
SpliteratorBasedStream<T>	complete(java.lang.Runnable fn) Provide a simpler method to handle stream or async operations.
long	count() Returns the count of elements in this reactiveStream.
protected <X> ReactiveSeq<X>	createSeq(java.util.stream.Stream<X> stream)
ReactiveSeq<T>	distinct()
<U> ReactiveSeq<T>	distinct(java.util.function.Function<? super T,? extends U> keyExtractor)
ReactiveSeq<T>	filter(java.util.function.Predicate<? super T> fn) Keep only elements for which the supplied predicates hold e.g.
ReactiveSeq<T>	filterLazyPredicate(java.util.function.Supplier<java.util.function.Predicate<? super T>> fn)
java.util.Optional<T>	findFirst()
Either<java.lang.Throwable,T>	findFirstOrError() Lazy / reactiveBuffer look up of first value , capturing the first error, if one occurs.
Maybe<T>	findOne() Lazy / reactiveBuffer analogue of findFirst / findAny from JDK For push based reactiveBuffer-streams (created via Spouts.XXX) data will be pushed to the returned Maybe on arrival.
<R> ReactiveSeq<R>	flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn) flatMap operation
<R> ReactiveSeq<R>	flatMapAnyM(java.util.function.Function<? super T,AnyM<Witness.stream,? extends R>> fn) Allows flatMap return type to be any Monad type
<R> ReactiveSeq<R>	flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn) FlatMap where the result is a Collection, flattens the resultant collections into the host ReactiveSeq
<R> ReactiveSeq<R>	flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see IterableFunctor#flatMapPublisher(Function, int, QueueFactory) method to forEachAsync asynchronously also.
<R> ReactiveSeq<R>	flatMapP(int maxConcurrency, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see IterableFunctor#flatMapPublisher(Function, int, QueueFactory) method to forEachAsync asynchronously also.
<R> ReactiveSeq<R>	flatMapP(int maxConcurrency, QueueFactory<R> factory, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously.
void	forEach(java.util.function.Consumer<? super T> action) Performs an action for each element of this Stream.
<X extends java.lang.Throwable> void	forEach(java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError) Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
<X extends java.lang.Throwable> void	forEach(java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete) Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.
<X extends java.lang.Throwable> org.reactivestreams.Subscription	forEach(long numberOfElements, java.util.function.Consumer<? super T> consumer) Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time.
<X extends java.lang.Throwable> org.reactivestreams.Subscription	forEach(long numberOfElements, java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError) Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
<X extends java.lang.Throwable> org.reactivestreams.Subscription	forEach(long numberOfElements, java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete) Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
java.lang.String	format()
ReactiveSeq<ListX<T>>	grouped(int groupSize) Group elements in a Stream
<C extends java.util.Collection<? super T>> ReactiveSeq<C>	grouped(int size, java.util.function.Supplier<C> factory) Batch elements in a Stream by size into a toX created by the supplied factory
ReactiveSeq<ListX<T>>	groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit t) Batch elements by size into a List
<C extends java.util.Collection<? super T>> ReactiveSeq<C>	groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory) Batch elements by size into a toX created by the supplied factory
<C extends java.util.Collection<? super T>,R> ReactiveSeq<R>	groupedBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)
ReactiveSeq<ListX<T>>	groupedByTime(long time, java.util.concurrent.TimeUnit t) Batch elements in a Stream by time period
<C extends java.util.Collection<? super T>> ReactiveSeq<C>	groupedByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory) Batch elements by time into a toX created by the supplied factory
<C extends java.util.Collection<? super T>,R> ReactiveSeq<R>	groupedByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)
<C extends java.util.Collection<T>,R> ReactiveSeq<R>	groupedStatefullyUntil(java.util.function.BiPredicate<C,? super T> predicate, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)
ReactiveSeq<ListX<T>>	groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate) Create ReactiveSeq of ListX where each ListX is populated while the supplied bipredicate holds.
<C extends java.util.Collection<T>,R> ReactiveSeq<R>	groupedStatefullyWhile(java.util.function.BiPredicate<C,? super T> predicate, java.util.function.Supplier<C> factory, java.util.function.Function<? super C,? extends R> finalizer)
ReactiveSeq<ListX<T>>	groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
ReactiveSeq<ListX<T>>	groupedUntil(java.util.function.Predicate<? super T> predicate) Create a ReactiveSeq batched by List, where each batch is populated until the predicate holds
<C extends java.util.Collection<? super T>> ReactiveSeq<C>	groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory) Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
ReactiveSeq<ListX<T>>	groupedWhile(java.util.function.Predicate<? super T> predicate) Create a ReactiveSeq batched by List, where each batch is populated while the predicate holds
<C extends java.util.Collection<? super T>> ReactiveSeq<C>	groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory) Create a ReactiveSeq batched by a Collection, where each batch is populated while the predicate holds
java.util.Iterator<T>	iterator()
ReactiveSeq<T>	limit(long num) assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
ReactiveSeq<T>	limit(long time, java.util.concurrent.TimeUnit unit) Return all elements until specified time period has elapsed
ReactiveSeq<T>	limitLast(int num) Limit results to the last x elements in a ReactiveSeq
ReactiveSeq<T>	limitUntil(java.util.function.Predicate<? super T> p) Take elements from the Stream until the predicate returns true, after which all elements are excluded.
ReactiveSeq<T>	limitWhile(java.util.function.Predicate<? super T> p) Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded
ReactiveSeq<T>	limitWhileClosed(java.util.function.Predicate<? super T> predicate)
<R> ReactiveSeq<R>	map(java.util.function.Function<? super T,? extends R> fn) Transform this functor using the supplied transformation function
<R> ReactiveSeq<R>	mapLazyFn(java.util.function.Supplier<java.util.function.Function<? super T,? extends R>> fn)
ReactiveSeq<T>	onEmpty(T value) If this Container instance is zero, create a new instance containing the provided value
ReactiveSeq<T>	onEmptyGet(java.util.function.Supplier<? extends T> supplier) If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
ReactiveSeq<T>	onEmptySwitch(java.util.function.Supplier<? extends java.util.stream.Stream<T>> switchTo) If this ReactiveSeq is empty one it with a another Stream
<X extends java.lang.Throwable> ReactiveSeq<T>	onEmptyThrow(java.util.function.Supplier<? extends X> supplier) If this container instance is zero, throw the exception returned by the provided Supplier
ReactiveSeq<T>	peek(java.util.function.Consumer<? super T> c) Peek at the current value of this Transformable, without transforming it
ReactiveSeq<T>	prepend(java.lang.Iterable<? extends T> other)
ReactiveSeq<T>	prepend(T... other) Prepend given values to the skip of the Stream
ReactiveSeq<T>	prepend(T other)
ReactiveSeq<T>	prependS(java.util.stream.Stream<? extends T> other) Prepend Stream to this ReactiveSeq
<EX extends java.lang.Throwable> ReactiveSeq<T>	recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<? super EX,? extends T> fn) Recover from a particular exception type
ReactiveSeq<T>	recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn) Recover from an exception with an alternative value
java.util.Optional<T>	reduce(java.util.function.BinaryOperator<T> accumulator) An equivalent function to Stream.reduce(BinaryOperator)
T	reduce(T identity, java.util.function.BinaryOperator<T> accumulator) An equivalent function to Stream.reduce(Object, BinaryOperator)
<U> ReactiveSeq<U>	scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function) Scan left
ReactiveSeq<T>	skip(long num) assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
ReactiveSeq<T>	skip(long time, java.util.concurrent.TimeUnit unit) Skip all elements until specified time period has passed
ReactiveSeq<T>	skipLast(int num) assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
ReactiveSeq<T>	skipUntil(java.util.function.Predicate<? super T> p) Drop elements from the Stream until the predicate returns true, after which all elements are included
ReactiveSeq<T>	skipWhile(java.util.function.Predicate<? super T> p) SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *
ReactiveSeq<T>	skipWhileClosed(java.util.function.Predicate<? super T> predicate)
ReactiveSeq<VectorX<T>>	sliding(int windowSize, int increment) Create a sliding view over this Sequence
java.util.Spliterator<T>	spliterator() Returns a spliterator for the elements of this reactiveStream.
void	subscribe(org.reactivestreams.Subscriber<? super T> sub)
<T> ReactiveSeq<T>	unit(T unit)
<T> ReactiveSeq<T>	unitIterator(java.util.Iterator<T> it) Create an IterableFunctor instance of the same type from an Iterator
java.util.stream.Stream<T>	unwrapStream()
<S,U> ReactiveSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>>	zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third) zip 3 Streams into one
<S,U,R> ReactiveSeq<R>	zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Fn3<? super T,? super S,? super U,? extends R> fn3)
<T2,T3,T4> ReactiveSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>	zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth) zip 4 Streams into 1
<T2,T3,T4,R> ReactiveSeq<R>	zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn)
<S> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,S>>	zipS(java.util.stream.Stream<? extends S> second) Zip 2 streams into one
<U,R> ReactiveSeq<R>	zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper) Zip (combine) this Zippable with the supplied Stream, using the supplied combining function

Methods inherited from class com.aol.cyclops2.internal.stream.BaseExtendedStream

allMatch, anyM, anyMatch, close, collect, collect, debounce, endsWith, endsWithIterable, findAny, firstValue, fixedDelay, flatMapBufferedReader, flatMapCharSequence, flatMapCompletableFuture, flatMapFile, flatMapOptional, flatMapStream, flatMapToDouble, flatMapToInt, flatMapToLong, flatMapURL, foldLeft, foldLeft, foldLeftMapToType, foldRight, foldRight, foldRight, foldRightMapToType, forEachOrdered, headAndTail, isParallel, jitter, join, join, join, mapReduce, mapReduce, mapToDouble, mapToInt, mapToLong, max, maxBy, min, minBy, noneMatch, onClose, onePer, parallel, reduce, reduce, reduce, reduce, sequential, sorted, startsWith, startsWithIterable, stream, toArray, toArray, toList, toSet, unordered, xMatch, xPer

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.aol.cyclops2.types.Unwrapable

unwrap, unwrapIfInstance, unwrapNested

Methods inherited from interface cyclops.stream.ReactiveSeq

allTypeclasses, allTypeclasses, ambWith, ambWith, backpressureAware, broadcast, cast, collectAll, collectStream, combinations, combinations, combinationsT, combinationsT, combine, combine, concat, concat, concat, concat, concatDoubles, concatInts, concatLongs, coproduct, crossJoin, cycle, cycle, cycle, cycleUntil, cycleWhile, deferred, deferredI, deferredP, deleteBetween, doubles, drop, dropRight, dropUntil, dropWhile, duplicate, duplicate, elapsed, elementAt, empty, enqueued, enqueued, enqueued, enqueuedAll, enums, enums, enums, enumsFromTo, fanOut, fanOut, fanOut, fanOutZipIn, fanOutZipIn, fanOutZipIn, fill, filterInts, filterLongs, filterLongs, filterNot, flatMapDoubles, flatMapInts, flatMapLongs, flatten, flattenI, flattenO, foldJool, foldParallel, foldParallel, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, forEachAsync, fromCharSequence, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromPublisher, fromSpliterator, fromStream, generate, generate, get, groupBy, grouped, grouped, hotStream, insertAt, insertAtS, intersperse, ints, isEmpty, isReplayable, iterate, iterate, jool, kindCokleisli, kindKleisli, liftM, limitDouble, limitInts, limitLongs, limitUntilClosed, longs, mapDoubles, mapInts, mapLongs, mapM, merge, mergeP, mergeP, multicast, narrowK, nested, notNull, of, of, ofDoubles, ofInts, ofLongs, ofNullable, ofType, oneShotList, oneShotStream, parallel, parallel, parallelFanOut, parallelFanOut, parallelFanOut, parallelFanOutZipIn, parallelFanOutZipIn, parallelFanOutZipIn, partition, pausableHotStream, permutations, permutationsT, primedHotStream, primedPausableHotStream, print, print, printErr, printOut, product, product, publishTo, publishTo, quadruplicate, quadruplicate, range, range, rangeLong, rangeLong, reactiveSeq, reduce, reduceAll, remove, removeAll, removeAllI, removeAllS, retainAll, retainAllI, retainAllS, retry, retry, reverse, reversedListOf, reversedOf, scanLeft, scanRight, scanRight, schedule, scheduleFixedDelay, scheduleFixedRate, seq, shuffle, shuffle, single, single, singleUnsafe, size, skipDoubles, skipInts, skipLongs, skipUntilClosed, slice, sliding, sorted, sorted, sorted, splitAt, splitAtHead, splitBy, subStream, tailRec, take, takeOne, takeRight, takeUntil, takeWhile, timestamp, trampoline, triplicate, triplicate, unfold, unzip, unzip3, unzip4, visit, widen, zip, zip, zip, zipLatest, zipP, zipP, zipWith, zipWithIndex, zipWithP, zipWithS

Methods inherited from interface com.aol.cyclops2.types.foldable.To

to

Methods inherited from interface java.util.stream.Stream

builder

Methods inherited from interface com.aol.cyclops2.types.traversable.FoldableTraversable

asFunction, foldFuture, foldLazy, foldTry, forEachSubscribe, forEachSubscribe, forEachSubscribe, runFuture, runLazy, toListX, toSetX, visit

Methods inherited from interface com.aol.cyclops2.types.foldable.CyclopsCollectable

commonPrefix, commonSuffix, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, mode, sum, sumDouble, sumInt, sumLong, to, toMap, toMap, toString, toString

Methods inherited from interface com.aol.cyclops2.types.foldable.Folds

foldLeft, foldLeft

Methods inherited from interface com.aol.cyclops2.types.traversable.Traversable

traversable

Methods inherited from interface com.aol.cyclops2.types.functor.TransformerTraversable

groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT

Methods inherited from interface com.aol.cyclops2.hkt.Higher

applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.aol.cyclops2.hkt.Convert

convert

Constructor Detail

SpliteratorBasedStream

public SpliteratorBasedStream(java.util.stream.Stream<T> stream)

SpliteratorBasedStream

public SpliteratorBasedStream(java.util.Spliterator<T> stream,
                              java.util.Optional<ReversableSpliterator> rev)

SpliteratorBasedStream

public SpliteratorBasedStream(java.util.stream.Stream<T> stream,
                              java.util.Optional<ReversableSpliterator> rev)

Method Detail

complete

public SpliteratorBasedStream<T> complete(java.lang.Runnable fn)

Description copied from interface: ReactiveSeq

Provide a simpler method to handle stream or async operations.

Parameters:

fn - Function that accepts and returns completed value

Returns:

ReactiveSeq that can handle stream or async operations simpler

iterator

public java.util.Iterator<T> iterator()

coflatMap

public <R> ReactiveSeq<R> coflatMap(java.util.function.Function<? super ReactiveSeq<T>,? extends R> fn)

Description copied from interface: ReactiveSeq

coflatMap pattern, can be used to perform maybe reductions / collections / folds and other terminal operations

 

      ReactiveSeq.of(1,2,3)
                 .map(i->i*2)
                 .coflatMap(s -> s.reduce(0,(a,b)->a+b))

      //ReactiveSeq[12]
 
 

Returns:

findFirstOrError

public Either<java.lang.Throwable,T> findFirstOrError()

Description copied from interface: ReactiveSeq

Lazy / reactiveBuffer look up of first value , capturing the first error, if one occurs. If no values are present a NoSuchElementException is returned. For push based reactiveBuffer-streams (created via Spouts.XXX) data will be pushed to the returned Either on arrival. For pull based Streams (created via ReactiveSeq.XXX) the Stream will be executed when the Either is first accessed.

Returns:

findOne

public Maybe<T> findOne()

Description copied from interface: ReactiveSeq

Lazy / reactiveBuffer analogue of findFirst / findAny from JDK For push based reactiveBuffer-streams (created via Spouts.XXX) data will be pushed to the returned Maybe on arrival. For pull based Streams (created via ReactiveSeq.XXX) the Stream will be executed when the Maybe is first accessed.

Returns:

collectSeq

public <A,R> ReactiveSeq<R> collectSeq(java.util.stream.Collector<? super T,A,R> c)

unit

public <T> ReactiveSeq<T> unit(T unit)

unwrapStream

public java.util.stream.Stream<T> unwrapStream()

Specified by:

unwrapStream in class BaseExtendedStream<T>

zipS

public final <S> ReactiveSeq<org.jooq.lambda.tuple.Tuple2<T,S>> zipS(java.util.stream.Stream<? extends S> second)

Description copied from interface: ReactiveSeq

Zip 2 streams into one

 
  List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
  // [[1,"a"],[2,"b"]]
 
 

Parameters:

second - Stream to combine with

Returns:

Combined Zippable

zipS

public final <U,R> ReactiveSeq<R> zipS(java.util.stream.Stream<? extends U> other,
                                       java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Description copied from interface: Zippable

Zip (combine) this Zippable with the supplied Stream, using the supplied combining function

Parameters:

other - Stream to combine with

zipper - Zip / combining function

Returns:

Combined zippable

zip3

public final <S,U,R> ReactiveSeq<R> zip3(java.lang.Iterable<? extends S> second,
                                         java.lang.Iterable<? extends U> third,
                                         Fn3<? super T,? super S,? super U,? extends R> fn3)

zip3

public <S,U> ReactiveSeq<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
                                                                   java.lang.Iterable<? extends U> third)

Description copied from interface: ReactiveSeq

zip 3 Streams into one

 
  List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(CyclopsCollectors.toList());

  // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 

 

zip4

public <T2,T3,T4,R> ReactiveSeq<R> zip4(java.lang.Iterable<? extends T2> second,
                                        java.lang.Iterable<? extends T3> third,
                                        java.lang.Iterable<? extends T4> fourth,
                                        Fn4<? super T,? super T2,? super T3,? super T4,? extends R> fn)

zip4

public final <T2,T3,T4> ReactiveSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
                                                                                   java.lang.Iterable<? extends T3> third,
                                                                                   java.lang.Iterable<? extends T4> fourth)

Description copied from interface: ReactiveSeq

zip 4 Streams into 1

 
  List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
          .collect(CyclopsCollectors.toList());

 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 

sliding

public final ReactiveSeq<VectorX<T>> sliding(int windowSize,
                                             int increment)

Description copied from interface: ReactiveSeq

Create a sliding view over this Sequence

 
  List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(CyclopsCollectors.toList());

  assertThat(list.get(0), hasItems(1, 2, 3));
  assertThat(list.get(1), hasItems(3, 4, 5));

 

 

Parameters:

windowSize - number of elements in each batch

increment - for each window

Returns:

ReactiveSeq with sliding view

grouped

public ReactiveSeq<ListX<T>> grouped(int groupSize)

Description copied from interface: ReactiveSeq

Group elements in a Stream

 
  List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(CyclopsCollectors.toList());

  assertThat(list.get(0), hasItems(1, 2, 3));
  assertThat(list.get(1), hasItems(4, 5, 6));

 
 

Parameters:

groupSize - Size of each Group

Returns:

Stream with elements grouped by size

groupedStatefullyWhile

public ReactiveSeq<ListX<T>> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)

groupedStatefullyWhile

public <C extends java.util.Collection<T>,R> ReactiveSeq<R> groupedStatefullyWhile(java.util.function.BiPredicate<C,? super T> predicate,
                                                                                   java.util.function.Supplier<C> factory,
                                                                                   java.util.function.Function<? super C,? extends R> finalizer)

groupedStatefullyUntil

public ReactiveSeq<ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)

Description copied from interface: ReactiveSeq

Create ReactiveSeq of ListX where each ListX is populated while the supplied bipredicate holds. The bipredicate recieves the ListX from the last window as well as the current value and can choose to aggregate the current value or create a new window

 
    ReactiveSeq.of(1,2,3,4,5,6)
               .groupedStatefullyUntil((s,i)-> s.contains(4) ? true : false)
               .toList()
               .size()
     //5
 
 

Parameters:

predicate - Window while true

Returns:

ReactiveSeq windowed while predicate holds

groupedStatefullyUntil

public <C extends java.util.Collection<T>,R> ReactiveSeq<R> groupedStatefullyUntil(java.util.function.BiPredicate<C,? super T> predicate,
                                                                                   java.util.function.Supplier<C> factory,
                                                                                   java.util.function.Function<? super C,? extends R> finalizer)

distinct

public final ReactiveSeq<T> distinct()

scanLeft

public final <U> ReactiveSeq<U> scanLeft(U seed,
                                         java.util.function.BiFunction<? super U,? super T,? extends U> function)

Description copied from interface: ReactiveSeq

Scan left

 
  assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
         		is(4));
 
 

skip

public ReactiveSeq<T> skip(long num)

Description copied from interface: ReactiveSeq

  assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 

Parameters:

num - Number of elemenets to skip

Returns:

Stream with specified number of elements skipped

skipWhile

public final ReactiveSeq<T> skipWhile(java.util.function.Predicate<? super T> p)

Description copied from interface: ReactiveSeq

SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *

 
 assertThat(ReactiveSeq.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
 
 

Parameters:

p - Predicate to skip while true

Returns:

Stream with elements skipped while predicate holds

skipUntil

public final ReactiveSeq<T> skipUntil(java.util.function.Predicate<? super T> p)

Description copied from interface: ReactiveSeq

Drop elements from the Stream until the predicate returns true, after which all elements are included

  assertThat(ReactiveSeq.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
 

Parameters:

p - Predicate to skip until true

Returns:

Stream with elements skipped until predicate holds

limit

public ReactiveSeq<T> limit(long num)

Description copied from interface: ReactiveSeq

  assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 

Parameters:

num - Limit element size to num

Returns:

Monad converted to Stream with elements up to num

limitWhile

public final ReactiveSeq<T> limitWhile(java.util.function.Predicate<? super T> p)

Description copied from interface: ReactiveSeq

Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded

  assertThat(ReactiveSeq.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
 

Parameters:

p - Limit while predicate is true

Returns:

Stream with limited elements

limitUntil

public final ReactiveSeq<T> limitUntil(java.util.function.Predicate<? super T> p)

Description copied from interface: ReactiveSeq

Take elements from the Stream until the predicate returns true, after which all elements are excluded.

  assertThat(ReactiveSeq.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3))); 
 

Parameters:

p - Limit until predicate is true

Returns:

Stream with limited elements

skipWhileClosed

public ReactiveSeq<T> skipWhileClosed(java.util.function.Predicate<? super T> predicate)

limitWhileClosed

public ReactiveSeq<T> limitWhileClosed(java.util.function.Predicate<? super T> predicate)

findFirst

public final java.util.Optional<T> findFirst()

Returns:

First matching element in sequential order

 
 ReactiveSeq.of(1,2,3,4,5).filter(it -> it <3).findFirst().get();

 //3
 
 

(deterministic)

reduce

public final java.util.Optional<T> reduce(java.util.function.BinaryOperator<T> accumulator)

Description copied from interface: Folds

An equivalent function to Stream.reduce(BinaryOperator)

 
  
       ReactiveSeq.of(1,2,3,4,5).map(it -> it*100).reduce(
 (acc,next) -> acc+next)
        //Optional[1500]
  
  

Specified by:

reduce in interface Folds<T>

Specified by:

reduce in interface ReactiveSeq<T>

Specified by:

reduce in interface java.util.stream.Stream<T>

Overrides:

reduce in class BaseExtendedStream<T>

Parameters:

accumulator - Combiner function

reduce

public final T reduce(T identity,
                      java.util.function.BinaryOperator<T> accumulator)

Description copied from interface: Folds

An equivalent function to Stream.reduce(Object, BinaryOperator)

Specified by:

reduce in interface Folds<T>

Specified by:

reduce in interface ReactiveSeq<T>

Specified by:

reduce in interface java.util.stream.Stream<T>

Overrides:

reduce in class BaseExtendedStream<T>

accumulator - Combiner function

Returns:

Value emitted by applying the current accumulated value and the next value to the combiner function as this Folds is traversed from left to right

map

public final <R> ReactiveSeq<R> map(java.util.function.Function<? super T,? extends R> fn)

Description copied from interface: Transformable

Transform this functor using the supplied transformation function

 


    of(1,2,3).map(i->i*2)

    //[2,4,6]

 
 

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

peek

public final ReactiveSeq<T> peek(java.util.function.Consumer<? super T> c)

Description copied from interface: Transformable

Peek at the current value of this Transformable, without transforming it

 


    of(1,2,3).map(System.out::println)

    1
    2
    3

 
 

Parameters:

c - Consumer that recieves each element from this Transformable

Returns:

Transformable that will peek at each value

flatMap

public final <R> ReactiveSeq<R> flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)

Description copied from interface: ReactiveSeq

flatMap operation

 
 	assertThat(ReactiveSeq.of(1,2)
 						.flatMap(i -> asList(i, -i).reactiveStream())
 						.toList(),equalTo(asList(1, -1, 2, -2)));

 
 

Parameters:

fn - to be applied

Returns:

new stage in Sequence with flatMap operation to be lazily applied

flatMapAnyM

public final <R> ReactiveSeq<R> flatMapAnyM(java.util.function.Function<? super T,AnyM<Witness.stream,? extends R>> fn)

Description copied from interface: ReactiveSeq

Allows flatMap return type to be any Monad type

 
 	assertThat(ReactiveSeq.of(1,2,3)).flatMapAnyM(i-> fromEither5(CompletableFuture.completedFuture(i+2))).toList(),equalTo(Arrays.asList(3,4,5)));

 
 

Parameters:

fn - to be applied

Returns:

new stage in Sequence with flatMap operation to be lazily applied

flatMapI

public final <R> ReactiveSeq<R> flatMapI(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)

Description copied from interface: ReactiveSeq

FlatMap where the result is a Collection, flattens the resultant collections into the host ReactiveSeq

 
 	ReactiveSeq.of(1,2)
 			.flatMap(i -> asList(i, -i))
          .toList();

   //1,-1,2,-2
 
 

Returns:

flatMapP

public <R> ReactiveSeq<R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see IterableFunctor#flatMapPublisher(Function, int, QueueFactory) method to forEachAsync asynchronously also. A default limit of 10k active publishers is enforced, along with a default limit of 5k queued values before backpressure is applied.

Parameters:

mapper -

Returns:

flatMapP

public <R> ReactiveSeq<R> flatMapP(int maxConcurrency,
                                   java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously, users can use the overloaded @see IterableFunctor#flatMapPublisher(Function, int, QueueFactory) method to forEachAsync asynchronously also. Active publishers are limited by the maxConcurrency parameter, along with a default limit of 5k queued values before backpressure is applied.

Parameters:

mapper -

Returns:

flatMapP

public <R> ReactiveSeq<R> flatMapP(int maxConcurrency,
                                   QueueFactory<R> factory,
                                   java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

A potentially asynchronous flatMap operation where data from each publisher may arrive out of order (if publishers are configured to publish asynchronously. Active publishers are limited by the maxConcurrency parameter. The QueueFactory parameter can be used to control the maximum queued elements @see QueueFactories

createSeq

protected <X> ReactiveSeq<X> createSeq(java.util.stream.Stream<X> stream)

Specified by:

createSeq in class BaseExtendedStream<T>

filter

public final ReactiveSeq<T> filter(java.util.function.Predicate<? super T> fn)

Description copied from interface: Filters

Keep only elements for which the supplied predicates hold e.g.

  
   
     of(1,2,3).filter(i->i>2);
     
     //[3]
   
 
 

Parameters:

fn - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

filterLazyPredicate

public final ReactiveSeq<T> filterLazyPredicate(java.util.function.Supplier<java.util.function.Predicate<? super T>> fn)

Specified by:

filterLazyPredicate in class BaseExtendedStream<T>

forEach

public void forEach(java.util.function.Consumer<? super T> action)

Description copied from interface: ReactiveSeq

Performs an action for each element of this Stream. For potentially non-blocking analogs see ReactiveSeq.forEachAsync(Consumer) and forEach overloads such as FoldableTraversable.forEach(Consumer, Consumer) and FoldableTraversable.forEach(Consumer, Consumer,Runnable) This method overrides the JDK Stream.forEach(Consumer) and maintains it's blocking semantics. Other forEach overloads in ReactiveSeq are non-blocking for asynchronously executing Streams.

This is a terminal operation.

The behavior of this operation is explicitly nondeterministic. For parallel reactiveStream pipelines, this operation does not guarantee to respect the encounter order of the reactiveStream, as doing so would sacrifice the benefit of parallelism. For any given element, the action may be performed at whatever time and in whatever thread the library chooses. If the action accesses shared state, it is responsible for providing the required synchronization.

Parameters:

action - a non-interfering action to perform on the elements

spliterator

public java.util.Spliterator<T> spliterator()

Description copied from interface: ReactiveSeq

Returns a spliterator for the elements of this reactiveStream.

This is a terminal operation.

Returns:

the element spliterator for this reactiveStream

count

public long count()

Description copied from interface: ReactiveSeq

Returns the count of elements in this reactiveStream. This is a special case of a reduction and is equivalent to:

     return mapToLong(e -> 1L).sum();
 

This is a terminal operation.

Returns:

the count of elements in this reactiveStream

changes

public ReactiveSeq<T> changes()

Returns:

A Stream that contains only changes in the values in the current Stream, useful for converting a Continuous sequence into one with discrete steps

subscribe

public void subscribe(org.reactivestreams.Subscriber<? super T> sub)

onEmpty

public ReactiveSeq<T> onEmpty(T value)

Description copied from interface: OnEmpty

If this Container instance is zero, create a new instance containing the provided value

Returns:

New instance containing value if container is zero, otherwise returns this container

onEmptySwitch

public ReactiveSeq<T> onEmptySwitch(java.util.function.Supplier<? extends java.util.stream.Stream<T>> switchTo)

Description copied from interface: ReactiveSeq

If this ReactiveSeq is empty one it with a another Stream

 
 assertThat(ReactiveSeq.of(4,5,6)
 							.onEmptySwitch(()->ReactiveSeq.of(1,2,3))
 							.toList(),
 							equalTo(Arrays.asList(4,5,6)));
 
 

Parameters:

switchTo - Supplier that will generate the alternative Stream

Returns:

ReactiveSeq that will switch to an alternative Stream if empty

onEmptyGet

public ReactiveSeq<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)

Description copied from interface: OnEmpty

If this Container instance is zero, create a new instance containing the value returned from the provided Supplier

Parameters:

supplier - to determine new value for container

Returns:

New Container with value if this is zero, otherwise this container

onEmptyThrow

public <X extends java.lang.Throwable> ReactiveSeq<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)

Description copied from interface: OnEmpty

If this container instance is zero, throw the exception returned by the provided Supplier

Parameters:

supplier - to create exception from

Returns:

Throw exception if zero, otherwise this container

appendS

public ReactiveSeq<T> appendS(java.util.stream.Stream<? extends T> other)

Description copied from interface: ReactiveSeq

Append Stream to this ReactiveSeq

 
  List<String> result = ReactiveSeq.of(1, 2, 3).appendStream(ReactiveSeq.of(100, 200, 300)).map(it -> it + "!!").collect(CyclopsCollectors.toList());

  assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!")));     * 
 

Returns:

ReactiveSeq with Stream appended

append

public ReactiveSeq<T> append(java.lang.Iterable<? extends T> other)

append

public ReactiveSeq<T> append(T other)

append

public ReactiveSeq<T> append(T... other)

Description copied from interface: ReactiveSeq

Append values to the take of this ReactiveSeq

 
  List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(CyclopsCollectors.toList());

  assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!")));     * 
 

Parameters:

other - to append

Returns:

ReactiveSeq with appended values

prependS

public ReactiveSeq<T> prependS(java.util.stream.Stream<? extends T> other)

Description copied from interface: ReactiveSeq

Prepend Stream to this ReactiveSeq

 
  List<String> result = ReactiveSeq.of(1, 2, 3)
                                   .prependS(of(100, 200, 300))
                                   .map(it -> it + "!!")
                                   .collect(CyclopsCollectors.toList());

  assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
 
 

Parameters:

other - to Prepend

Returns:

ReactiveSeq with Stream prepended

prepend

public ReactiveSeq<T> prepend(java.lang.Iterable<? extends T> other)

prepend

public ReactiveSeq<T> prepend(T other)

prepend

public ReactiveSeq<T> prepend(T... other)

Description copied from interface: ReactiveSeq

Prepend given values to the skip of the Stream

 
 List<String> result = 	ReactiveSeq.of(1,2,3)
 									 .prepend(100,200,300)
 										 .map(it ->it+"!!")
 										 .collect(CyclopsCollectors.toList());

 			assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 

Parameters:

other - to prepend

Returns:

ReactiveSeq with values prepended

distinct

public <U> ReactiveSeq<T> distinct(java.util.function.Function<? super T,? extends U> keyExtractor)

groupedBySizeAndTime

public ReactiveSeq<ListX<T>> groupedBySizeAndTime(int size,
                                                  long time,
                                                  java.util.concurrent.TimeUnit t)

Description copied from interface: ReactiveSeq

Batch elements by size into a List

 
 ReactiveSeq.of(1,2,3,4,5,6)
              .groupedBySizeAndTime(3,10,TimeUnit.SECONDS)
              .toList();

 //[[1,2,3],[4,5,6]]
 
 

Parameters:

size - Max size of a batch

time - (Max) time period to build a singleUnsafe batch in

t - time unit for batch

Returns:

ReactiveSeq batched by size and time

mapLazyFn

public <R> ReactiveSeq<R> mapLazyFn(java.util.function.Supplier<java.util.function.Function<? super T,? extends R>> fn)

Specified by:

mapLazyFn in class BaseExtendedStream<T>

groupedByTime

public ReactiveSeq<ListX<T>> groupedByTime(long time,
                                           java.util.concurrent.TimeUnit t)

Description copied from interface: ReactiveSeq

Batch elements in a Stream by time period

 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6).batchByTime(1,TimeUnit.SECONDS).collect(CyclopsCollectors.toList()).size(),is(1));
 assertThat(ReactiveSeq.of(1,2,3,4,5,6).batchByTime(1,TimeUnit.NANOSECONDS).collect(CyclopsCollectors.toList()).size(),greaterThan(5));
 
 

Parameters:

time - - time period to build a singleUnsafe batch in

t - time unit for batch

Returns:

ReactiveSeq batched into lists by time period

skip

public ReactiveSeq<T> skip(long time,
                           java.util.concurrent.TimeUnit unit)

Description copied from interface: ReactiveSeq

Skip all elements until specified time period has passed

 
  List<Integer> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).peek(i -> sleep(i * 100)).skip(1000, TimeUnit.MILLISECONDS).toList();

  // [4,5,6]


 
 

Parameters:

time - Length of time

unit - Time unit

Returns:

ReactiveSeq that skips all elements until time period has elapsed

limit

public ReactiveSeq<T> limit(long time,
                            java.util.concurrent.TimeUnit unit)

Description copied from interface: ReactiveSeq

Return all elements until specified time period has elapsed

 
  List<Integer> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).peek(i -> sleep(i * 100)).limit(1000, TimeUnit.MILLISECONDS).toList();

  // [1,2,3,4]

 
 

Parameters:

time - Length of time

unit - Time unit

Returns:

ReactiveSeq that returns all elements until time period has elapsed

groupedUntil

public ReactiveSeq<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)

Description copied from interface: ReactiveSeq

Create a ReactiveSeq batched by List, where each batch is populated until the predicate holds

 
  assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .batchUntil(i->i%3==0)
              .toList()
              .size(),equalTo(2));
 
 

Parameters:

predicate - Batch until predicate holds, applyHKT open next batch

Returns:

ReactiveSeq batched into lists determined by the predicate supplied

groupedWhile

public ReactiveSeq<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)

Description copied from interface: ReactiveSeq

Create a ReactiveSeq batched by List, where each batch is populated while the predicate holds

 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .batchWhile(i->i%3!=0)
              .toList().size(),equalTo(2));

 
 

Parameters:

predicate - Batch while predicate holds, applyHKT open next batch

Returns:

ReactiveSeq batched into lists determined by the predicate supplied

groupedWhile

public <C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedWhile(java.util.function.Predicate<? super T> predicate,
                                                                               java.util.function.Supplier<C> factory)

Description copied from interface: ReactiveSeq

Create a ReactiveSeq batched by a Collection, where each batch is populated while the predicate holds

 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .batchWhile(i->i%3!=0)
              .toList()
              .size(),equalTo(2));
 
 

Parameters:

predicate - Batch while predicate holds, applyHKT open next batch

factory - Collection factory

Returns:

ReactiveSeq batched into collections determined by the predicate supplied

groupedUntil

public <C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedUntil(java.util.function.Predicate<? super T> predicate,
                                                                               java.util.function.Supplier<C> factory)

Description copied from interface: ReactiveSeq

Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds

 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
              .batchUntil(i->i%3!=0)
              .toList()
              .size(),equalTo(2));
 
 

Parameters:

predicate - Batch until predicate holds, applyHKT open next batch

factory - Collection factory

Returns:

ReactiveSeq batched into collections determined by the predicate supplied

groupedBySizeAndTime

public <C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedBySizeAndTime(int size,
                                                                                       long time,
                                                                                       java.util.concurrent.TimeUnit unit,
                                                                                       java.util.function.Supplier<C> factory)

Description copied from interface: ReactiveSeq

Batch elements by size into a toX created by the supplied factory

 
 ReactiveSeq.of(1,2,3,4,5,6)
              .groupedBySizeAndTime(3,10,TimeUnit.SECONDS,()->SetX.empty())
              .toList();

 //[[1,2,3],[4,5,6]]
 
 

Parameters:

size - Max size of a batch

time - (Max) time period to build a singleUnsafe batch in

unit - time unit for batch

factory - Collection factory

Returns:

ReactiveSeq batched by size and time

groupedBySizeAndTime

public <C extends java.util.Collection<? super T>,R> ReactiveSeq<R> groupedBySizeAndTime(int size,
                                                                                         long time,
                                                                                         java.util.concurrent.TimeUnit unit,
                                                                                         java.util.function.Supplier<C> factory,
                                                                                         java.util.function.Function<? super C,? extends R> finalizer)

groupedByTime

public <C extends java.util.Collection<? super T>,R> ReactiveSeq<R> groupedByTime(long time,
                                                                                  java.util.concurrent.TimeUnit unit,
                                                                                  java.util.function.Supplier<C> factory,
                                                                                  java.util.function.Function<? super C,? extends R> finalizer)

groupedByTime

public <C extends java.util.Collection<? super T>> ReactiveSeq<C> groupedByTime(long time,
                                                                                java.util.concurrent.TimeUnit unit,
                                                                                java.util.function.Supplier<C> factory)

Description copied from interface: ReactiveSeq

Batch elements by time into a toX created by the supplied factory

 
   assertThat(ReactiveSeq.of(1,1,1,1,1,1)
                       .batchByTime(1500,TimeUnit.MICROSECONDS,()-> new TreeSet<>())
                       .toList()
                       .get(0)
                       .size(),is(1));
 
 

Parameters:

time - - time period to build a singleUnsafe batch in

unit - time unit for batch

factory - Collection factory

Returns:

ReactiveSeq batched into toX types by time period

grouped

public <C extends java.util.Collection<? super T>> ReactiveSeq<C> grouped(int size,
                                                                          java.util.function.Supplier<C> factory)

Description copied from interface: ReactiveSeq

Batch elements in a Stream by size into a toX created by the supplied factory

 
 assertThat(ReactiveSeq.of(1,1,1,1,1,1)
                      .batchBySize(3,()->new TreeSet<>())
                      .toList()
                      .get(0)
                      .size(),is(1));
 
 

Parameters:

size - batch size

factory - Collection factory

Returns:

ReactiveSeq batched into toX types by size

skipLast

public ReactiveSeq<T> skipLast(int num)

Description copied from interface: ReactiveSeq

assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));

Returns:

limitLast

public ReactiveSeq<T> limitLast(int num)

Description copied from interface: ReactiveSeq

Limit results to the last x elements in a ReactiveSeq

 
 	assertThat(ReactiveSeq.of(1,2,3,4,5)
 							.limitLast(2)
 							.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(4,5)));

 

Parameters:

num - of elements to return (last elements)

Returns:

ReactiveSeq limited to last num elements

recover

public ReactiveSeq<T> recover(java.util.function.Function<? super java.lang.Throwable,? extends T> fn)

Description copied from interface: ReactiveSeq

Recover from an exception with an alternative value

 
 assertThat(ReactiveSeq.of(1,2,3,4)
 						   .map(i->i+2)
 						   .map(u->{throw new RuntimeException();})
 						   .recover(e->"hello")
 						   .firstValue(),equalTo("hello"));
 
 

Parameters:

fn - Function that accepts a Throwable and returns an alternative value

Returns:

ReactiveSeq that can recover from an Exception

recover

public <EX extends java.lang.Throwable> ReactiveSeq<T> recover(java.lang.Class<EX> exceptionClass,
                                                               java.util.function.Function<? super EX,? extends T> fn)

Description copied from interface: ReactiveSeq

Recover from a particular exception type

 
 assertThat(ReactiveSeq.of(1,2,3,4)
 					.map(i->i+2)
 					.map(u->{ExceptionSoftener.throwSoftenedException( new IOException()); return null;})
 					.recover(IOException.class,e->"hello")
 					.firstValue(),equalTo("hello"));

 
 

Parameters:

exceptionClass - Type to recover from

fn - That accepts an error and returns an alternative value

Returns:

ReactiveSeq that can recover from a particular exception

forEach

public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(long numberOfElements,
                                                                                java.util.function.Consumer<? super T> consumer)

Description copied from interface: ReactiveStreamsTerminalOperations

Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription e.g.

 
     Subscription next = ReactiveSeq.of(1,2,3,4)
          					    .forEach(2,System.out::println);
          
     System.out.println("First batch processed!");
     
     next.request(2);
     
      System.out.println("Second batch processed!");
      
     //prints
     1
     2
     First batch processed!
     3
     4 
     Second batch processed!
 
 

Parameters:

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming events from the Stream

Returns:

Subscription so that further processing can be continued or cancelled.

forEach

public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(long numberOfElements,
                                                                                java.util.function.Consumer<? super T> consumer,
                                                                                java.util.function.Consumer<? super java.lang.Throwable> consumerError)

Description copied from interface: ReactiveStreamsTerminalOperations

Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription

 
     Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
                                  .map(Supplier::get)
          					    .forEach(2,System.out::println, e->e.printStackTrace());
          
     System.out.println("First batch processed!");
     
     next.request(2);
     
      System.out.println("Second batch processed!");
      
     //prints
     1
     2
     First batch processed!
     
     RuntimeException Stack Trace on System.err
     
     4 
     Second batch processed!
 
 

Parameters:

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

Returns:

Subscription so that further processing can be continued or cancelled.

forEach

public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(long numberOfElements,
                                                                                java.util.function.Consumer<? super T> consumer,
                                                                                java.util.function.Consumer<? super java.lang.Throwable> consumerError,
                                                                                java.lang.Runnable onComplete)

Description copied from interface: ReactiveStreamsTerminalOperations

Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription, when the entire Stream has been processed an onComplete event will be recieved.

 
     Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
                                  .map(Supplier::get)
          					    .forEach(2,System.out::println, e->e.printStackTrace(),()->System.out.println("the take!"));
          
     System.out.println("First batch processed!");
     
     next.request(2);
     
      System.out.println("Second batch processed!");
      
     //prints
     1
     2
     First batch processed!
     
     RuntimeException Stack Trace on System.err
     
     4 
     Second batch processed!
     The take!
 
 

Parameters:

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

onComplete - To run after an onComplete event

Returns:

Subscription so that further processing can be continued or cancelled.

forEach

public <X extends java.lang.Throwable> void forEach(java.util.function.Consumer<? super T> consumerElement,
                                                    java.util.function.Consumer<? super java.lang.Throwable> consumerError)

Description copied from interface: ReactiveStreamsTerminalOperations

Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,

 
     Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
                                  .map(Supplier::get)
          					    .forEach(System.out::println, e->e.printStackTrace());
          
     System.out.println("processed!");
     
    
      
     //prints
     1
     2
     RuntimeException Stack Trace on System.err
     4
     processed!
     
 
 

Parameters:

consumerElement - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

forEach

public <X extends java.lang.Throwable> void forEach(java.util.function.Consumer<? super T> consumerElement,
                                                    java.util.function.Consumer<? super java.lang.Throwable> consumerError,
                                                    java.lang.Runnable onComplete)

Description copied from interface: ReactiveStreamsTerminalOperations

Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.

 
     Subscription next = ReactiveSeq.of(()->1,()->2,()->throw new RuntimeException(),()->4)
                                  .map(Supplier::get)
          					    .forEachEvents(System.out::println, e->e.printStackTrace(),()->System.out.println("the take!"));
          
     System.out.println("processed!");
     
      
     //prints
     1
     2
     RuntimeException Stack Trace on System.err
      4 
     processed!
     
     
 
 

Parameters:

consumerElement - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

onComplete - To run after an onComplete event

format

public java.lang.String format()

collectors

public org.jooq.lambda.Collectable<T> collectors()

Description copied from interface: CyclopsCollectable

Narrow this class to a Collectable

Returns:

Collectable

unitIterator

public <T> ReactiveSeq<T> unitIterator(java.util.Iterator<T> it)

Description copied from interface: Traversable

Create an IterableFunctor instance of the same type from an Iterator

 
       ReactiveSeq<Integer> newSeq = seq.unitIterable(myIterator);

 
 

Parameters:

it - Iterator to create new IterableFunctor from

Returns:

New IterableFunctor instance