LazyReact (simple-react 1.0.0-RC2.3 API)

java.lang.Object
- com.aol.cyclops.control.LazyReact

All Implemented Interfaces:

ReactBuilder
```
public class LazyReact
extends java.lang.Object
implements ReactBuilder
```
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, boolean streamOfFutures, boolean objectPoolingActive, boolean autoOptimize, boolean autoMemoize, Cacheable memoizeCache)`
`LazyReact(int maxActive, java.util.concurrent.Executor executor)`
`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`	`autoMemoizeOn(Cacheable memoizeCache)`
`LazyReact`	`autoOptimizeOff()` Turn off automatic threading management.
`LazyReact`	`autoOptimizeOn()` Turn on automatic threading optimization.
`<U> LazyFutureStream<U>`	`construct(java.util.stream.Stream<U> 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 reactive flow from a Collection using an Iterator
`<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 reactive flow from a JDK Iterator
`LazyFutureStream<java.lang.Long>`	`from(java.util.stream.LongStream stream)` Start a reactive dataflow from a stream.
`<U> LazyFutureStream<U>`	`fromIterable(java.lang.Iterable<U> iter)`
`<U> LazyFutureStream<U>`	`fromIterableAsync(java.lang.Iterable<java.util.function.Supplier<U>> actions)`
`<U> LazyFutureStream<U>`	`fromIteratorAsync(java.util.Iterator<java.util.function.Supplier<U>> actions)`
`<T> LazyFutureStream<T>`	`fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)` Construct a LazyFutureStream from an Publisher
`<U> LazyFutureStream<U>`	`fromStream(java.util.stream.Stream<U> stream)`
`<U> LazyFutureStream<U>`	`fromStreamAsync(java.util.stream.Stream<java.util.function.Supplier<U>> actions)`
`<U> LazyFutureStream<U>`	`fromStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<U>> stream)`
`<U> LazyFutureStream<U>`	`generate(java.util.function.Supplier<U> generate)` Generate an infinite Stream
`<U> LazyFutureStream<U>`	`generateAsync(java.util.function.Supplier<U> s)`
`boolean`	`isAsync()`
`<U> LazyFutureStream<U>`	`iterate(U seed, java.util.function.UnaryOperator<U> f)` Iterate infinitely using the supplied seed and function Iteration is synchronized to support multiple threads using the same iterator.
`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)`
`<U> LazyFutureStream<U>`	`ofAsync(java.util.function.Supplier<U>... actions)`
`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)`
`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 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 maxActive,
 java.util.concurrent.Executor executor)
```
 - 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,
 boolean streamOfFutures,
 boolean objectPoolingActive,
 boolean autoOptimize,
 boolean autoMemoize,
 Cacheable memoizeCache)
```
 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
 - autoMemoizeOn
```
public LazyReact autoMemoizeOn(Cacheable memoizeCache)
```
 - isAsync
```
public boolean isAsync()
```
 - from
```
public  LazyFutureStream from(java.util.concurrent.CompletableFuture cf)
```
 - from
```
public  LazyFutureStream from(java.util.concurrent.CompletableFuture... cf)
```
 - construct
```
public  LazyFutureStream construct(java.util.stream.Stream s)
```
 - 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
 - fromPublisher
```
public <T> LazyFutureStream<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
```
 Construct a LazyFutureStream from an Publisher
 
 Parameters:
 
 publisher - to construct LazyFutureStream from
 
 Returns:
 
 LazyFutureStream
 - range
```
public LazyFutureStream<java.lang.Integer> range(int startInclusive,
 int endExclusive)
```
 - fromStreamFutures
```
public  LazyFutureStream fromStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture> stream)
```
 - ofAsync
```
@SafeVarargs
public final  LazyFutureStream ofAsync(java.util.function.Supplier... actions)
```
 - fromStream
```
public  LazyFutureStream fromStream(java.util.stream.Stream stream)
```
 - react
```
public  LazyFutureStream react(java.util.Collection<java.util.function.Supplier> actions)
```
 - fromIterable
```
public  LazyFutureStream fromIterable(java.lang.Iterable iter)
```
 - fromStreamAsync
```
public  LazyFutureStream fromStreamAsync(java.util.stream.Stream<java.util.function.Supplier> actions)
```
 - fromIteratorAsync
```
public  LazyFutureStream fromIteratorAsync(java.util.Iterator<java.util.function.Supplier> actions)
```
 - fromIterableAsync
```
public  LazyFutureStream fromIterableAsync(java.lang.Iterable<java.util.function.Supplier> actions)
```
 - 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
 - iterate
```
public  LazyFutureStream iterate(U seed,
 java.util.function.UnaryOperator f)
```
 Iterate infinitely using the supplied seed and function Iteration is synchronized to support multiple threads using the same iterator.
 
 Parameters:
 
 seed - Initial value
 
 f - Function that performs the iteration
 
 Returns:
 
 Next stage in the flow / stream
 
 See Also:
 
 for an alternative which does not synchronize iteration
 - generate
```
public  LazyFutureStream generate(java.util.function.Supplier generate)
```
 Generate an infinite Stream
```
 
 new LazyReact().generate(()->"hello")
 .limit(5)
 .reduce(Semigroups.stringConcat);
 
 //Optional[hellohellohellohellohello] 
 
 
```
 Parameters:
 
 generate - Supplier that generates stream input
 
 Returns:
 - generateAsync
```
public  LazyFutureStream generateAsync(java.util.function.Supplier s)
```
 - from
```
public  LazyFutureStream from(java.util.Iterator iterator)
```
 Start a reactive flow from a JDK Iterator
 
 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 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
 - from
```
public LazyFutureStream<java.lang.Integer> from(java.util.stream.IntStream 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
 - from
```
public LazyFutureStream<java.lang.Double> from(java.util.stream.DoubleStream 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
 - from
```
public LazyFutureStream<java.lang.Long> from(java.util.stream.LongStream 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
 - of
```
@SafeVarargs
public final  LazyFutureStream of(U... array)
```

Class LazyReact

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

LazyReact

LazyReact

LazyReact

LazyReact

LazyReact

LazyReact

Method Detail

autoMemoizeOn

isAsync

from

from

construct

constructFutures

objectPoolingOn

objectPoolingOff

autoOptimizeOn

autoOptimizeOff

async

sync

fromPublisher

range

fromStreamFutures

ofAsync

fromStream

react

fromIterable

fromStreamAsync

fromIteratorAsync

fromIterableAsync

parallelBuilder

parallelBuilder

parallelCommonBuilder

sequentialBuilder

sequentialCommonBuilder

sequentialCurrentBuilder

iterate

generate

generateAsync

from

from

from

from

from

of