BaseSimpleReactStream (cyclops-react 2.1.1 API)

All Superinterfaces:

BlockingStream

All Known Subinterfaces:

FutureStream, LazySimpleReactStream, SimpleReactStream
```
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<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<? extends U> type)`
`static <T> SimpleReactStream<T>`	`empty()` Create an zero sequential synchronous reactiveStream 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 singleUnsafe Stream.
`<R> BaseSimpleReactStream<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
`<R> BaseSimpleReactStream<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
`static <T> SimpleReactStream<T>`	`freeThread(T... values)` Create a sequential synchronous reactiveStream that runs on the current thread
`static <T> SimpleReactStream<T>`	`freeThread(T value)` Create a sequential synchronous reactiveStream that runs on the current thread
`<R> BaseSimpleReactStream<R>`	`fromStream(java.util.stream.Stream<R> stream)`
`com.aol.cyclops2.internal.react.stream.StreamWrapper<U>`	`getLastActive()`
`QueueFactory<U>`	`getQueueFactory()`
`com.aol.cyclops2.internal.react.stream.ReactBuilder`	`getSimpleReact()`
`Continueable`	`getSubscription()`
`java.util.concurrent.Executor`	`getTaskExecutor()`
`default BaseSimpleReactStream<U>`	`intersperse(U value)` Returns a reactiveStream with a given value interspersed between any two values of this reactiveStream.
`boolean`	`isAsync()`
`default java.util.Iterator<U>`	`iterator()`
`static <T> SimpleReactStream<T>`	`of(T... values)` Create a sequential synchronous reactiveStream that runs on the current thread
`static <T> SimpleReactStream<T>`	`of(T value)` Create a sequential synchronous reactiveStream that runs on the current thread
`default <U> BaseSimpleReactStream<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a reactiveStream that are of a given type.
`BaseSimpleReactStream<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.
`BaseSimpleReactStream<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.
`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 reactiveStream that runs on a singleUnsafe 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 reactiveStream that runs on a singleUnsafe 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>`	`simpleReactStream(java.util.concurrent.CompletableFuture<T>... values)` Create a 'free threaded' asynchronous reactiveStream that runs on a singleUnsafe 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 reactiveStream 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 reactiveStream 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)` React transform Unlike 'with' this method is fluent, and returns another Stage Builder that can represent the next stage in the dataflow.
`<R> BaseSimpleReactStream<R>`	`then(java.util.function.Function<? super U,? extends R> fn, java.util.concurrent.Executor service)`
`<R> BaseSimpleReactStream<R>`	`thenSync(java.util.function.Function<? super U,? extends R> fn)`
`Queue<U>`	`toQueue()`
`BaseSimpleReactStream<U>`	`withQueueFactory(QueueFactory<U> queueFactory)`
`BaseSimpleReactStream<U>`	`withSubscription(Continueable subscription)`

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

- Method Detail
 - getSimpleReact
```
com.aol.cyclops2.internal.react.stream.ReactBuilder getSimpleReact()
```
 - ofType
```
default  BaseSimpleReactStream ofType(java.lang.Class<? extends U> type)
```
 Keep only those elements in a reactiveStream 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<? extends U> type)
```
 - intersperse
```
default BaseSimpleReactStream intersperse(U value)
```
 Returns a reactiveStream with a given value interspersed between any two values of this reactiveStream. // (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
```
com.aol.cyclops2.internal.react.stream.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)
```
 - fromStream
```
<R> BaseSimpleReactStream<R> fromStream(java.util.stream.Stream<R> stream)
```
 - then
```
<R> BaseSimpleReactStream<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 toX 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
 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
```
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<? 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
 Parameters:
 
 flatFn - flatMap function
 
 Returns:
 
 Flatten Stream with flatFn applied
 - flatMapToCompletableFutureSync
```
<R> BaseSimpleReactStream<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
 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 singleUnsafe Stream. flatMap function turn each aggregate value into it's own Stream, and SimpleReact aggregates those Streams into a singleUnsafe flattened reactiveStream
 
 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<? 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 applyHKT 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.
 Parameters:
 
 fn - Recovery function, the exception is input, and the recovery value is emitted
 
 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<? 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
 Parameters:
 
 exceptionClass - Class of exceptions to recover from
 
 fn - Recovery function
 
 Returns:
 
 recovery value
 - capture
```
BaseSimpleReactStream 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.
 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 reactiveStream that runs on a singleUnsafe 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 reactiveStream that runs on a singleUnsafe 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 reactiveStream that runs on the current thread
 - of
```
@SafeVarargs
static <T> SimpleReactStream<T> of(T... values)
```
 Create a sequential synchronous reactiveStream that runs on the current thread
 - freeThread
```
static <T> SimpleReactStream<T> freeThread(T value)
```
 Create a sequential synchronous reactiveStream that runs on the current thread
 
 See Also:
 
 Stream.of(Object)
 - freeThread
```
@SafeVarargs
static <T> SimpleReactStream<T> freeThread(T... values)
```
 Create a sequential synchronous reactiveStream that runs on the current thread
 
 See Also:
 
 Stream.of(Object[])
 - empty
```
static <T> SimpleReactStream<T> empty()
```
 Create an zero sequential synchronous reactiveStream 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 reactiveBuffer reactiveStream / 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 reactiveStream 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 reactiveStream 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 reactiveStream that runs on a singleUnsafe 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)
```
 - getTaskExecutor
```
java.util.concurrent.Executor getTaskExecutor()
```
 - isAsync
```
boolean isAsync()
```

Interface BaseSimpleReactStream<U>

Method Summary

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

Method Detail

getSimpleReact

ofType

cast

intersperse

skip

iterator

getLastActive

then

thenSync

fromStream

then

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

getTaskExecutor

isAsync