SimpleReact (simple-react 0.4 API)

java.lang.Object
- com.aol.simple.react.stream.BaseSimpleReact
- - com.aol.simple.react.stream.simple.SimpleReact

public class SimpleReact
extends BaseSimpleReact

Builder class for FutureStream

Constructor Summary

Constructors
Constructor and Description

SimpleReact()
Construct a SimpleReact builder using standard thread pool.

SimpleReact(java.util.concurrent.ExecutorService executor)

Constructors
Constructor and Description
`SimpleReact()` Construct a SimpleReact builder using standard thread pool.
`SimpleReact(java.util.concurrent.ExecutorService executor)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<U> SimpleReactStream<U>`	`construct(java.util.stream.Stream s, java.util.concurrent.ExecutorService executor, com.nurkiewicz.asyncretry.RetryExecutor retrier, boolean eager)`
`<U> SimpleReactStream<U>`	`fromStream(java.util.stream.Stream<java.util.concurrent.CompletableFuture<U>> stream)` Start a reactive dataflow from a stream of CompletableFutures.
`<U> SimpleReactStream<U>`	`fromStreamWithoutFutures(java.util.stream.Stream<U> stream)` Start a reactive dataflow from a stream.
`static <T> ReactIterator<T>`	`iterate(T seed)` Create an iterator that manages a function call starting with the supplied seed value
`<U> SimpleReactStream<U>`	`iterateInfinitely(U seed, java.util.function.UnaryOperator<U> f)`
`<U> SimpleReactStream<U>`	`of(U... array)`
`<U> SimpleReactStream<U>`	`react(java.util.function.Function<U,U> f, ReactIterator<U> t)` Start a reactive dataflow that calls the supplied function iteratively, with each output, feeding into the next input Example :- `List<Integer> results = new SimpleReact() .<Integer> react((input) -> input + 1,iterate(0).times(1).offset(10))`
`<U> SimpleReactStream<U>`	`react(java.util.Iterator<U> iterator, int maxTimes)` Start a reactive flow from a JDK Iterator
`<U> SimpleReactStream<U>`	`react(java.util.List<java.util.function.Supplier<U>> actions)` Start a reactive dataflow with a list of one-off-suppliers
`<U> SimpleReactStream<U>`	`react(java.util.function.Supplier<U>... actions)` Start a reactive dataflow with an array of one-off-suppliers
`<U> SimpleReactStream<U>`	`react(java.util.function.Supplier<U> s, Generator t)` Start a reactive dataflow from a single Supplier, which will be executed repeatedly according to rules defined by the generator.
`protected <U> SimpleReactStream<U>`	`reactI(java.util.function.Supplier<U>... actions)` This internal method has been left protected, so it can be mocked / stubbed as some of the entry points are final
`<U> SimpleReactStream<U>`	`reactInfinitely(java.util.function.Supplier<U> s)` Generate an infinite reactive flow.
`<R> SimpleReactStream<R>`	`reactToCollection(java.util.Collection<R> collection)` Start a reactive flow from a Collection using an Iterator
`static ParallelGenerator`	`times(int times)` Create a Sequential Generator that will trigger a Supplier to be called the specified number of times
`static ParallelGenerator`	`timesInSequence(int times)` Create a Parallel Generator that will trigger a Supplier to be called the specified number of times

Methods inherited from class com.aol.simple.react.stream.BaseSimpleReact
getExecutor, getRetrier, isEager

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
 - SimpleReact
```
public SimpleReact()
```
 Construct a SimpleReact builder using standard thread pool. By default, unless ThreadPools is configured otherwise this will be sized to the available processors
 
 See Also:
 
 ThreadPools.getStandard()
 - SimpleReact
```
public SimpleReact(java.util.concurrent.ExecutorService executor)
```
 Parameters:
 
 executor - Executor this SimpleReact instance will use to execute concurrent tasks.
- Method Detail
 - construct
```
public  SimpleReactStream construct(java.util.stream.Stream s,
 java.util.concurrent.ExecutorService executor,
 com.nurkiewicz.asyncretry.RetryExecutor retrier,
 boolean eager)
```
 Specified by:
 
 construct in class BaseSimpleReact
 - fromStream
```
public  SimpleReactStream fromStream(java.util.stream.Stream<java.util.concurrent.CompletableFuture> stream)
```
 Start a reactive dataflow from a stream of CompletableFutures.
 
 Overrides:
 
 fromStream in class BaseSimpleReact
 
 Parameters:
 
 stream - of CompletableFutures that will be used to drive the reactive dataflow
 
 Returns:
 
 Next stage in the reactive flow
 - fromStreamWithoutFutures
```
public  SimpleReactStream fromStreamWithoutFutures(java.util.stream.Stream stream)
```
 Start a reactive dataflow from a stream.
 
 Overrides:
 
 fromStreamWithoutFutures in class BaseSimpleReact
 
 Parameters:
 
 stream - that will be used to drive the reactive dataflow
 
 Returns:
 
 Next stage in the reactive flow
 - of
```
public  SimpleReactStream of(U... array)
```
 Overrides:
 
 of in class BaseSimpleReact
 - react
```
public  SimpleReactStream react(java.util.List<java.util.function.Supplier> actions)
```
 Start a reactive dataflow with a list of one-off-suppliers
 
 Overrides:
 
 react in class BaseSimpleReact
 
 Parameters:
 
 actions - List of Suppliers to provide data (and thus events) that downstream jobs will react too
 
 Returns:
 
 Next stage in the reactive flow
 - react
```
public  SimpleReactStream react(java.util.Iterator iterator,
 int maxTimes)
```
 Start a reactive flow from a JDK Iterator
 
 Overrides:
 
 react in class BaseSimpleReact
 
 Parameters:
 
 iterator - SimpleReact will iterate over this iterator concurrently to start the reactive dataflow
 
 maxTimes - Maximum number of iterations
 
 Returns:
 
 Next stage in the reactive flow
 - reactToCollection
```
public <R> SimpleReactStream<R> reactToCollection(java.util.Collection<R> collection)
```
 Start a reactive flow from a Collection using an Iterator
 
 Overrides:
 
 reactToCollection in class BaseSimpleReact
 
 Parameters:
 
 collection - - Collection SimpleReact will iterate over at the start of the flow
 
 Returns:
 
 Next stage in the reactive flow
 - react
```
public  SimpleReactStream react(java.util.function.Supplier s,
 Generator t)
```
 Start a reactive dataflow from a single Supplier, which will be executed repeatedly according to rules defined by the generator. Example : To execute the same Supplier 4 times use : List<String> strings = new SimpleReact() .<Integer> react(() -> count++ ,SimpleReact.times(4)) To skip the first 5 iterations and take the next 5 * List<String> strings = new SimpleReact() .<Integer> react(() -> count++ ,SimpleReact.times(5).offset(5)) The supplier will be called 10 times, in the above example, but only the last 5 results will be passed into the reactive dataflow.
 
 Overrides:
 
 react in class BaseSimpleReact
 
 Parameters:
 
 s - Supplier to provide data (and thus events) that downstream jobs will react too
 
 t - Generator implementation that will determine how the Supplier is executed
 
 Returns:
 
 Next stage in the reactive flow
 - reactInfinitely
```
public  SimpleReactStream reactInfinitely(java.util.function.Supplier s)
```
 Generate an infinite reactive flow. Requires a lazy flow. The flow will run indefinitely unless / until the provided Supplier throws an Exception
 
 Overrides:
 
 reactInfinitely in class BaseSimpleReact
 
 Parameters:
 
 s - Supplier to generate the infinite flow
 
 Returns:
 
 Next stage in the flow
 
 See Also:
 
 SimpleReact Queue for a way to create a more managable infinit flow
 - iterateInfinitely
```
public  SimpleReactStream iterateInfinitely(U seed,
 java.util.function.UnaryOperator f)
```
 Overrides:
 
 iterateInfinitely in class BaseSimpleReact
 - times
```
public static ParallelGenerator times(int times)
```
 Create a Sequential Generator that will trigger a Supplier to be called the specified number of times
 
 Parameters:
 
 times - Number of times the Supplier should be called at the start of the reactive dataflow
 
 Returns:
 
 Sequential Generator
 - timesInSequence
```
public static ParallelGenerator timesInSequence(int times)
```
 Create a Parallel Generator that will trigger a Supplier to be called the specified number of times
 
 Parameters:
 
 times - Number of times the Supplier should be called at the start of the reactive dataflow
 
 Returns:
 
 Parellel Generator
 - react
```
public  SimpleReactStream react(java.util.function.Function<U,U> f,
 ReactIterator t)
```
 Start a reactive dataflow that calls the supplied function iteratively, with each output, feeding into the next input Example :- List<Integer> results = new SimpleReact() .<Integer> react((input) -> input + 1,iterate(0).times(1).offset(10))
 
 Overrides:
 
 react in class BaseSimpleReact
 
 Parameters:
 
 f - Function to be called iteratively
 
 t - Iterator that manages function call
 
 Returns:
 
 Next stage in the reactive flow
 - iterate
```
public static <T> ReactIterator<T> iterate(T seed)
```
 Create an iterator that manages a function call starting with the supplied seed value
 
 Parameters:
 
 seed - Initial value that iterator will apply to the function it iterates over
 
 Returns:
 
 Populated ReactIterator
 - react
```
@SafeVarargs
public final  SimpleReactStream react(java.util.function.Supplier... actions)
```
 Start a reactive dataflow with an array of one-off-suppliers
 
 Overrides:
 
 react in class BaseSimpleReact
 
 Parameters:
 
 actions - Array of Suppliers to provide data (and thus events) that downstream jobs will react too
 
 Returns:
 
 Next stage in the reactive flow
 - reactI
```
protected  SimpleReactStream reactI(java.util.function.Supplier... actions)
```
 This internal method has been left protected, so it can be mocked / stubbed as some of the entry points are final
 
 Overrides:
 
 reactI in class BaseSimpleReact

Class SimpleReact

Constructor Summary

Method Summary

Methods inherited from class com.aol.simple.react.stream.BaseSimpleReact

Methods inherited from class java.lang.Object

Constructor Detail

SimpleReact

SimpleReact

Method Detail

construct

fromStream

fromStreamWithoutFutures

of

react

react

reactToCollection

react

reactInfinitely

iterateInfinitely

times

timesInSequence

react

iterate

react

reactI