LazySimpleReactStream (cyclops-react 1.0.0-FINAL API)

All Superinterfaces:

BaseSimpleReactStream, BlockingStream, ConfigurableStream<U,FastFuture>, ToQueue

All Known Subinterfaces:

LazyFutureStream

All Known Implementing Classes:

LazyFutureStreamImpl
```
public interface LazySimpleReactStream
extends BlockingStream, ConfigurableStream<U,FastFuture>, ToQueue, BaseSimpleReactStream
```

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`static SimpleReactFailedStageException`	`assureSimpleReactException(java.lang.Throwable throwable)`
`default LazySimpleReactStream<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 ListX<BaseSimpleReactStream<U>>`	`copySimpleReactStream(int times)`
`default LazySimpleReactStream<U>`	`filter(java.util.function.Predicate<? super U> p)` Removes elements that do not match the supplied predicate from the dataflow
`default LazySimpleReactStream<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> LazySimpleReactStream<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> LazySimpleReactStream<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> LazySimpleReactStream<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
`LazyStreamWrapper<U>`	`getLastActive()`
`LazyReact`	`getSimpleReact()`
`Continueable`	`getSubscription()`
`static <U,R> java.util.function.Function<U,R>`	`handleExceptions(java.util.function.Function<? super U,? extends R> fn)`
`default LazySimpleReactStream<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 LazySimpleReactStream<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 LazySimpleReactStream<U>`	`peek(java.util.function.Consumer<? super U> consumer)` Peek asynchronously at the results in the current stage.
`default LazySimpleReactStream<U>`	`peekSync(java.util.function.Consumer<? super U> consumer)` Synchronous peek operator
`default <R> LazySimpleReactStream<R>`	`retry(java.util.function.Function<? super U,? extends 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 <R> LazySimpleReactStream<R>`	`then(java.util.function.Function<? super U,? extends 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> LazySimpleReactStream<R>`	`then(java.util.function.Function<? super U,? extends R> fn, java.util.concurrent.Executor service)`
`default <R> LazySimpleReactStream<R>`	`thenSync(java.util.function.Function<? super U,? extends R> fn)`
`LazySimpleReactStream<U>`	`withAsync(boolean b)`
`LazySimpleReactStream<U>`	`withErrorHandler(java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)`
`<R> LazySimpleReactStream<R>`	`withLastActive(LazyStreamWrapper<R> streamWrapper)`
`LazySimpleReactStream<U>`	`withQueueFactory(QueueFactory<U> queue)`
`LazySimpleReactStream<U>`	`withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)`
`LazySimpleReactStream<U>`	`withSubscription(Continueable sub)`
`LazySimpleReactStream<U>`	`withTaskExecutor(java.util.concurrent.Executor e)`

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

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

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

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

- Method Detail
 - getSimpleReact
```
LazyReact getSimpleReact()
```
 Specified by:
 
 getSimpleReact in interface BaseSimpleReactStream
 
 Specified by:
 
 getSimpleReact in interface ConfigurableStream<U,FastFuture>
 - withTaskExecutor
```
LazySimpleReactStream withTaskExecutor(java.util.concurrent.Executor e)
```
 Specified by:
 
 withTaskExecutor in interface ConfigurableStream<U,FastFuture>
 - withRetrier
```
LazySimpleReactStream withRetrier(com.nurkiewicz.asyncretry.RetryExecutor retry)
```
 Specified by:
 
 withRetrier in interface BaseSimpleReactStream
 
 Specified by:
 
 withRetrier in interface ConfigurableStream<U,FastFuture>
 - withQueueFactory
```
LazySimpleReactStream withQueueFactory(QueueFactory queue)
```
 Specified by:
 
 withQueueFactory in interface BaseSimpleReactStream
 
 Specified by:
 
 withQueueFactory in interface ConfigurableStream<U,FastFuture>
 - withErrorHandler
```
LazySimpleReactStream withErrorHandler(java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)
```
 Specified by:
 
 withErrorHandler in interface ConfigurableStream<U,FastFuture>
 - withSubscription
```
LazySimpleReactStream withSubscription(Continueable sub)
```
 Specified by:
 
 withSubscription in interface BaseSimpleReactStream
 
 Specified by:
 
 withSubscription in interface ConfigurableStream<U,FastFuture>
 - withAsync
```
LazySimpleReactStream withAsync(boolean b)
```
 Specified by:
 
 withAsync in interface ConfigurableStream<U,FastFuture>
 - getSubscription
```
Continueable getSubscription()
```
 Specified by:
 
 getSubscription in interface BaseSimpleReactStream
 - withLastActive
```
<R> LazySimpleReactStream<R> withLastActive(LazyStreamWrapper<R> streamWrapper)
```
 - getLastActive
```
LazyStreamWrapper getLastActive()
```
 Specified by:
 
 getLastActive in interface BaseSimpleReactStream
 
 Specified by:
 
 getLastActive in interface BlockingStream
 - then
```
default <R> LazySimpleReactStream<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> LazySimpleReactStream<R> thenSync(java.util.function.Function<? super U,? extends R> fn)
```
 Specified by:
 
 thenSync in interface BaseSimpleReactStream
 - retry
```
default <R> LazySimpleReactStream<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,
 - then
```
default <R> LazySimpleReactStream<R> then(java.util.function.Function<? super U,? extends 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 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 LazySimpleReactStream 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 LazySimpleReactStream 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> LazySimpleReactStream<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> LazySimpleReactStream<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> LazySimpleReactStream<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 BaseSimpleReactStream
 
 Parameters:
 
 flatFn - Function that coverts a value (e.g. a Collection) into a Stream
 
 Returns:
 
 SimpleReactStream
 - copySimpleReactStream
```
default ListX<BaseSimpleReactStream> copySimpleReactStream(int times)
```
 - filter
```
default LazySimpleReactStream 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 LazySimpleReactStream 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
 - onFail
```
default LazySimpleReactStream 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)
 				.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 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 LazySimpleReactStream 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 LazySimpleReactStream 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)
 		.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 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

Interface LazySimpleReactStream<U>

Method Summary

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

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

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

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

Method Detail

getSimpleReact

withTaskExecutor

withRetrier

withQueueFactory

withErrorHandler

withSubscription

withAsync

getSubscription

withLastActive

getLastActive

then

thenSync

retry

then

peek

peekSync

handleExceptions

flatMapToCompletableFuture

flatMapToCompletableFutureSync

flatMap

copySimpleReactStream

filter

filterSync

streamCompletableFutures

onFail

onFail

assureSimpleReactException

capture