com.aol.cyclops2.internal.stream

Class StreamX<T>

java.lang.Object

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

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

com.aol.cyclops2.internal.stream.StreamX<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>

public class StreamX<T>
extends SpliteratorBasedStream<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
StreamX(java.util.Spliterator<T> stream, java.util.Optional<ReversableSpliterator> rev)
StreamX(java.util.stream.Stream<T> stream)
StreamX(java.util.stream.Stream<T> stream, java.util.Optional<ReversableSpliterator> rev)

Method Summary

Modifier and Type	Method and Description
ReactiveSeq<T>	combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op) Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
ReactiveSeq<T>	cycle() Convert to a Stream with the values infinitely cycled
ReactiveSeq<T>	cycle(long times) Convert to a Stream with the values repeated specified times
org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>	duplicate() Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading reactiveStream.
org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>	duplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>	partition(java.util.function.Predicate<? super T> splitter) Partition a Stream into two one a per element basis, based on predicate's boolean value
org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>	quadruplicate() Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading reactiveStream.
org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>	quadruplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
ReactiveSeq<T>	reverse() Potentially efficient Stream reversal.
org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>	splitAt(int where) Split at supplied location
org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,ReactiveSeq<T>>	splitAtHead() Split a Stream at it's head (similar to headAndTail)
org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>	splitBy(java.util.function.Predicate<T> splitter) Split reactiveStream at point where predicate no longer holds
org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>	triplicate() Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading reactiveStream.
org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>>	triplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
<R> R	visit(java.util.function.Function<? super ReactiveSeq<T>,? extends R> sync, java.util.function.Function<? super ReactiveSeq<T>,? extends R> reactiveStreams, java.util.function.Function<? super ReactiveSeq<T>,? extends R> asyncNoBackPressure)

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

append, append, append, appendS, changes, coflatMap, collectors, collectSeq, complete, count, createSeq, distinct, distinct, filter, filterLazyPredicate, findFirst, findFirstOrError, findOne, flatMap, flatMapAnyM, flatMapI, flatMapP, flatMapP, flatMapP, forEach, forEach, forEach, forEach, forEach, forEach, format, grouped, grouped, groupedBySizeAndTime, groupedBySizeAndTime, groupedBySizeAndTime, groupedByTime, groupedByTime, groupedByTime, groupedStatefullyUntil, groupedStatefullyUntil, groupedStatefullyWhile, groupedStatefullyWhile, groupedUntil, groupedUntil, groupedWhile, groupedWhile, iterator, limit, limit, limitLast, limitUntil, limitWhile, limitWhileClosed, map, mapLazyFn, onEmpty, onEmptyGet, onEmptySwitch, onEmptyThrow, peek, prepend, prepend, prepend, prependS, recover, recover, reduce, reduce, scanLeft, skip, skip, skipLast, skipUntil, skipWhile, skipWhileClosed, sliding, spliterator, subscribe, unit, unitIterator, unwrapStream, zip3, zip3, zip4, zip4, zipS, zipS

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, concat, concat, concat, concat, concatDoubles, concatInts, concatLongs, coproduct, crossJoin, cycle, cycleUntil, cycleWhile, deferred, deferredI, deferredP, deleteBetween, doubles, drop, dropRight, dropUntil, dropWhile, 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, pausableHotStream, permutations, permutationsT, primedHotStream, primedPausableHotStream, print, print, printErr, printOut, product, product, publishTo, publishTo, range, range, rangeLong, rangeLong, reactiveSeq, reduce, reduceAll, remove, removeAll, removeAllI, removeAllS, retainAll, retainAllI, retainAllS, retry, retry, reversedListOf, reversedOf, scanLeft, scanRight, scanRight, schedule, scheduleFixedDelay, scheduleFixedRate, seq, shuffle, shuffle, single, single, singleUnsafe, size, skipDoubles, skipInts, skipLongs, skipUntilClosed, slice, sliding, sorted, sorted, sorted, subStream, tailRec, take, takeOne, takeRight, takeUntil, takeWhile, timestamp, trampoline, unfold, unzip, unzip3, unzip4, 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

StreamX

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

StreamX

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

StreamX

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

Method Detail

reverse

public ReactiveSeq<T> reverse()

Description copied from interface: Traversable

Potentially efficient Stream reversal. Is efficient if - Sequence created via a range - Sequence created via a List - Sequence created via an Array / var args Otherwise Sequence collected into a Collection prior to reversal

  assertThat( of(1, 2, 3).reverse().toList(),
 equalTo(asList(3, 2, 1)));  

combine

public ReactiveSeq<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
                              java.util.function.BinaryOperator<T> op)

Description copied from interface: Traversable

Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The emitted of a combination may in turn be combined with it's neighbour

  
  ReactiveSeq.of(1,1,2,3)
                   .combine((a, b)->a.equals(b),SemigroupK.intSum)
                   .listX()
                   
  //ListX(3,4) 
 

Parameters:

predicate - Test to see if two neighbours should be joined. The first parameter to the bi-predicate is the currently accumulated result and the second is the next element

op - BinaryOperator to combine neighbours

Returns:

Combined / Partially Reduced Traversable

cycle

public ReactiveSeq<T> cycle()

Description copied from interface: ReactiveSeq

Convert to a Stream with the values infinitely cycled

 
      ReactiveSeq.of(1).cycle().limit(6).toList());
      //List[1, 1, 1, 1, 1,1]
   
 

Returns:

Stream with values repeated

duplicate

public org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> duplicate()

Description copied from interface: ReactiveSeq

Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading reactiveStream. Not thread-safe.

 

 	Tuple2<ReactiveSeq<Integer>, ReactiveSeq<Integer>> copies = of(1, 2, 3, 4, 5, 6)
                                                                  .duplicate();
 	assertTrue(copies.v1.anyMatch(i > i == 2));
 	assertTrue(copies.v2.anyMatch(i > i == 2));

 
 

Returns:

duplicated reactiveStream

duplicate

public org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> duplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

triplicate

public org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> triplicate()

Description copied from interface: ReactiveSeq

Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading reactiveStream. Not thread-safe.

 
 	Tuple3<ReactiveSeq<Tuple3<T1, T2, T3>>, ReactiveSeq<Tuple3<T1, T2, T3>>, ReactiveSeq<Tuple3<T1, T2, T3>>> Tuple3 = sequence.triplicate();

 
 

quadruplicate

public org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> quadruplicate()

Description copied from interface: ReactiveSeq

Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading reactiveStream. Not thread-safe.

 
 	Tuple4<ReactiveSeq<Tuple4<T1, T2, T3, T4>>,
          ReactiveSeq<Tuple4<T1, T2, T3, T4>>,
          ReactiveSeq<Tuple4<T1, T2, T3, T4>>,
          ReactiveSeq<Tuple4<T1, T2, T3, T4>>> quad = sequence.quadruplicate();

 
 

Returns:

Tuple4 containing 4 duplicated ReactiveSeqs

triplicate

public org.jooq.lambda.tuple.Tuple3<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> triplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

quadruplicate

public org.jooq.lambda.tuple.Tuple4<ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>,ReactiveSeq<T>> quadruplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

splitAtHead

public org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,ReactiveSeq<T>> splitAtHead()

Description copied from interface: ReactiveSeq

Split a Stream at it's head (similar to headAndTail)

 
 ReactiveSeq.of(1,2,3)
            .splitAtHead()

  //Optional[1], ReactiveSeq[2,3]
 

 

splitAt

public org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> splitAt(int where)

Description copied from interface: ReactiveSeq

Split at supplied location

 
 ReactiveSeq.of(1,2,3)
            .splitAt(1)

  //ReactiveSeq[1], ReactiveSeq[2,3]
 

 

splitBy

public org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> splitBy(java.util.function.Predicate<T> splitter)

Description copied from interface: ReactiveSeq

Split reactiveStream at point where predicate no longer holds

 
   ReactiveSeq.of(1, 2, 3, 4, 5, 6).splitBy(i->i<4)

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

partition

public org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> partition(java.util.function.Predicate<? super T> splitter)

Description copied from interface: ReactiveSeq

Partition a Stream into two one a per element basis, based on predicate's boolean value

 
  ReactiveSeq.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0)

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

 

cycle

public ReactiveSeq<T> cycle(long times)

Description copied from interface: ReactiveSeq

Convert to a Stream with the values repeated specified times

 
 		ReactiveSeq.of(1,2,2)
 								.cycle(3)
 								.collect(CyclopsCollectors.toList());

 		//List[1,2,2,1,2,2,1,2,2]

 
 

Parameters:

times - Times values should be repeated within a Stream

Returns:

Stream with values repeated

visit

public <R> R visit(java.util.function.Function<? super ReactiveSeq<T>,? extends R> sync,
                   java.util.function.Function<? super ReactiveSeq<T>,? extends R> reactiveStreams,
                   java.util.function.Function<? super ReactiveSeq<T>,? extends R> asyncNoBackPressure)