SimpleReact (simple-react 0.3 API)

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

public class SimpleReact
extends java.lang.Object

Entry point for creating a concurrent dataflow.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class SimpleReact.InfiniteProcessingException

Nested Classes
Modifier and Type	Class and Description
`static class`	`SimpleReact.InfiniteProcessingException`

Constructor Summary

Constructors
Constructor and Description
`SimpleReact()` Construct a new SimpleReact that will use a ForkJoinPool with parrellism set to the number of processors on the host
`SimpleReact(java.util.concurrent.ExecutorService executor)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<U> Stage<U>`	`fromStream(java.util.stream.Stream<java.util.concurrent.CompletableFuture<U>> stream)` Start a reactive dataflow from a stream of CompletableFutures.
`<U> Stage<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> Stage<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> Stage<U>`	`react(java.util.Iterator<U> iterator, int maxTimes)` Start a reactive flow from a JDK Iterator
`<U> Stage<U>`	`react(java.util.List<java.util.function.Supplier<U>> actions)` Start a reactive dataflow with a list of one-off-suppliers
`<U> Stage<U>`	`react(java.util.function.Supplier<U>... actions)` Start a reactive dataflow with an array of one-off-suppliers
`<U> Stage<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> Stage<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> Stage<U>`	`reactInfinitely(java.util.function.Supplier<U> s)` Generate an infinite reactive flow.
`<R> Stage<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 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
 - SimpleReact
```
public SimpleReact()
```
 Construct a new SimpleReact that will use a ForkJoinPool with parrellism set to the number of processors on the host
 - SimpleReact
```
public SimpleReact(java.util.concurrent.ExecutorService executor)
```
 Parameters:
 
 executor - Executor this SimpleReact instance will use to execute concurrent tasks.
- Method Detail
 - fromStream
```
public  Stage fromStream(java.util.stream.Stream<java.util.concurrent.CompletableFuture> stream)
```
 Start a reactive dataflow from a stream of CompletableFutures.
 
 Parameters:
 
 stream - of CompletableFutures that will be used to drive the reactive dataflow
 
 Returns:
 
 Next stage in the reactive flow
 - fromStreamWithoutFutures
```
public  Stage fromStreamWithoutFutures(java.util.stream.Stream stream)
```
 Start a reactive dataflow from a stream.
 
 Parameters:
 
 stream - that will be used to drive the reactive dataflow
 
 Returns:
 
 Next stage in the reactive flow
 - react
```
public  Stage react(java.util.List<java.util.function.Supplier> actions)
```
 Start a reactive dataflow with a list of one-off-suppliers
 
 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  Stage react(java.util.Iterator iterator,
 int maxTimes)
```
 Start a reactive flow from a JDK Iterator
 
 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> Stage<R> reactToCollection(java.util.Collection<R> collection)
```
 Start a reactive flow from a Collection using an Iterator
 
 Parameters:
 
 collection - - Collection SimpleReact will iterate over at the start of the flow
 
 Returns:
 
 Next stage in the reactive flow
 - react
```
public  Stage 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.
 
 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  Stage 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
 
 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
 - 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  Stage 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))
 
 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  Stage react(java.util.function.Supplier... actions)
```
 Start a reactive dataflow with an array of one-off-suppliers
 
 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  Stage 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

Class SimpleReact

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SimpleReact

SimpleReact

Method Detail

fromStream

fromStreamWithoutFutures

react

react

reactToCollection

react

reactInfinitely

times

timesInSequence

react

iterate

react

reactI