LazyReact (simple-react 0.99.2 API)

java.lang.Object
- com.aol.simple.react.stream.BaseSimpleReact
- - com.aol.simple.react.stream.lazy.LazyReact

All Implemented Interfaces:

ReactBuilder
```
public class LazyReact
extends BaseSimpleReact
```
Builder class for LazyFutureStreams react methods - submit Suppliers to task executor of methods - build Streams directly from data

Constructor Summary

Constructors
Constructor and Description
`LazyReact()` Construct a LazyReact builder using standard thread pool.
`LazyReact(java.util.concurrent.Executor executor)` Construct a LazyReact builder with provided Executor
`LazyReact(java.util.concurrent.Executor currentThreadExecutor, com.nurkiewicz.asyncretry.AsyncRetryExecutor withScheduler, boolean async, MaxActive maxActive2)`
`LazyReact(java.util.concurrent.Executor executor, com.nurkiewicz.asyncretry.RetryExecutor retrier, java.lang.Boolean async, MaxActive maxActive, java.util.concurrent.Executor pub, boolean streamOfFutures, boolean objectPoolingActive, boolean autoOptimize)`
`LazyReact(int threadPoolSize, int maxActiveTasks)` LazyReact builder with a new TaskExecutor with threads determined by threadPoolSize Max concurrent tasks is determined by concurrency

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`LazyReact`	`async()` Start any created Streams in asyncrhonous mode - that is tasks will be submited to an Executor to be run.
`LazyReact`	`autoOptimizeOff()` Turn off automatic threading management.
`LazyReact`	`autoOptimizeOn()` Turn on automatic threading optimization.
`<U> LazyFutureStream<U>`	`construct(java.util.stream.Stream s)`
`<U> LazyFutureStream<U>`	`constructFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<U>> s)`
`<R> LazyFutureStream<R>`	`from(java.util.Collection<R> collection)` Start a LazyFutureStream from a Collection
`<U> LazyFutureStream<U>`	`from(java.util.concurrent.CompletableFuture<U>... cf)`
`<U> LazyFutureStream<U>`	`from(java.util.concurrent.CompletableFuture<U> cf)`
`LazyFutureStream<java.lang.Double>`	`from(java.util.stream.DoubleStream stream)` Start a reactive dataflow from a stream.
`LazyFutureStream<java.lang.Integer>`	`from(java.util.stream.IntStream stream)` Start a reactive dataflow from a stream.
`<U> LazyFutureStream<U>`	`from(java.util.Iterator<U> iterator)` Start a LazyFutureStream from a JDK Iterator
`LazyFutureStream<java.lang.Long>`	`from(java.util.stream.LongStream stream)` Start a reactive dataflow from a stream.
`<U> LazyFutureStream<U>`	`from(java.util.stream.Stream<U> stream)` Start a reactive dataflow from a stream.
`<U> LazyFutureStream<U>`	`fromIterable(java.lang.Iterable<U> iter)` Start a reactive flow from a JDK Iterator
`<U> LazyFutureStream<U>`	`fromStream(java.util.stream.Stream<java.util.concurrent.CompletableFuture<U>> stream)` Start a reactive dataflow from a stream of CompletableFutures.
`boolean`	`isAsync()`
`<U> LazyFutureStream<U>`	`iterateInfinitely(U seed, java.util.function.UnaryOperator<U> f)` Iterate infinitely using the supplied seed and function
`LazyReact`	`objectPoolingOff()` Turn objectPooling off for any Streams created by the returned LazyReact builder.
`LazyReact`	`objectPoolingOn()` Turn objectPooling on for any Streams created by the returned LazyReact builder This improves performance for Streams with very large numbers of elements, by reusing Future instances.
`<U> LazyFutureStream<U>`	`of(U... array)`
`static LazyReact`	`parallelBuilder()`
`static LazyReact`	`parallelBuilder(int parallelism)` Construct a new LazyReact builder, with a new task executor and retry executor with configured number of threads
`static LazyReact`	`parallelCommonBuilder()`
`LazyFutureStream<java.lang.Integer>`	`range(int startInclusive, int endExclusive)`
`<U> LazyFutureStream<U>`	`react(java.util.Collection<java.util.function.Supplier<U>> actions)` Start a reactive dataflow with a list of one-off-suppliers
`<U> LazyFutureStream<U>`	`react(java.util.Iterator<java.util.function.Supplier<U>> actions)` Start a reactive dataflow with a list of one-off-suppliers
`<U> LazyFutureStream<U>`	`react(java.util.stream.Stream<java.util.function.Supplier<U>> actions)` Start a reactive dataflow with a list of one-off-suppliers
`<U> LazyFutureStream<U>`	`react(java.util.function.Supplier<U>... actions)` Start a reactive dataflow with an array of one-off-suppliers
`protected <U> LazyFutureStream<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> LazyFutureStream<U>`	`reactInfinitely(java.util.function.Supplier<U> s)` Generate an infinite reactive flow.
`<U> LazyFutureStream<U>`	`reactInfinitelyAsync(java.util.function.Supplier<U> s)` Generate an infinite reactive flow.
`<U> LazyFutureStream<U>`	`reactIterable(java.lang.Iterable<java.util.function.Supplier<U>> actions)` Start a reactive dataflow with a list of one-off-suppliers
`static LazyReact`	`sequentialBuilder()`
`static LazyReact`	`sequentialCommonBuilder()`
`static LazyReact`	`sequentialCurrentBuilder()`
`LazyReact`	`sync()` Start any created Streams in syncrhonous mode - that is tasks will be executed on the calling thread

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

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

- Constructor Detail
 - LazyReact
```
public LazyReact()
```
 Construct a LazyReact builder using standard thread pool. By default, unless ThreadPools is configured otherwise this will be sized to the available processors
 
 See Also:
 
 ThreadPools.getStandard()
 - LazyReact
```
public LazyReact(java.util.concurrent.Executor executor)
```
 Construct a LazyReact builder with provided Executor
 
 Parameters:
 
 executor - Executor to use
 - LazyReact
```
public LazyReact(int threadPoolSize,
 int maxActiveTasks)
```
 LazyReact builder with a new TaskExecutor with threads determined by threadPoolSize Max concurrent tasks is determined by concurrency
 
 Parameters:
 
 threadPoolSize -
 
 maxActiveTasks -
 - LazyReact
```
public LazyReact(java.util.concurrent.Executor executor,
 com.nurkiewicz.asyncretry.RetryExecutor retrier,
 java.lang.Boolean async,
 MaxActive maxActive,
 java.util.concurrent.Executor pub,
 boolean streamOfFutures,
 boolean objectPoolingActive,
 boolean autoOptimize)
```
 Parameters:
 
 executor - Task Executor for concurrent tasks
 
 retrier - Async Retrier
 
 async - If true each task will be submitted to an executor service
 - LazyReact
```
public LazyReact(java.util.concurrent.Executor currentThreadExecutor,
 com.nurkiewicz.asyncretry.AsyncRetryExecutor withScheduler,
 boolean async,
 MaxActive maxActive2)
```
- Method Detail
 - isAsync
```
public boolean isAsync()
```
 Specified by:
 
 isAsync in class BaseSimpleReact
 - from
```
public  LazyFutureStream from(java.util.concurrent.CompletableFuture cf)
```
 Overrides:
 
 from in class BaseSimpleReact
 - from
```
public  LazyFutureStream from(java.util.concurrent.CompletableFuture... cf)
```
 Overrides:
 
 from in class BaseSimpleReact
 - construct
```
public  LazyFutureStream construct(java.util.stream.Stream s)
```
 Specified by:
 
 construct in class BaseSimpleReact
 - constructFutures
```
public  LazyFutureStream constructFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture> s)
```
 - objectPoolingOn
```
public LazyReact objectPoolingOn()
```
 Turn objectPooling on for any Streams created by the returned LazyReact builder This improves performance for Streams with very large numbers of elements, by reusing Future instances. By default Object Pooling is Off.
```
 
 return new LazyReact()
						.objectPoolingOn()
						.range(0,5_000_000_000)
						.map(this::process)
						.forEach(System.out::println);
	 
 
```
 Returns:
 
 New LazyReact builder with Object pooling on.
 - objectPoolingOff
```
public LazyReact objectPoolingOff()
```
 Turn objectPooling off for any Streams created by the returned LazyReact builder. By default Object Pooling is Off.
```
 
 	LazyReact react; 
 
 react.objectPoolingOff()
						.range(0,5_000)
						.map(this::process)
						.forEach(System.out::println);
 
 
```
 Returns:
 
 New LazyReact builder with Object pooling off.
 - autoOptimizeOn
```
public LazyReact autoOptimizeOn()
```
 Turn on automatic threading optimization. Tasks will be 'fanned' out across threads initially and subsequent task completion events will trigger further processing on the same thread. Where operations require working on the results of multiple tasks, data will be forwarded to a Queue, data read from the queue will then also be 'fanned' out for processing across threads (with subsequent events again occuring on the same thread). This is equivalent to optimal use of the async() and sync() operators on a Stream. autoOptimize overrides direct calls to sync() and async() on the Stream. By default autoOptimize is On.
```
 
 new LazyReact().autoOptimizeOn()
 .range(0, 1_000_000)
						.map(i->i+2)
						.map(i->Thread.currentThread().getId())
						.peek(System.out::println)
						.runOnCurrent();
 
 
```
 Returns:
 - autoOptimizeOff
```
public LazyReact autoOptimizeOff()
```
 Turn off automatic threading management. This allows use async() and sync() to control fan out directly in a LazyFutureStream By default autoOptimize is On.
```
 
 	LazyReact react; 
 
 react.autoOptimizeOff()
					 .range(0, 1_000_000)
						.map(i->i+2)
						.map(i->Thread.currentThread().getId())
						.peek(System.out::println)
						.runOnCurrent();
 
 
```
 Returns:
 - async
```
public LazyReact async()
```
 Start any created Streams in asyncrhonous mode - that is tasks will be submited to an Executor to be run.
 
 Returns:
 
 LazyReact that creates Streams in async mode
 - sync
```
public LazyReact sync()
```
 Start any created Streams in syncrhonous mode - that is tasks will be executed on the calling thread
 
 Returns:
 
 LazyReact that creates Streams in sync mode
 - range
```
public LazyFutureStream<java.lang.Integer> range(int startInclusive,
 int endExclusive)
```
 Overrides:
 
 range in class BaseSimpleReact
 - fromStream
```
public  LazyFutureStream fromStream(java.util.stream.Stream<java.util.concurrent.CompletableFuture> stream)
```
 Description copied from class: BaseSimpleReact
 
 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
 - react
```
@SafeVarargs
public final  LazyFutureStream react(java.util.function.Supplier... actions)
```
 Description copied from class: BaseSimpleReact
 
 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
 - from
```
public  LazyFutureStream from(java.util.stream.Stream stream)
```
 Description copied from class: BaseSimpleReact
 
 Start a reactive dataflow from a stream.
 
 Overrides:
 
 from in class BaseSimpleReact
 
 Parameters:
 
 stream - that will be used to drive the reactive dataflow
 
 Returns:
 
 Next stage in the reactive flow
 - from
```
public LazyFutureStream<java.lang.Integer> from(java.util.stream.IntStream stream)
```
 Description copied from class: BaseSimpleReact
 
 Start a reactive dataflow from a stream.
 
 Overrides:
 
 from in class BaseSimpleReact
 
 Parameters:
 
 stream - that will be used to drive the reactive dataflow
 
 Returns:
 
 Next stage in the reactive flow
 - from
```
public LazyFutureStream<java.lang.Double> from(java.util.stream.DoubleStream stream)
```
 Description copied from class: BaseSimpleReact
 
 Start a reactive dataflow from a stream.
 
 Overrides:
 
 from in class BaseSimpleReact
 
 Parameters:
 
 stream - that will be used to drive the reactive dataflow
 
 Returns:
 
 Next stage in the reactive flow
 - from
```
public LazyFutureStream<java.lang.Long> from(java.util.stream.LongStream stream)
```
 Description copied from class: BaseSimpleReact
 
 Start a reactive dataflow from a stream.
 
 Overrides:
 
 from in class BaseSimpleReact
 
 Parameters:
 
 stream - that will be used to drive the reactive dataflow
 
 Returns:
 
 Next stage in the reactive flow
 - of
```
public  LazyFutureStream of(U... array)
```
 Overrides:
 
 of in class BaseSimpleReact
 - react
```
public  LazyFutureStream react(java.util.Collection<java.util.function.Supplier> actions)
```
 Description copied from class: BaseSimpleReact
 
 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
 - from
```
public  LazyFutureStream from(java.util.Iterator iterator)
```
 Start a LazyFutureStream from a JDK Iterator
 
 Overrides:
 
 from in class BaseSimpleReact
 
 Parameters:
 
 iterator - SimpleReact will iterate over this iterator concurrently to start the reactive dataflow
 
 Returns:
 
 Next stage in the reactive flow
 - from
```
public <R> LazyFutureStream<R> from(java.util.Collection<R> collection)
```
 Start a LazyFutureStream from a Collection
 
 Overrides:
 
 from in class BaseSimpleReact
 
 Parameters:
 
 collection - - Collection Stream will be formed from
 
 Returns:
 
 Next stage in the reactive flow
 - reactI
```
protected  LazyFutureStream reactI(java.util.function.Supplier... actions)
```
 Description copied from class: BaseSimpleReact
 
 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
 - fromIterable
```
public  LazyFutureStream fromIterable(java.lang.Iterable iter)
```
 Description copied from class: BaseSimpleReact
 
 Start a reactive flow from a JDK Iterator
 
 Overrides:
 
 fromIterable in class BaseSimpleReact
 
 Parameters:
 
 iter - SimpleReact will iterate over this iterator concurrently to start the reactive dataflow
 
 Returns:
 
 Next stage in the reactive flow
 - react
```
public  LazyFutureStream react(java.util.stream.Stream<java.util.function.Supplier> actions)
```
 Description copied from class: BaseSimpleReact
 
 Start a reactive dataflow with a list of one-off-suppliers
 
 Overrides:
 
 react in class BaseSimpleReact
 
 Parameters:
 
 actions - Stream of Suppliers to provide data (and thus events) that downstream jobs will react too
 
 Returns:
 
 Next stage in the reactive flow
 - react
```
public  LazyFutureStream react(java.util.Iterator<java.util.function.Supplier> actions)
```
 Description copied from class: BaseSimpleReact
 
 Start a reactive dataflow with a list of one-off-suppliers
 
 Overrides:
 
 react in class BaseSimpleReact
 
 Parameters:
 
 actions - Iterator over Suppliers to provide data (and thus events) that downstream jobs will react too
 
 Returns:
 
 Next stage in the reactive flow
 - reactIterable
```
public  LazyFutureStream reactIterable(java.lang.Iterable<java.util.function.Supplier> actions)
```
 Description copied from class: BaseSimpleReact
 
 Start a reactive dataflow with a list of one-off-suppliers
 
 Overrides:
 
 reactIterable in class BaseSimpleReact
 
 Parameters:
 
 actions - Stream of Suppliers to provide data (and thus events) that downstream jobs will react too
 
 Returns:
 
 Next stage in the reactive flow
 - parallelBuilder
```
public static LazyReact parallelBuilder()
```
 Returns:
 
 Lazy SimpleReact for handling infinite streams
 - parallelBuilder
```
public static LazyReact parallelBuilder(int parallelism)
```
 Construct a new LazyReact builder, with a new task executor and retry executor with configured number of threads
 
 Parameters:
 
 parallelism - Number of threads task executor should have
 
 Returns:
 
 LazyReact instance
 - parallelCommonBuilder
```
public static LazyReact parallelCommonBuilder()
```
 Returns:
 
 new LazyReact builder configured with standard parallel executor By default this is the ForkJoinPool common instance but is configurable in the ThreadPools class
 
 See Also:
 
 see RetryBuilder#getDefaultInstance()
 - sequentialBuilder
```
public static LazyReact sequentialBuilder()
```
 Returns:
 
 new LazyReact builder configured to run on a separate thread (non-blocking current thread), sequentially New ForkJoinPool will be created
 - sequentialCommonBuilder
```
public static LazyReact sequentialCommonBuilder()
```
 Returns:
 
 LazyReact builder configured to run on a separate thread (non-blocking current thread), sequentially Common free thread Executor from
 - sequentialCurrentBuilder
```
public static LazyReact sequentialCurrentBuilder()
```
 Returns:
 
 LazyReact builder configured to run on a separate thread (non-blocking current thread), sequentially Common free thread Executor from
 - reactInfinitely
```
public  LazyFutureStream reactInfinitely(java.util.function.Supplier s)
```
 Generate an infinite reactive flow. Requires a lazy flow. Supplier will be executed multiple times sequentially / synchronously by populating thread. 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
 - reactInfinitelyAsync
```
public  LazyFutureStream reactInfinitelyAsync(java.util.function.Supplier s)
```
 Generate an infinite reactive flow. Requires a lazy flow. Supplier may be executed multiple times in parallel asynchronously by populating thread. Active CompletableFutures may grow rapidly. 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
 - iterateInfinitely
```
public  LazyFutureStream iterateInfinitely(U seed,
 java.util.function.UnaryOperator f)
```
 Iterate infinitely using the supplied seed and function
 
 Parameters:
 
 seed - Initial value
 
 f - Function that performs the iteration
 
 Returns:
 
 Next stage in the flow / stream

Class LazyReact

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Constructor Detail

LazyReact

LazyReact

LazyReact

LazyReact

LazyReact

Method Detail

isAsync

from

from

construct

constructFutures

objectPoolingOn

objectPoolingOff

autoOptimizeOn

autoOptimizeOff

async

sync

range

fromStream

react

from

from

from

from

of

react

from

from

reactI

fromIterable

react

react

reactIterable

parallelBuilder

parallelBuilder

parallelCommonBuilder

sequentialBuilder

sequentialCommonBuilder

sequentialCurrentBuilder

reactInfinitely

reactInfinitelyAsync

iterateInfinitely