com.aol.cyclops2.internal.stream

Class OneShotStreamX<T>

java.lang.Object

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

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

com.aol.cyclops2.internal.stream.OneShotStreamX<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 OneShotStreamX<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
OneShotStreamX(java.util.Spliterator<T> stream, java.util.Optional<ReversableSpliterator> rev)
OneShotStreamX(java.util.stream.Stream<T> stream)
OneShotStreamX(java.util.stream.Stream<T> stream, java.util.Optional<ReversableSpliterator> rev)

Method Summary

Modifier and Type	Method and Description
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
ReactiveSeq<T>	cycleUntil(java.util.function.Predicate<? super T> predicate) Repeat in a Stream until specified predicate holds
ReactiveSeq<T>	cycleWhile(java.util.function.Predicate<? super T> predicate) Repeat in a Stream while specified predicate holds
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)
ListX<ReactiveSeq<T>>	multicast(int num) Broadcast the contents of this Stream to multiple downstream Streams (determined by supplier parameter).
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, combine, concat, concat, concat, concat, concatDoubles, concatInts, concatLongs, coproduct, crossJoin, cycle, 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, 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

OneShotStreamX

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

OneShotStreamX

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

OneShotStreamX

public OneShotStreamX(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)));  

cycle

public final 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 final 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 final org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> duplicate(java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

triplicate

public final 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();

 
 

triplicate

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

quadruplicate

public final 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

quadruplicate

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

multicast

public ListX<ReactiveSeq<T>> multicast(int num)

Description copied from interface: ReactiveSeq

Broadcast the contents of this Stream to multiple downstream Streams (determined by supplier parameter). For pull based Streams this Stream will be buffered. For push based Streams elements are broadcast downstream on receipt, the emitted downstream Streams remain asynchonous This contrasts with ReactiveSeq.duplicate() ReactiveSeq#triplate ReactiveSeq.quadruplicate() Which buffer all Stream types and produce a synchronous downstream stream.

Parameters:

num - Number of downstream Streams to multicast to

Returns:

List of Streams that recieve data from this Stream

splitAtHead

public final 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 final 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 final 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 final 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]
 

 

cycleWhile

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

Description copied from interface: ReactiveSeq

Repeat in a Stream while specified predicate holds

 

 	MutableInt count = MutableInt.of(0);
 	ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6)
             .collect(CyclopsCollectors.toList());

 	// List(1,2,2,1,2,2)
 
 

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

cycleUntil

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

Description copied from interface: ReactiveSeq

Repeat in a Stream until specified predicate holds

 
 	MutableInt count =MutableInt.of(0);
 		ReactiveSeq.of(1,2,2)
 		 		.cycleUntil(next -> count.get()>6)
 		 		.peek(i-> count.mutate(i->i+1))
 		 		.collect(CyclopsCollectors.toList());

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

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

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)