SimpleReactStream (cyclops-react 2.0.0-MI1 API)

All Superinterfaces:: BaseSimpleReactStream, BlockingStream, ConfigurableStream<U,java.util.concurrent.CompletableFuture>, ToQueue

public interface SimpleReactStream<U>
extends BaseSimpleReactStream<U>, BlockingStream<U>, ConfigurableStream<U,java.util.concurrent.CompletableFuture<U>>, ToQueue<U>

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <R1,R2> SimpleReactStream<R2>`	`allOf(java.util.stream.Collector<? super U,?,R1> collector, java.util.function.Function<? super R1,? extends R2> fn)`
`default <R> SimpleReactStream<R>`	`allOf(java.util.function.Function<? super java.util.List<U>,? extends R> fn)` React and allOf allOf is a non-blocking equivalent of block.
`default <R> SimpleReactStream<R>`	`anyOf(java.util.function.Function<? super U,? extends R> fn)` React to the completion of any of the events in the previous stage.
`static SimpleReactFailedStageException`	`assureSimpleReactException(java.lang.Throwable throwable)`
`default SimpleReactStream<U>`	`async()`
`static <U,R> SimpleReactStream<R>`	`bind(SimpleReactStream<U> stream, java.util.function.Function<U,BaseSimpleReactStream<R>> flatFn)` flatMap / bind implementation that returns the correct type (SimpleReactStream)
`default <A,R> R`	`block(java.util.stream.Collector<? super U,A,R> collector, java.util.function.Predicate<Status<U>> breakout)`
`default ListX<U>`	`block(java.util.function.Predicate<Status<U>> breakout)` React and block with breakout Sometimes you may not need to block until all the work is complete, one result or a subset may be enough.
`default void`	`cancel()` Cancel the CompletableFutures in this stage of the stream
`default SimpleReactStream<U>`	`capture(java.util.function.Consumer<java.lang.Throwable> errorHandler)` React capture While onFail is used for disaster recovery (when it is possible to recover) - capture is used to capture those occasions where the full pipeline has failed and is unrecoverable.
`default <T2> org.jooq.lambda.Seq<org.jooq.lambda.tuple.Tuple2<U,T2>>`	`combineLatest(SimpleReactStream<T2> right)`
`default FutureStream<U>`	`convertToLazyStream()` Convert between an Lazy and Eager future stream, can be used to take advantages of each approach during a single Stream
`default ListX<SimpleReactStream<U>>`	`copySimpleReactStream(int times)`
`default org.jooq.lambda.tuple.Tuple2<SimpleReactStream<U>,SimpleReactStream<U>>`	`duplicate()` Duplicate a Stream into two equivalent LazyFutureStreams, underlying Stream of Futures is duplicated
`default SimpleReactStream<U>`	`filter(java.util.function.Predicate<? super U> p)` Removes elements that do not match the supplied predicate from the dataflow
`default SimpleReactStream<U>`	`filterSync(java.util.function.Predicate<? super U> p)` Synchronous filtering operation Removes elements that do not match the supplied predicate from the dataflow
`static <U> SimpleReactStream<U>`	`firstOf(SimpleReactStream<U>... futureStreams)` Return first Stream out of provided Streams that starts emitted results
`default <R> SimpleReactStream<R>`	`flatMap(java.util.function.Function<? super U,? extends java.util.stream.Stream<? extends R>> flatFn)` Allows aggregate values in a Stream to be flatten into a single Stream.
`default <R> SimpleReactStream<R>`	`flatMapToCompletableFuture(java.util.function.Function<? super U,java.util.concurrent.CompletableFuture<? extends R>> flatFn)` Perform a flatMap operation where the CompletableFuture type returned is flattened from the resulting Stream If in async mode this operation is performed asyncrhonously If in sync mode this operation is performed synchronously
`default <R> SimpleReactStream<R>`	`flatMapToCompletableFutureSync(java.util.function.Function<? super U,java.util.concurrent.CompletableFuture<? extends R>> flatFn)` Perform a flatMap operation where the CompletableFuture type returned is flattened from the resulting Stream This operation is performed synchronously
`default <R> SimpleReactStream<R>`	`fromListCompletableFuture(java.util.List<java.util.concurrent.CompletableFuture<R>> list)`
`default <R> SimpleReactStream<R>`	`fromStream(java.util.stream.Stream<R> stream)`
`default <R> SimpleReactStream<R>`	`fromStreamCompletableFutureReplace(java.util.stream.Stream<java.util.concurrent.CompletableFuture<R>> stream)`
`default <R> SimpleReactStream<R>`	`fromStreamOfFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<R>> stream)` Construct a SimpleReactStream from provided Stream of CompletableFutures
`com.aol.cyclops2.internal.react.stream.EagerStreamWrapper`	`getLastActive()`
`SimpleReact`	`getSimpleReact()`
`Continueable`	`getSubscription()`
`static <U,R> java.util.function.Function<U,R>`	`handleExceptions(java.util.function.Function<? super U,? extends R> fn)`
`static <U,R> SimpleReactStream<R>`	`join(SimpleReactStream<BaseSimpleReactStream<U>> stream)` flatten nested SimpleReactStreams
`static java.util.concurrent.CompletableFuture[]`	`lastActiveArray(com.aol.cyclops2.internal.react.stream.EagerStreamWrapper lastActive)`
`default SimpleReactStream<U>`	`limit(long maxSize)` Perform a limit operation on the underlying Stream of Futures In contrast to EagerFutureStream#limit this removes entries basaed on their skip position
`default SimpleReactStream<U>`	`merge(SimpleReactStream<U>... s)`
`static <R> SimpleReactStream<R>`	`merge(SimpleReactStream s1, SimpleReactStream s2)` Merge this reactive dataflow with another - recommended for merging different types.
`default SimpleReactStream<U>`	`onFail(java.lang.Class<? extends java.lang.Throwable> exceptionClass, java.util.function.Function<? super SimpleReactFailedStageException,? extends U> fn)` Recover for a particular class of exceptions only.
`default SimpleReactStream<U>`	`onFail(java.util.function.Function<? super SimpleReactFailedStageException,? extends U> fn)` React onFail Define a function that can be used to recover from exceptions during the preceeding stage of the dataflow.
`default SimpleReactStream<U>`	`peek(java.util.function.Consumer<? super U> consumer)` Peek asynchronously at the results in the current stage.
`default SimpleReactStream<U>`	`peekSync(java.util.function.Consumer<? super U> consumer)` Synchronous peek operator
`default <R> SimpleReactStream<R>`	`retry(java.util.function.Function<? super U,? extends R> fn)` Will execute this phase on the RetryExecutor (default or user supplied).
`default SimpleReactStream<U>`	`reverse()` Reversed, operating on the underlying futures.
`default void`	`run()`
`default SimpleReactStream<U>`	`self(java.util.function.Consumer<SimpleReactStream<U>> consumer)` Give a function access to the current stage of a SimpleReact Stream
`default SimpleReactStream<U>`	`skip(long n)` In contast to EagerFutureStream#skip skipFutures will skip the first n entries of the underlying Stream of Futures.
`default <T> ReactiveSeq<U>`	`skipUntil(SimpleReactStream<T> s)` Return a Stream with the same values as this Stream, but with all values omitted until the provided stream starts emitting values.
`default SimpleReactStream<U>`	`slice(long from, long to)` Returns a limited interval from a given Stream.
`default org.jooq.lambda.tuple.Tuple2<SimpleReactStream<U>,SimpleReactStream<U>>`	`splitAt(long position)` Split a stream at a given position.
`default <T> java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>>`	`streamCompletableFutures()`
`default SimpleReactStream<U>`	`sync()`
`default <T> ReactiveSeq<U>`	`takeUntil(SimpleReactStream<T> s)` Return a Stream with the same values, but will stop emitting values once the provided Stream starts to emit values.
`default <R> SimpleReactStream<R>`	`then(java.util.function.Function<? super U,? extends R> fn)` React transform Unlike 'with' this method is fluent, and returns another Stage Builder that can represent the next stage in the dataflow.
`default <R> SimpleReactStream<R>`	`then(java.util.function.Function<? super U,? extends R> fn, java.util.concurrent.Executor service)`
`default <R> SimpleReactStream<R>`	`thenSync(java.util.function.Function<? super U,? extends R> fn)`
`default <R> java.util.List<java.util.concurrent.CompletableFuture<R>>`	`with(java.util.function.Function<? super U,? extends R> fn)` React with Asynchronously apply the function supplied to the currently active event tasks in the dataflow.
`SimpleReactStream<U>`	`withAsync(boolean b)`
`SimpleReactStream<U>`	`withErrorHandler(java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)`
`SimpleReactStream<U>`	`withLastActive(com.aol.cyclops2.internal.react.stream.EagerStreamWrapper streamWrapper)`
`default <T2> org.jooq.lambda.Seq<org.jooq.lambda.tuple.Tuple2<U,T2>>`	`withLatest(SimpleReactStream<T2> right)`
`SimpleReactStream<U>`	`withQueueFactory(QueueFactory<U> queue)`
`SimpleReactStream<U>`	`withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)`
`SimpleReactStream<U>`	`withSubscription(Continueable sub)`
`SimpleReactStream<U>`	`withTaskExecutor(java.util.concurrent.Executor e)`
`default <R> SimpleReactStream<org.jooq.lambda.tuple.Tuple2<U,R>>`	`zip(SimpleReactStream<R> other)` Zip two Streams, zipping against the underlying futures of both Streams Placeholders (Futures) will be populated immediately in the new zipped Stream and results will be populated asyncrhonously
`default <R> SimpleReactStream<org.jooq.lambda.tuple.Tuple2<U,R>>`	`zip(java.util.stream.Stream<R> other)` Zip two Streams, zipping against the underlying futures of this stream
`default SimpleReactStream<org.jooq.lambda.tuple.Tuple2<U,java.lang.Long>>`	`zipWithIndex()` Zip this Stream with an index, but Zip based on the underlying tasks, not completed results.

Methods inherited from interface com.aol.cyclops2.types.futurestream.BaseSimpleReactStream
cast, empty, freeThread, freeThread, getQueueFactory, getTaskExecutor, intersperse, isAsync, iterator, of, of, ofType, parallel, react, react, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStreamFrom, simpleReactStreamFromIterable, toQueue

Methods inherited from interface com.aol.cyclops2.types.futurestream.BlockingStream
block, block, getErrorHandler

Methods inherited from interface com.aol.cyclops2.types.futurestream.ConfigurableStream
getErrorHandler, getRetrier, getTaskExecutor, isAsync

Methods inherited from interface com.aol.cyclops2.types.futurestream.ToQueue
addToQueue, getQueueFactory, toQueue, toQueue, toQueue

- Method Detail
 - getSimpleReact
```
SimpleReact getSimpleReact()
```
 Specified by:
 
 getSimpleReact in interface BaseSimpleReactStream
 
 Specified by:
 
 getSimpleReact in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 - withLastActive
```
SimpleReactStream withLastActive(com.aol.cyclops2.internal.react.stream.EagerStreamWrapper streamWrapper)
```
 - getLastActive
```
com.aol.cyclops2.internal.react.stream.EagerStreamWrapper getLastActive()
```
 Specified by:
 
 getLastActive in interface BaseSimpleReactStream
 
 Specified by:
 
 getLastActive in interface BlockingStream
 - withTaskExecutor
```
SimpleReactStream withTaskExecutor(java.util.concurrent.Executor e)
```
 Specified by:
 
 withTaskExecutor in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 - withRetrier
```
SimpleReactStream withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)
```
 Specified by:
 
 withRetrier in interface BaseSimpleReactStream
 
 Specified by:
 
 withRetrier in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 - withQueueFactory
```
SimpleReactStream withQueueFactory(QueueFactory queue)
```
 Specified by:
 
 withQueueFactory in interface BaseSimpleReactStream
 
 Specified by:
 
 withQueueFactory in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 - withErrorHandler
```
SimpleReactStream withErrorHandler(java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)
```
 Specified by:
 
 withErrorHandler in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 - withSubscription
```
SimpleReactStream withSubscription(Continueable sub)
```
 Specified by:
 
 withSubscription in interface BaseSimpleReactStream
 
 Specified by:
 
 withSubscription in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 - withAsync
```
SimpleReactStream withAsync(boolean b)
```
 Specified by:
 
 withAsync in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 - getSubscription
```
Continueable getSubscription()
```
 Specified by:
 
 getSubscription in interface BaseSimpleReactStream
 - combineLatest
```
default <T2> org.jooq.lambda.Seq<org.jooq.lambda.tuple.Tuple2<U,T2>> combineLatest(SimpleReactStream<T2> right)
```
 - withLatest
```
default <T2> org.jooq.lambda.Seq<org.jooq.lambda.tuple.Tuple2<U,T2>> withLatest(SimpleReactStream<T2> right)
```
 - self
```
default SimpleReactStream self(java.util.function.Consumer<SimpleReactStream> consumer)
```
 Give a function access to the current stage of a SimpleReact Stream
 
 Parameters:
 
 consumer - Consumer that will recieve current stage
 
 Returns:
 
 Self (current stage)
 - run
```
default void run()
```
 - splitAt
```
default org.jooq.lambda.tuple.Tuple2<SimpleReactStream,SimpleReactStream> splitAt(long position)
```
 Split a stream at a given position. (Operates on futures)
```
 
 // tuple((1, 2, 3), (4, 5, 6))
 EagerFutureStream.of(1, 2, 3, 4, 5,6).splitAt(3)

 
```
 Returns:
 - duplicate
```
default org.jooq.lambda.tuple.Tuple2<SimpleReactStream,SimpleReactStream> duplicate()
```
 Duplicate a Stream into two equivalent LazyFutureStreams, underlying Stream of Futures is duplicated
```
 
 EagerFutureStream.of(1, 2, 3).duplicate()

 results in

 tuple((1,2,3),(1,2,3))
 
```
 Care should be taken not to use this method with infinite streams!
 Returns:
 
 Two equivalent Streams
 
 See Also:
 
 duplicate()
 - zip
```
default <R> SimpleReactStream<org.jooq.lambda.tuple.Tuple2<U,R>> zip(java.util.stream.Stream<R> other)
```
 Zip two Streams, zipping against the underlying futures of this stream
 
 Parameters:
 
 other -
 
 Returns:
 - zip
```
default <R> SimpleReactStream<org.jooq.lambda.tuple.Tuple2<U,R>> zip(SimpleReactStream<R> other)
```
 Zip two Streams, zipping against the underlying futures of both Streams Placeholders (Futures) will be populated immediately in the new zipped Stream and results will be populated asyncrhonously
 
 Parameters:
 
 other - Another FutureStream to zip Futures with
 
 Returns:
 
 New Sequence of CompletableFutures
 - zipWithIndex
```
default SimpleReactStream<org.jooq.lambda.tuple.Tuple2<U,java.lang.Long>> zipWithIndex()
```
 Zip this Stream with an index, but Zip based on the underlying tasks, not completed results. e.g. two function that return method name, but take varying lengths of time.
```
 
 EagerFutureStream.react(()->takesALotOfTime(),()->veryQuick()).zipWithIndex();

 [["takesALotOfTime",0],["veryQuick",1]]

 Where as with standard zipWithIndex you would get a new Stream ordered by completion

 [["veryQuick",0],["takesALotOfTime",1]]
 
 
```
 - firstOf
```
@SafeVarargs
static  SimpleReactStream firstOf(SimpleReactStream... futureStreams)
```
 Return first Stream out of provided Streams that starts emitted results
 
 Parameters:
 
 futureStreams - Streams to race
 
 Returns:
 
 First Stream to skip emitting values
 - reverse
```
default SimpleReactStream reverse()
```
 Reversed, operating on the underlying futures.
```
 

 // (3, 2, 1) EagerFutureStream.of(1, 2, 3).reverse()
 
```
 Returns:
 - slice
```
default SimpleReactStream slice(long from,
 long to)
```
 Returns a limited interval from a given Stream.
```
 
 // (4, 5) EagerFutureStream.of(1, 2, 3, 4, 5, 6).sliceFutures(3, 5)
 
```
 See Also:
 
 slice(long, long)
 - limit
```
default SimpleReactStream limit(long maxSize)
```
 Perform a limit operation on the underlying Stream of Futures In contrast to EagerFutureStream#limit this removes entries basaed on their skip position
```
 
 EagerFutureStream.of(()>loadSlow(),()>loadMedium(),()>loadFast())
 				.limitFutures(2)
 

 //[loadSlow, loadMedium]
 
```
 Parameters:
 
 maxSize - The size of the subsequent Stream
 
 Returns:
 
 limited Stream
 - skip
```
default SimpleReactStream skip(long n)
```
 In contast to EagerFutureStream#skip skipFutures will skip the first n entries of the underlying Stream of Futures.
```
 
 EagerFutureStream.of(()>loadSlow(),()>loadMedium(),()>loadFast())
 				.skip(2)
 

 //[loadFast]
 
```
 Specified by:
 
 skip in interface BaseSimpleReactStream
 
 Parameters:
 
 n -
 
 Returns:
 - skipUntil
```
default <T> ReactiveSeq skipUntil(SimpleReactStream<T> s)
```
 Return a Stream with the same values as this Stream, but with all values omitted until the provided stream starts emitting values. Provided Stream ends the stream of values from this stream.
 
 Parameters:
 
 s - Stream that will skip the emission of values from this stream
 
 Returns:
 
 Next stage in the Stream but with all values skipped until the provided Stream starts emitting
 - takeUntil
```
default <T> ReactiveSeq takeUntil(SimpleReactStream<T> s)
```
 Return a Stream with the same values, but will stop emitting values once the provided Stream starts to emit values. e.g. if the provided Stream is asynchronously refreshing state from some remote store, this stream can proceed until the provided Stream succeeds in retrieving data.
 
 Parameters:
 
 s - Stream that will stop the emission of values from this stream
 
 Returns:
 
 Next stage in the Stream but will only emit values until provided Stream starts emitting values
 - cancel
```
default void cancel()
```
 Cancel the CompletableFutures in this stage of the stream
 - copySimpleReactStream
```
default ListX<SimpleReactStream> copySimpleReactStream(int times)
```
 - then
```
default <R> SimpleReactStream<R> then(java.util.function.Function<? super U,? extends R> fn,
 java.util.concurrent.Executor service)
```
 Specified by:
 
 then in interface BaseSimpleReactStream
 - thenSync
```
default <R> SimpleReactStream<R> thenSync(java.util.function.Function<? super U,? extends R> fn)
```
 Specified by:
 
 thenSync in interface BaseSimpleReactStream
 - allOf
```
default <R1,R2> SimpleReactStream<R2> allOf(java.util.stream.Collector<? super U,?,R1> collector,
 java.util.function.Function<? super R1,? extends R2> fn)
```
 Parameters:
 
 collector - to perform aggregation / reduction operation on the results from active stage (e.g. to Collect into a List or String)
 
 fn - Function that receives the results of all currently active tasks as input
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - anyOf
```
default <R> SimpleReactStream<R> anyOf(java.util.function.Function<? super U,? extends R> fn)
```
 React to the completion of any of the events in the previous stage. Will not work reliably with Streams where filter has been applied in earlier stages. (As Filter completes the Stream for events that are filtered out, they potentially shortcircuit the completion of the stage).
 
 Parameters:
 
 fn - Function to apply when any of the previous events complete
 
 Returns:
 
 Next stage in the stream
 - lastActiveArray
```
static java.util.concurrent.CompletableFuture[] lastActiveArray(com.aol.cyclops2.internal.react.stream.EagerStreamWrapper lastActive)
```
 - retry
```
default <R> SimpleReactStream<R> retry(java.util.function.Function<? super U,? extends R> fn)
```
 Will execute this phase on the RetryExecutor (default or user supplied). The RetryExecutor can be changed via withRetrier. This stage will be retried according to the configured rules. See https://github.com/nurkiewicz/async-retry for detailed advice on how to conifugre
 
 Specified by:
 
 retry in interface BaseSimpleReactStream
 
 Parameters:
 
 fn - Function that will be executed and retried on failure
 
 Returns:
 
 Next Stage in the Strea,
 - fromStream
```
default <R> SimpleReactStream<R> fromStream(java.util.stream.Stream<R> stream)
```
 Specified by:
 
 fromStream in interface BaseSimpleReactStream
 - fromStreamOfFutures
```
default <R> SimpleReactStream<R> fromStreamOfFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<R>> stream)
```
 Construct a SimpleReactStream from provided Stream of CompletableFutures
 
 Parameters:
 
 stream - JDK Stream to construct new SimpleReactStream from
 
 Returns:
 
 SimpleReactStream
 - fromStreamCompletableFutureReplace
```
default <R> SimpleReactStream<R> fromStreamCompletableFutureReplace(java.util.stream.Stream<java.util.concurrent.CompletableFuture<R>> stream)
```
 - fromListCompletableFuture
```
default <R> SimpleReactStream<R> fromListCompletableFuture(java.util.List<java.util.concurrent.CompletableFuture<R>> list)
```
 - then
```
default <R> SimpleReactStream<R> then(java.util.function.Function<? super U,? extends R> fn)
```
 React transform Unlike 'with' this method is fluent, and returns another Stage Builder that can represent the next stage in the dataflow.
```
 
 new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3)
 .transform((it) -> it * 100)
 .transform((it) -> "*" + it)
 
 
 
```
 React transform allows event reactors to be chained. Unlike React with, which returns a collection of Future references, React transform is a fluent interface that returns the React builder - allowing further reactors to be added to the chain. React transform does not block. React with can be called after React transform which gives access to the full CompleteableFuture api. CompleteableFutures can be passed back into SimpleReact via SimpleReact.react(streamOfCompleteableFutures); See this blog post for examples of what can be achieved via CompleteableFuture :- http://www.nurkiewicz.com/2013/12/promises-and-completablefuture.htm l
 Specified by:
 
 then in interface BaseSimpleReactStream
 
 Parameters:
 
 fn - Function to be applied to the results of the currently active event tasks
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - peek
```
default SimpleReactStream peek(java.util.function.Consumer<? super U> consumer)
```
 Peek asynchronously at the results in the current stage. Current results are passed through to the next stage.
 
 Specified by:
 
 peek in interface BaseSimpleReactStream
 
 Parameters:
 
 consumer - That will recieve current results
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - peekSync
```
default SimpleReactStream peekSync(java.util.function.Consumer<? super U> consumer)
```
 Synchronous peek operator
 
 Specified by:
 
 peekSync in interface BaseSimpleReactStream
 
 Parameters:
 
 consumer - Peek consumer
 
 Returns:
 
 Next stage
 - handleExceptions
```
static <U,R> java.util.function.Function<U,R> handleExceptions(java.util.function.Function<? super U,? extends R> fn)
```
 - flatMapToCompletableFuture
```
default <R> SimpleReactStream<R> flatMapToCompletableFuture(java.util.function.Function<? super U,java.util.concurrent.CompletableFuture<? extends R>> flatFn)
```
 Perform a flatMap operation where the CompletableFuture type returned is flattened from the resulting Stream If in async mode this operation is performed asyncrhonously If in sync mode this operation is performed synchronously
```
 
 assertThat( new SimpleReact()
 .of(1,2,3)
 .flatMapCompletableFuture(i->CompletableFuture.completedFuture(i))
 .block(),equalTo(Arrays.asList(1,2,3)));
 
 
```
 In this example the result of the flatMapCompletableFuture is 'flattened' to the raw integer values
 Specified by:
 
 flatMapToCompletableFuture in interface BaseSimpleReactStream
 
 Parameters:
 
 flatFn - flatMap function
 
 Returns:
 
 Flatten Stream with flatFn applied
 - flatMapToCompletableFutureSync
```
default <R> SimpleReactStream<R> flatMapToCompletableFutureSync(java.util.function.Function<? super U,java.util.concurrent.CompletableFuture<? extends R>> flatFn)
```
 Perform a flatMap operation where the CompletableFuture type returned is flattened from the resulting Stream This operation is performed synchronously
```
 
 assertThat( new SimpleReact()
 .of(1,2,3)
 .flatMapCompletableFutureSync(i->CompletableFuture.completedFuture(i))
 .block(),equalTo(Arrays.asList(1,2,3)));
 
```
 In this example the result of the flatMapCompletableFuture is 'flattened' to the raw integer values
 Specified by:
 
 flatMapToCompletableFutureSync in interface BaseSimpleReactStream
 
 Parameters:
 
 flatFn - flatMap function
 
 Returns:
 
 Flatten Stream with flatFn applied
 - flatMap
```
default <R> SimpleReactStream<R> flatMap(java.util.function.Function<? super U,? extends java.util.stream.Stream<? extends R>> flatFn)
```
 Allows aggregate values in a Stream to be flatten into a single Stream. flatMap function turn each aggregate value into it's own Stream, and SimpleReact aggregates those Streams into a single flattened stream
 
 Specified by:
 
 flatMap in interface BaseSimpleReactStream
 
 Parameters:
 
 flatFn - Function that coverts a value (e.g. a Collection) into a Stream
 
 Returns:
 
 SimpleReactStream
 - with
```
default <R> java.util.List<java.util.concurrent.CompletableFuture<R>> with(java.util.function.Function<? super U,? extends R> fn)
```
 React with Asynchronously apply the function supplied to the currently active event tasks in the dataflow. While most methods in this class are fluent, and return a reference to a SimpleReact Stage builder, this method can be used this method to access the underlying CompletableFutures.
```
 
 List<CompletableFuture<Integer>> futures = new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3)
 .with((it) -> it * 100);
 
 
```
 In this instance, 3 suppliers generate 3 numbers. These may be executed in parallel, when they complete each number will be multiplied by 100 - as a separate parrellel task (handled by a ForkJoinPool or configurable task executor). A List of Future objects will be returned immediately from Simple React and the tasks will be executed asynchronously. React with does not block.
 Parameters:
 
 fn - Function to be applied to the results of the currently active event tasks
 
 Returns:
 
 A list of CompletableFutures which will contain the result of the application of the supplied function
 - filter
```
default SimpleReactStream filter(java.util.function.Predicate<? super U> p)
```
 Removes elements that do not match the supplied predicate from the dataflow
 
 Specified by:
 
 filter in interface BaseSimpleReactStream
 
 Parameters:
 
 p - Predicate that will be used to filter elements from the dataflow
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - filterSync
```
default SimpleReactStream filterSync(java.util.function.Predicate<? super U> p)
```
 Synchronous filtering operation Removes elements that do not match the supplied predicate from the dataflow
 
 Specified by:
 
 filterSync in interface BaseSimpleReactStream
 
 Parameters:
 
 p - Predicate that will be used to filter elements from the dataflow
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - streamCompletableFutures
```
default <T> java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> streamCompletableFutures()
```
 Specified by:
 
 streamCompletableFutures in interface BaseSimpleReactStream
 
 Returns:
 
 A Stream of CompletableFutures that represent this stage in the dataflow
 - merge
```
default SimpleReactStream merge(SimpleReactStream... s)
```
 - block
```
default ListX block(java.util.function.Predicate<Status> breakout)
```
 React and block with breakout Sometimes you may not need to block until all the work is complete, one result or a subset may be enough. To faciliate this, block can accept a Predicate functional interface that will allow SimpleReact to stop blocking the current thread when the Predicate has been fulfilled. E.g.
```
 
 List<String> strings = new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3)
 .transform(it -> it * 100)
 .transform(it -> "*" + it)
 .block(status -> status.getCompleted()->1);
 
 
 
```
 In this example the current thread will unblock once more than one result has been returned.
 Parameters:
 
 breakout - Predicate that determines whether the block should be continued or removed
 
 Returns:
 
 List of Completed results of currently active stage at full completion point or when breakout triggered (which ever comes first). throws InterruptedException,ExecutionException
 - block
```
default <A,R> R block(java.util.stream.Collector<? super U,A,R> collector,
 java.util.function.Predicate<Status> breakout)
```
 Parameters:
 
 collector - to perform aggregation / reduction operation on the results (e.g. to Collect into a List or String)
 
 breakout - Predicate that determines whether the block should be continued or removed
 
 Returns:
 
 Completed results of currently active stage at full completion point or when breakout triggered (which ever comes first), in aggregated in form determined by collector throws InterruptedException,ExecutionException
 - merge
```
static <R> SimpleReactStream<R> merge(SimpleReactStream s1,
 SimpleReactStream s2)
```
 Merge this reactive dataflow with another - recommended for merging different types. To merge flows of the same type the instance method merge is more appropriate.
 
 Parameters:
 
 s1 - Reactive stage builder to merge
 
 s2 - Reactive stage builder to merge
 
 Returns:
 
 Merged dataflow
 - onFail
```
default SimpleReactStream onFail(java.util.function.Function<? super SimpleReactFailedStageException,? extends U> fn)
```
 React onFail Define a function that can be used to recover from exceptions during the preceeding stage of the dataflow. e.g. onFail allows disaster recovery for each task (a separate onFail should be configured for each react phase that can fail). E.g. if reading data from an external service fails, but default value is acceptable - onFail is a suitable mechanism to set the default value. Asynchronously apply the function supplied to the currently active event tasks in the dataflow.
```
 
 List<String> strings = new SimpleReact().<Integer, Integer> react(() -> 100, () -> 2, () -> 3)
 .transform(it -> {
 if (it == 100)
 throw new RuntimeException("boo!");
 
 return it;
 })
 .onFail(e -> 1)
 .transform(it -> "*" + it)
 .block();
 
 
 
 
 
 
```
 In this example onFail recovers from the RuntimeException thrown when the input to the first 'transform' stage is 100.
 Specified by:
 
 onFail in interface BaseSimpleReactStream
 
 Parameters:
 
 fn - Recovery function, the exception is input, and the recovery value is output
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - onFail
```
default SimpleReactStream onFail(java.lang.Class<? extends java.lang.Throwable> exceptionClass,
 java.util.function.Function<? super SimpleReactFailedStageException,? extends U> fn)
```
 Recover for a particular class of exceptions only. Chain onFail methods from specific Exception classes to general, as Exceptions will be caught and handled in order. e.g.
```
 
 onFail(IOException.class, recoveryFunction1)
 .onFail(Throwable.class,recovertyFunction2)
 
 
```
 For an IOException recoveryFunction1 will be executed but with the definitions reveresed
```
 
 onFail(Throwable.class,recovertyFunction2)
 .onFail(IOException.class, recoveryFunction1)
 
 
```
 recoveryFunction1 will not be called
 Specified by:
 
 onFail in interface BaseSimpleReactStream
 
 Parameters:
 
 exceptionClass - Class of exceptions to recover from
 
 fn - Recovery function
 
 Returns:
 
 recovery value
 - assureSimpleReactException
```
static SimpleReactFailedStageException assureSimpleReactException(java.lang.Throwable throwable)
```
 - capture
```
default SimpleReactStream capture(java.util.function.Consumer<java.lang.Throwable> errorHandler)
```
 React capture While onFail is used for disaster recovery (when it is possible to recover) - capture is used to capture those occasions where the full pipeline has failed and is unrecoverable.
```
 
 List<String> strings = new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3)
 .transform(it -> it * 100)
 .transform(it -> {
 if (it == 100)
 throw new RuntimeException("boo!");
 
 return it;
 })
 .onFail(e -> 1)
 .transform(it -> "*" + it)
 .transform(it -> {
 
 if ("*200".equals(it))
 throw new RuntimeException("boo!");
 
 return it;
 })
 .capture(e -> logger.error(e.getMessage(),e))
 .block();
 
 
```
 In this case, strings will only contain the two successful results (for ()->1 and ()->3), an exception for the chain starting from Supplier ()->2 will be logged by capture. Capture will not capture the exception thrown when an Integer value of 100 is found, but will catch the exception when the String value "*200" is passed along the chain.
 Specified by:
 
 capture in interface BaseSimpleReactStream
 
 Parameters:
 
 errorHandler - A consumer that recieves and deals with an unrecoverable error in the dataflow
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - allOf
```
default <R> SimpleReactStream<R> allOf(java.util.function.Function<? super java.util.List,? extends R> fn)
```
 React and allOf allOf is a non-blocking equivalent of block. The current thread is not impacted by the calculations, but the reactive chain does not continue until all currently alloted tasks complete. The allOf task is transform provided with a list of the results from the previous tasks in the chain.
```
 
 boolean blocked[] = {false};
 new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3)
 
 .transform(it -> {
 try {
 Thread.sleep(50000);
 } catch (Exception e) {
 
 }
 blocked[0] =true;
 return 10;
 })
 .allOf( it -> it.size());
 
 assertThat(blocked[0],is(false));
 
 
 
```
 In this example, the current thread will continue and assert that it is not blocked, allOf could continue and be executed in a separate thread.
 Parameters:
 
 fn - Function that recieves the results of all currently active tasks as input
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - convertToLazyStream
```
default FutureStream convertToLazyStream()
```
 Convert between an Lazy and Eager future stream, can be used to take advantages of each approach during a single Stream
 
 Returns:
 
 An EagerFutureStream from this LazyFutureStream, will use the same executors
 - sync
```
default SimpleReactStream sync()
```
 Specified by:
 
 sync in interface BaseSimpleReactStream
 - async
```
default SimpleReactStream async()
```
 Specified by:
 
 async in interface BaseSimpleReactStream
 - bind
```
static <U,R> SimpleReactStream<R> bind(SimpleReactStream stream,
 java.util.function.Function<U,BaseSimpleReactStream<R>> flatFn)
```
 flatMap / bind implementation that returns the correct type (SimpleReactStream)
 
 Parameters:
 
 stream - Stream to flatMap
 
 flatFn - flatMap function
 
 Returns:
 - join
```
static <U,R> SimpleReactStream<R> join(SimpleReactStream<BaseSimpleReactStream> stream)
```
 flatten nested SimpleReactStreams
 
 Parameters:
 
 stream - Stream to flatten
 
 Returns:
 
 flattened Stream

Interface SimpleReactStream<U>

Method Summary

Methods inherited from interface com.aol.cyclops2.types.futurestream.BaseSimpleReactStream

Methods inherited from interface com.aol.cyclops2.types.futurestream.BlockingStream

Methods inherited from interface com.aol.cyclops2.types.futurestream.ConfigurableStream

Methods inherited from interface com.aol.cyclops2.types.futurestream.ToQueue

Method Detail

getSimpleReact

withLastActive

getLastActive

withTaskExecutor

withRetrier

withQueueFactory

withErrorHandler

withSubscription

withAsync

getSubscription

combineLatest

withLatest

self

run

splitAt

duplicate

zip

zip

zipWithIndex

firstOf

reverse

slice

limit

skip

skipUntil

takeUntil

cancel

copySimpleReactStream

then

thenSync

allOf

anyOf

lastActiveArray

retry

fromStream

fromStreamOfFutures

fromStreamCompletableFutureReplace

fromListCompletableFuture

then

peek

peekSync

handleExceptions

flatMapToCompletableFuture

flatMapToCompletableFutureSync

flatMap

with

filter

filterSync

streamCompletableFutures

merge

block

block

merge

onFail

onFail

assureSimpleReactException

capture

allOf

convertToLazyStream

sync

async

bind

join