EagerSimpleReactStream (simple-react 0.99.2 API)

All Superinterfaces:

BlockingStream, ConfigurableStream<U,java.util.concurrent.CompletableFuture>, SimpleReactStream, ToQueue

All Known Subinterfaces:

EagerFutureStream

All Known Implementing Classes:

EagerFutureStreamImpl, SimpleReactStreamImpl
```
public interface EagerSimpleReactStream
extends SimpleReactStream, BlockingStream, ConfigurableStream<U,java.util.concurrent.CompletableFuture>, ToQueue
```

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <T,R> EagerSimpleReactStream<R>`	`allOf(java.util.stream.Collector collector, java.util.function.Function<T,R> fn)`
`default <T,R> EagerSimpleReactStream<R>`	`allOf(java.util.function.Function<java.util.List<T>,R> fn)` React and allOf allOf is a non-blocking equivalent of block.
`default <R> EagerSimpleReactStream<R>`	`anyOf(java.util.function.Function<U,R> fn)` React to the completion of any of the events in the previous stage.
`static SimpleReactFailedStageException`	`assureSimpleReactException(java.lang.Throwable throwable)`
`default EagerSimpleReactStream<U>`	`async()`
`static <U,R> EagerSimpleReactStream<R>`	`bind(EagerSimpleReactStream<U> stream, java.util.function.Function<U,SimpleReactStream<R>> flatFn)` flatMap / bind implementation that returns the correct type (SimpleReactStream)
`default <R> R`	`block(java.util.stream.Collector collector, java.util.function.Predicate<Status> breakout)`
`default java.util.List<U>`	`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.
`default EagerSimpleReactStream<U>`	`capture(java.util.function.Consumer<? extends 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 EagerFutureStream<U>`	`convertToEagerStream()` Convert between an Lazy and Eager future stream, can be used to take advantages of each approach during a single Stream
`default java.util.List<SimpleReactStream<U>>`	`copySimpleReactStream(int times)`
`default EagerSimpleReactStream<U>`	`doOnEach(java.util.function.Function<U,U> fn)` Applies a function to this phase independent on the main flow.
`default EagerSimpleReactStream<U>`	`doOnEachSync(java.util.function.Function<U,U> fn)` Applies a function to this phase independent on the main flow, continues on the currently executing thread.
`default EagerSimpleReactStream<U>`	`filter(java.util.function.Predicate<? super U> p)` Removes elements that do not match the supplied predicate from the dataflow
`default EagerSimpleReactStream<U>`	`filterSync(java.util.function.Predicate<? super U> p)` Synchronous filtering operation Removes elements that do not match the supplied predicate from the dataflow
`default <R> EagerSimpleReactStream<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> EagerSimpleReactStream<R>`	`flatMapCompletableFuture(java.util.function.Function<U,java.util.concurrent.CompletableFuture<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> EagerSimpleReactStream<R>`	`flatMapCompletableFutureSync(java.util.function.Function<U,java.util.concurrent.CompletableFuture<R>> flatFn)` Perform a flatMap operation where the CompletableFuture type returned is flattened from the resulting Stream This operation is performed synchronously
`default <R> EagerSimpleReactStream<R>`	`fromListCompletableFuture(java.util.List<java.util.concurrent.CompletableFuture<R>> list)`
`default <R> EagerSimpleReactStream<R>`	`fromStream(java.util.stream.Stream<R> stream)`
`default <R> EagerSimpleReactStream<R>`	`fromStreamCompletableFutureReplace(java.util.stream.Stream<java.util.concurrent.CompletableFuture<R>> stream)`
`default <R> EagerSimpleReactStream<R>`	`fromStreamOfFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<R>> stream)` Construct a SimpleReactStream from provided Stream of CompletableFutures
`EagerStreamWrapper`	`getLastActive()`
`Continueable`	`getSubscription()`
`static <U,R> java.util.function.Function<U,R>`	`handleExceptions(java.util.function.Function<U,R> fn)`
`static <U,R> EagerSimpleReactStream<R>`	`join(EagerSimpleReactStream<SimpleReactStream<U>> stream)` flatten nested SimpleReactStreams
`static java.util.concurrent.CompletableFuture[]`	`lastActiveArray(EagerStreamWrapper lastActive)`
`default EagerSimpleReactStream<U>`	`merge(EagerSimpleReactStream<U>... s)`
`static <R> EagerSimpleReactStream<R>`	`merge(EagerSimpleReactStream s1, EagerSimpleReactStream s2)` Merge this reactive dataflow with another - recommended for merging different types.
`default EagerSimpleReactStream<U>`	`onFail(java.lang.Class<? extends java.lang.Throwable> exceptionClass, java.util.function.Function<SimpleReactFailedStageException,U> fn)` Recover for a particular class of exceptions only.
`default EagerSimpleReactStream<U>`	`onFail(java.util.function.Function<SimpleReactFailedStageException,U> fn)` React onFail Define a function that can be used to recover from exceptions during the preceeding stage of the dataflow.
`default EagerSimpleReactStream<U>`	`peek(java.util.function.Consumer<? super U> consumer)` Peek asynchronously at the results in the current stage.
`default EagerSimpleReactStream<U>`	`peekSync(java.util.function.Consumer<? super U> consumer)` Synchronous peek operator
`default <R> EagerSimpleReactStream<R>`	`retry(java.util.function.Function<U,R> fn)` Will execute this phase on the RetryExecutor (default or user supplied).
`default <T> java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>>`	`streamCompletableFutures()`
`default EagerSimpleReactStream<U>`	`sync()`
`default <R> EagerSimpleReactStream<R>`	`then(java.util.function.Function<U,R> fn)` React then Unlike 'with' this method is fluent, and returns another Stage Builder that can represent the next stage in the dataflow.
`default <R> EagerSimpleReactStream<R>`	`then(java.util.function.Function<U,R> fn, java.util.concurrent.Executor service)`
`default <R> EagerSimpleReactStream<R>`	`thenSync(java.util.function.Function<U,R> fn)`
`default <R> java.util.List<java.util.concurrent.CompletableFuture<R>>`	`with(java.util.function.Function<U,R> fn)` React with Asynchronously apply the function supplied to the currently active event tasks in the dataflow.
`EagerSimpleReactStream<U>`	`withAsync(boolean b)`
`EagerSimpleReactStream<U>`	`withErrorHandler(java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)`
`EagerSimpleReactStream<U>`	`withLastActive(EagerStreamWrapper streamWrapper)`
`EagerSimpleReactStream<U>`	`withQueueFactory(QueueFactory<U> queue)`
`EagerSimpleReactStream<U>`	`withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)`
`EagerSimpleReactStream<U>`	`withSubscription(Continueable sub)`
`EagerSimpleReactStream<U>`	`withTaskExecutor(java.util.concurrent.Executor e)`

Methods inherited from interface com.aol.simple.react.stream.traits.SimpleReactStream
empty, getQueueFactory, getSimpleReact, getTaskExecutor, isAsync, iterator, of, of, ofThread, ofThread, parallel, react, react, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStreamFrom, simpleReactStreamFromIterable, toQueue

Methods inherited from interface com.aol.simple.react.stream.traits.BlockingStream
block, block, blockAndExtract, blockAndExtract, first, getErrorHandler, last

Methods inherited from interface com.aol.simple.react.stream.traits.ConfigurableStream
getErrorHandler, getRetrier, getSimpleReact, getTaskExecutor, isAsync

Methods inherited from interface com.aol.simple.react.stream.traits.ToQueue
addToQueue, getQueueFactory, toQueue, toQueue, toQueue

- Method Detail
 - withLastActive
```
EagerSimpleReactStream withLastActive(EagerStreamWrapper streamWrapper)
```
 - getLastActive
```
EagerStreamWrapper getLastActive()
```
 Specified by:
 
 getLastActive in interface BlockingStream
 
 Specified by:
 
 getLastActive in interface SimpleReactStream
 - withTaskExecutor
```
EagerSimpleReactStream withTaskExecutor(java.util.concurrent.Executor e)
```
 Specified by:
 
 withTaskExecutor in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 - withRetrier
```
EagerSimpleReactStream withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)
```
 Specified by:
 
 withRetrier in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 
 Specified by:
 
 withRetrier in interface SimpleReactStream
 - withQueueFactory
```
EagerSimpleReactStream withQueueFactory(QueueFactory queue)
```
 Specified by:
 
 withQueueFactory in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 
 Specified by:
 
 withQueueFactory in interface SimpleReactStream
 - withErrorHandler
```
EagerSimpleReactStream withErrorHandler(java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)
```
 Specified by:
 
 withErrorHandler in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 - withSubscription
```
EagerSimpleReactStream withSubscription(Continueable sub)
```
 Specified by:
 
 withSubscription in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 
 Specified by:
 
 withSubscription in interface SimpleReactStream
 - withAsync
```
EagerSimpleReactStream withAsync(boolean b)
```
 Specified by:
 
 withAsync in interface ConfigurableStream<U,java.util.concurrent.CompletableFuture>
 - getSubscription
```
Continueable getSubscription()
```
 Specified by:
 
 getSubscription in interface SimpleReactStream
 - copySimpleReactStream
```
default java.util.List<SimpleReactStream> copySimpleReactStream(int times)
```
 - then
```
default <R> EagerSimpleReactStream<R> then(java.util.function.Function<U,R> fn,
 java.util.concurrent.Executor service)
```
 Specified by:
 
 then in interface SimpleReactStream
 - thenSync
```
default <R> EagerSimpleReactStream<R> thenSync(java.util.function.Function<U,R> fn)
```
 Specified by:
 
 thenSync in interface SimpleReactStream
 - allOf
```
default <T,R> EagerSimpleReactStream<R> allOf(java.util.stream.Collector collector,
 java.util.function.Function<T,R> 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> EagerSimpleReactStream<R> anyOf(java.util.function.Function<U,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(EagerStreamWrapper lastActive)
```
 - retry
```
default <R> EagerSimpleReactStream<R> retry(java.util.function.Function<U,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 SimpleReactStream
 
 Parameters:
 
 fn - Function that will be executed and retried on failure
 
 Returns:
 
 Next Stage in the Strea,
 - fromStream
```
default <R> EagerSimpleReactStream<R> fromStream(java.util.stream.Stream<R> stream)
```
 Specified by:
 
 fromStream in interface SimpleReactStream
 - fromStreamOfFutures
```
default <R> EagerSimpleReactStream<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> EagerSimpleReactStream<R> fromStreamCompletableFutureReplace(java.util.stream.Stream<java.util.concurrent.CompletableFuture<R>> stream)
```
 - fromListCompletableFuture
```
default <R> EagerSimpleReactStream<R> fromListCompletableFuture(java.util.List<java.util.concurrent.CompletableFuture<R>> list)
```
 - then
```
default <R> EagerSimpleReactStream<R> then(java.util.function.Function<U,R> fn)
```
 React then 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)
				.then((it) -> it * 100)
				.then((it) -> "*" + it)
				
				
 
```
 React then allows event reactors to be chained. Unlike React with, which returns a collection of Future references, React then is a fluent interface that returns the React builder - allowing further reactors to be added to the chain. React then does not block. React with can be called after React then 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 SimpleReactStream
 
 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
 - doOnEach
```
default EagerSimpleReactStream doOnEach(java.util.function.Function<U,U> fn)
```
 Applies a function to this phase independent on the main flow. Convenience over taking a reference to this phase and splitting it.
 
 Specified by:
 
 doOnEach in interface SimpleReactStream
 
 Parameters:
 
 fn - Function to be applied to each completablefuture on completion
 
 Returns:
 
 This phase in Stream
 - doOnEachSync
```
default EagerSimpleReactStream doOnEachSync(java.util.function.Function<U,U> fn)
```
 Applies a function to this phase independent on the main flow, continues on the currently executing thread. Convenience over taking a reference to this phase and splitting it.
 
 Specified by:
 
 doOnEachSync in interface SimpleReactStream
 
 Parameters:
 
 fn - Function to be applied to each completablefuture on completion
 
 Returns:
 
 This phase in Stream
 - peek
```
default EagerSimpleReactStream 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 SimpleReactStream
 
 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 EagerSimpleReactStream peekSync(java.util.function.Consumer<? super U> consumer)
```
 Synchronous peek operator
 
 Specified by:
 
 peekSync in interface SimpleReactStream
 
 Parameters:
 
 consumer - Peek consumer
 
 Returns:
 
 Next stage
 - handleExceptions
```
static <U,R> java.util.function.Function<U,R> handleExceptions(java.util.function.Function<U,R> fn)
```
 - flatMapCompletableFuture
```
default <R> EagerSimpleReactStream<R> flatMapCompletableFuture(java.util.function.Function<U,java.util.concurrent.CompletableFuture<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:
 
 flatMapCompletableFuture in interface SimpleReactStream
 
 Parameters:
 
 flatFn - flatMap function
 
 Returns:
 
 Flatten Stream with flatFn applied
 - flatMapCompletableFutureSync
```
default <R> EagerSimpleReactStream<R> flatMapCompletableFutureSync(java.util.function.Function<U,java.util.concurrent.CompletableFuture<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:
 
 flatMapCompletableFutureSync in interface SimpleReactStream
 
 Parameters:
 
 flatFn - flatMap function
 
 Returns:
 
 Flatten Stream with flatFn applied
 - flatMap
```
default <R> EagerSimpleReactStream<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 functions turn each aggregate value into it's own Stream, and SimpleReact aggregates those Streams into a single flattened stream
 
 Specified by:
 
 flatMap in interface SimpleReactStream
 
 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<U,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 EagerSimpleReactStream 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 SimpleReactStream
 
 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 EagerSimpleReactStream 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 SimpleReactStream
 
 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 SimpleReactStream
 
 Returns:
 
 A Stream of CompletableFutures that represent this stage in the dataflow
 - merge
```
default EagerSimpleReactStream merge(EagerSimpleReactStream... s)
```
 - block
```
default java.util.List 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) .then(it -> it * 100) .then(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 <R> R block(java.util.stream.Collector 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> EagerSimpleReactStream<R> merge(EagerSimpleReactStream s1,
 EagerSimpleReactStream 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 EagerSimpleReactStream onFail(java.util.function.Function<SimpleReactFailedStageException,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)
					.then(it -> {
						if (it == 100)
							throw new RuntimeException("boo!");
			
						return it;
					})
					.onFail(e -> 1)
					.then(it -> "*" + it)
					.block();	 
	 
	 
	 
	 
 
 
```
 In this example onFail recovers from the RuntimeException thrown when the input to the first 'then' stage is 100.
 Specified by:
 
 onFail in interface SimpleReactStream
 
 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 EagerSimpleReactStream onFail(java.lang.Class<? extends java.lang.Throwable> exceptionClass,
 java.util.function.Function<SimpleReactFailedStageException,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 SimpleReactStream
 
 Parameters:
 
 exceptionClass - Class of exceptions to recover from
 
 fn - Recovery function
 
 Returns:
 
 recovery value
 - assureSimpleReactException
```
static SimpleReactFailedStageException assureSimpleReactException(java.lang.Throwable throwable)
```
 - capture
```
default EagerSimpleReactStream capture(java.util.function.Consumer<? extends 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)
			.then(it -> it * 100)
			.then(it -> {
				if (it == 100)
					throw new RuntimeException("boo!");
	
				return it;
			})
			.onFail(e -> 1)
			.then(it -> "*" + it)
			.then(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 SimpleReactStream
 
 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 <T,R> EagerSimpleReactStream<R> allOf(java.util.function.Function<java.util.List<T>,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 then 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)
				
				.then(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
 - convertToEagerStream
```
default EagerFutureStream convertToEagerStream()
```
 Convert between an Lazy and Eager future stream, can be used to take advantages of each approach during a single Stream
 
 Specified by:
 
 convertToEagerStream in interface SimpleReactStream
 
 Returns:
 
 An EagerFutureStream from this LazyFutureStream, will use the same executors
 - sync
```
default EagerSimpleReactStream sync()
```
 Specified by:
 
 sync in interface SimpleReactStream
 - async
```
default EagerSimpleReactStream async()
```
 Specified by:
 
 async in interface SimpleReactStream
 - bind
```
static <U,R> EagerSimpleReactStream<R> bind(EagerSimpleReactStream stream,
 java.util.function.Function<U,SimpleReactStream<R>> flatFn)
```
 flatMap / bind implementation that returns the correct type (SimpleReactStream)
 
 Parameters:
 
 stream - Stream to flatMap
 
 flatFn - flatMap function
 
 Returns:
 - join
```
static <U,R> EagerSimpleReactStream<R> join(EagerSimpleReactStream<SimpleReactStream> stream)
```
 flatten nested SimpleReactStreams
 
 Parameters:
 
 stream - Stream to flatten
 
 Returns:
 
 flattened Stream

Interface EagerSimpleReactStream<U>

Method Summary

Methods inherited from interface com.aol.simple.react.stream.traits.SimpleReactStream

Methods inherited from interface com.aol.simple.react.stream.traits.BlockingStream

Methods inherited from interface com.aol.simple.react.stream.traits.ConfigurableStream

Methods inherited from interface com.aol.simple.react.stream.traits.ToQueue

Method Detail

withLastActive

getLastActive

withTaskExecutor

withRetrier

withQueueFactory

withErrorHandler

withSubscription

withAsync

getSubscription

copySimpleReactStream

then

thenSync

allOf

anyOf

lastActiveArray

retry

fromStream

fromStreamOfFutures

fromStreamCompletableFutureReplace

fromListCompletableFuture

then

doOnEach

doOnEachSync

peek

peekSync

handleExceptions

flatMapCompletableFuture

flatMapCompletableFutureSync

flatMap

with

filter

filterSync

streamCompletableFutures

merge

block

block

merge

onFail

onFail

assureSimpleReactException

capture

allOf

convertToEagerStream

sync

async

bind

join