BaseSimpleReactStream (simple-react 1.0.0-RC2.1 API)

All Superinterfaces:

BlockingStream

All Known Subinterfaces:

LazyFutureStream, LazySimpleReactStream, SimpleReactStream

All Known Implementing Classes:

LazyFutureStreamImpl, SimpleReactStreamImpl
```
public interface BaseSimpleReactStream
extends BlockingStream
```

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`BaseSimpleReactStream<U>`	`async()`
`BaseSimpleReactStream<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 <U> BaseSimpleReactStream<U>`	`cast(java.lang.Class<U> type)`
`BaseSimpleReactStream<U>`	`doOnEach(java.util.function.Function<U,U> fn)` Applies a function to this phase independent on the main flow.
`BaseSimpleReactStream<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.
`static <T> SimpleReactStream<T>`	`empty()` Create an empty sequential synchronous stream that runs on the current thread
`BaseSimpleReactStream<U>`	`filter(java.util.function.Predicate<? super U> p)` Removes elements that do not match the supplied predicate from the dataflow
`BaseSimpleReactStream<U>`	`filterSync(java.util.function.Predicate<? super U> p)` Synchronous filtering operation Removes elements that do not match the supplied predicate from the dataflow
`<R> BaseSimpleReactStream<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.
`<R> BaseSimpleReactStream<R>`	`flatMapToCompletableFuture(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
`<R> BaseSimpleReactStream<R>`	`flatMapToCompletableFutureSync(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
`static <T> SimpleReactStream<T>`	`freeThread(T... values)` Create a sequential synchronous stream that runs on the current thread
`static <T> SimpleReactStream<T>`	`freeThread(T value)` Create a sequential synchronous stream that runs on the current thread
`<R> BaseSimpleReactStream<R>`	`fromStream(java.util.stream.Stream<R> stream)`
`StreamWrapper<U>`	`getLastActive()`
`QueueFactory<U>`	`getQueueFactory()`
`ReactBuilder`	`getSimpleReact()`
`Continueable`	`getSubscription()`
`java.util.concurrent.Executor`	`getTaskExecutor()`
`default BaseSimpleReactStream<U>`	`intersperse(U value)` Returns a stream with a given value interspersed between any two values of this stream.
`boolean`	`isAsync()`
`default java.util.Iterator<U>`	`iterator()`
`static <T> SimpleReactStream<T>`	`of(T... values)` Create a sequential synchronous stream that runs on the current thread
`static <T> SimpleReactStream<T>`	`of(T value)` Create a sequential synchronous stream that runs on the current thread
`default <U> BaseSimpleReactStream<U>`	`ofType(java.lang.Class<U> type)` Keep only those elements in a stream that are of a given type.
`BaseSimpleReactStream<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.
`BaseSimpleReactStream<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.
`static <U> SimpleReactStream<U>`	`parallel(U... array)` Construct an SimpleReactStream from specified array, that will run in parallel on the common Parallel executor service (by default the Common ForkJoinPool) see ThreadPools#setUseCommon to change to a different pool
`BaseSimpleReactStream<U>`	`peek(java.util.function.Consumer<? super U> consumer)` Peek asynchronously at the results in the current stage.
`BaseSimpleReactStream<U>`	`peekSync(java.util.function.Consumer<? super U> consumer)` Synchronous peek operator
`static <T> SimpleReactStream<T>`	`react(java.util.function.Supplier<T>... values)` Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
`static <T> SimpleReactStream<T>`	`react(java.util.function.Supplier<T> value)` Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
`<R> java.lang.Object`	`retry(java.util.function.Function<? super U,? extends R> fn)` Will execute this phase on the RetryExecutor (default or user supplied).
`static <T> SimpleReactStream<T>`	`simpleReactStream(java.util.concurrent.CompletableFuture<T>... values)` Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
`static <T> BaseSimpleReactStream<T>`	`simpleReactStream(java.util.concurrent.CompletableFuture<T> value)` Create a 'free threaded' asynchronous stream that runs on the supplied CompletableFutures executor service (unless async operator invoked , in which it will switch to the common 'free' thread executor) Subsequent tasks will be executed synchronously unless the async() operator is invoked.
`static <T> SimpleReactStream<T>`	`simpleReactStream(java.util.Iterator<T> iterator)` Wrap an Iterator into a FutureStream.
`static <T> SimpleReactStream<T>`	`simpleReactStream(java.util.stream.Stream<T> stream)` Wrap a Stream into a SimpleReactStream.
`static <T> BaseSimpleReactStream<T>`	`simpleReactStreamFrom(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)` Create a 'free threaded' asynchronous stream that runs on the supplied CompletableFutures executor service (unless async operator invoked , in which it will switch to the common 'free' thread executor) Subsequent tasks will be executed synchronously unless the async() operator is invoked.
`static <T> SimpleReactStream<T>`	`simpleReactStreamFromIterable(java.lang.Iterable<T> iterable)` Wrap an Iterable into a FutureStream.
`BaseSimpleReactStream<U>`	`skip(long n)`
`<T> java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>>`	`streamCompletableFutures()`
`BaseSimpleReactStream<U>`	`sync()`
`<R> BaseSimpleReactStream<R>`	`then(java.util.function.Function<? super U,? extends R> fn, java.util.concurrent.Executor service)`
`<R> BaseSimpleReactStream<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.
`<R> BaseSimpleReactStream<R>`	`thenSync(java.util.function.Function<? super U,? extends R> fn)`
`Queue<U>`	`toQueue()`
`BaseSimpleReactStream<U>`	`withQueueFactory(QueueFactory<U> queueFactory)`
`BaseSimpleReactStream<U>`	`withRetrier(com.nurkiewicz.asyncretry.RetryExecutor executor)`
`BaseSimpleReactStream<U>`	`withSubscription(Continueable subscription)`

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

- Method Detail
 - getSimpleReact
```
ReactBuilder getSimpleReact()
```
 - ofType
```
default  BaseSimpleReactStream ofType(java.lang.Class type)
```
 Keep only those elements in a stream that are of a given type. LazyFutureStream.of(1, "a", 2, "b", 3).ofType(Integer.class) gives a Stream of (1,2,3) LazyFutureStream.of(1, "a", 2, "b", 3).ofType(String.class) gives a Stream of ("a","b")
 - cast
```
default  BaseSimpleReactStream cast(java.lang.Class type)
```
 - intersperse
```
default BaseSimpleReactStream intersperse(U value)
```
 Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) SimpleReactStream.of(1, 2, 3, 4).intersperse(0)
 - skip
```
BaseSimpleReactStream skip(long n)
```
 - iterator
```
default java.util.Iterator iterator()
```
 - getLastActive
```
StreamWrapper getLastActive()
```
 Specified by:
 
 getLastActive in interface BlockingStream
 - then
```
<R> BaseSimpleReactStream<R> then(java.util.function.Function<? super U,? extends R> fn,
 java.util.concurrent.Executor service)
```
 - thenSync
```
<R> BaseSimpleReactStream<R> thenSync(java.util.function.Function<? super U,? extends R> fn)
```
 - retry
```
<R> java.lang.Object 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
 
 Parameters:
 
 fn - Function that will be executed and retried on failure
 
 Returns:
 
 Next Stage in the Strea,
 - fromStream
```
<R> BaseSimpleReactStream<R> fromStream(java.util.stream.Stream<R> stream)
```
 - then
```
<R> BaseSimpleReactStream<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
 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
```
BaseSimpleReactStream 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.
 
 Parameters:
 
 fn - Function to be applied to each completablefuture on completion
 
 Returns:
 
 This phase in Stream
 - doOnEachSync
```
BaseSimpleReactStream 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.
 
 Parameters:
 
 fn - Function to be applied to each completablefuture on completion
 
 Returns:
 
 This phase in Stream
 - peek
```
BaseSimpleReactStream 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.
 
 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
```
BaseSimpleReactStream peekSync(java.util.function.Consumer<? super U> consumer)
```
 Synchronous peek operator
 
 Parameters:
 
 consumer - Peek consumer
 
 Returns:
 
 Next stage
 - flatMapToCompletableFuture
```
<R> BaseSimpleReactStream<R> flatMapToCompletableFuture(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
 Parameters:
 
 flatFn - flatMap function
 
 Returns:
 
 Flatten Stream with flatFn applied
 - flatMapToCompletableFutureSync
```
<R> BaseSimpleReactStream<R> flatMapToCompletableFutureSync(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
 Parameters:
 
 flatFn - flatMap function
 
 Returns:
 
 Flatten Stream with flatFn applied
 - flatMap
```
<R> BaseSimpleReactStream<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
 
 Parameters:
 
 flatFn - Function that coverts a value (e.g. a Collection) into a Stream
 
 Returns:
 
 SimpleReactStream
 - filter
```
BaseSimpleReactStream filter(java.util.function.Predicate<? super U> p)
```
 Removes elements that do not match the supplied predicate from the dataflow
 
 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
```
BaseSimpleReactStream filterSync(java.util.function.Predicate<? super U> p)
```
 Synchronous filtering operation Removes elements that do not match the supplied predicate from the dataflow
 
 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
```
<T> java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> streamCompletableFutures()
```
 Returns:
 
 A Stream of CompletableFutures that represent this stage in the dataflow
 - onFail
```
BaseSimpleReactStream 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.
 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
```
BaseSimpleReactStream 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
 Parameters:
 
 exceptionClass - Class of exceptions to recover from
 
 fn - Recovery function
 
 Returns:
 
 recovery value
 - capture
```
BaseSimpleReactStream 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.
 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
 - sync
```
BaseSimpleReactStream sync()
```
 - async
```
BaseSimpleReactStream async()
```
 - toQueue
```
Queue toQueue()
```
 - react
```
static <T> SimpleReactStream<T> react(java.util.function.Supplier<T> value)
```
 Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
 - react
```
@SafeVarargs
static <T> SimpleReactStream<T> react(java.util.function.Supplier<T>... values)
```
 Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
 - of
```
static <T> SimpleReactStream<T> of(T value)
```
 Create a sequential synchronous stream that runs on the current thread
 - of
```
@SafeVarargs
static <T> SimpleReactStream<T> of(T... values)
```
 Create a sequential synchronous stream that runs on the current thread
 - freeThread
```
static <T> SimpleReactStream<T> freeThread(T value)
```
 Create a sequential synchronous stream that runs on the current thread
 
 See Also:
 
 Stream.of(Object)
 - freeThread
```
@SafeVarargs
static <T> SimpleReactStream<T> freeThread(T... values)
```
 Create a sequential synchronous stream that runs on the current thread
 
 See Also:
 
 Stream.of(Object[])
 - empty
```
static <T> SimpleReactStream<T> empty()
```
 Create an empty sequential synchronous stream that runs on the current thread
 - parallel
```
static  SimpleReactStream parallel(U... array)
```
 Construct an SimpleReactStream from specified array, that will run in parallel on the common Parallel executor service (by default the Common ForkJoinPool) see ThreadPools#setUseCommon to change to a different pool
 
 Parameters:
 
 array - Array of value to form the reactive stream / sequence
 
 Returns:
 
 SimpleReact Stage
 - simpleReactStreamFrom
```
static <T> BaseSimpleReactStream<T> simpleReactStreamFrom(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)
```
 Create a 'free threaded' asynchronous stream that runs on the supplied CompletableFutures executor service (unless async operator invoked , in which it will switch to the common 'free' thread executor) Subsequent tasks will be executed synchronously unless the async() operator is invoked.
 
 See Also:
 
 Stream.of(Object)
 - simpleReactStream
```
static <T> BaseSimpleReactStream<T> simpleReactStream(java.util.concurrent.CompletableFuture<T> value)
```
 Create a 'free threaded' asynchronous stream that runs on the supplied CompletableFutures executor service (unless async operator invoked , in which it will switch to the common 'free' thread executor) Subsequent tasks will be executed synchronously unless the async() operator is invoked.
 
 See Also:
 
 Stream.of(Object)
 - simpleReactStream
```
static <T> SimpleReactStream<T> simpleReactStream(java.util.concurrent.CompletableFuture<T>... values)
```
 Create a 'free threaded' asynchronous stream that runs on a single thread (not current) The supplier will be executed asyncrhonously, subsequent tasks will be executed synchronously unless the async() operator is invoked.
 
 See Also:
 
 Stream.of(Object)
 - simpleReactStream
```
static <T> SimpleReactStream<T> simpleReactStream(java.util.stream.Stream<T> stream)
```
 Wrap a Stream into a SimpleReactStream.
 - simpleReactStreamFromIterable
```
static <T> SimpleReactStream<T> simpleReactStreamFromIterable(java.lang.Iterable<T> iterable)
```
 Wrap an Iterable into a FutureStream.
 - simpleReactStream
```
static <T> SimpleReactStream<T> simpleReactStream(java.util.Iterator<T> iterator)
```
 Wrap an Iterator into a FutureStream.
 - getSubscription
```
Continueable getSubscription()
```
 - getQueueFactory
```
QueueFactory getQueueFactory()
```
 - withSubscription
```
BaseSimpleReactStream withSubscription(Continueable subscription)
```
 - withQueueFactory
```
BaseSimpleReactStream withQueueFactory(QueueFactory queueFactory)
```
 - withRetrier
```
BaseSimpleReactStream withRetrier(com.nurkiewicz.asyncretry.RetryExecutor executor)
```
 - getTaskExecutor
```
java.util.concurrent.Executor getTaskExecutor()
```
 - isAsync
```
boolean isAsync()
```

Interface BaseSimpleReactStream<U>

Method Summary

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

Method Detail

getSimpleReact

ofType

cast

intersperse

skip

iterator

getLastActive

then

thenSync

retry

fromStream

then

doOnEach

doOnEachSync

peek

peekSync

flatMapToCompletableFuture

flatMapToCompletableFutureSync

flatMap

filter

filterSync

streamCompletableFutures

onFail

onFail

capture

sync

async

toQueue

react

react

of

of

freeThread

freeThread

empty

parallel

simpleReactStreamFrom

simpleReactStream

simpleReactStream

simpleReactStream

simpleReactStreamFromIterable

simpleReactStream

getSubscription

getQueueFactory

withSubscription

withQueueFactory

withRetrier

getTaskExecutor

isAsync