com.aol.simple.react.stream.lazy

Class LazyReact

java.lang.Object

com.aol.simple.react.stream.BaseSimpleReact

com.aol.simple.react.stream.lazy.LazyReact

public class LazyReact
extends BaseSimpleReact

Builder class for LazyFutureStreams

Constructor Summary

Constructors

Constructor and Description
LazyReact() Construct a LazyReact builder using standard thread pool.
LazyReact(java.util.concurrent.ExecutorService executor) Construct a LazyReact builder with provided ExecutorService

Method Summary

Modifier and Type	Method and Description
<U> LazyFutureStream<U>	construct(java.util.stream.Stream s, java.util.concurrent.ExecutorService executor, com.nurkiewicz.asyncretry.RetryExecutor retrier, boolean eager)
<U> LazyFutureStream<U>	fromStream(java.util.stream.Stream<java.util.concurrent.CompletableFuture<U>> stream) Start a reactive dataflow from a stream of CompletableFutures.
<U> LazyFutureStream<U>	fromStreamWithoutFutures(java.util.stream.Stream<U> stream) Start a reactive dataflow from a stream.
<U> LazyFutureStream<U>	iterateInfinitely(U seed, java.util.function.UnaryOperator<U> f)
<U> LazyFutureStream<U>	of(U... array)
<U> LazyFutureStream<U>	react(java.util.function.Function<U,U> f, ReactIterator<U> t) Start a LazyFutureStream that calls the supplied function iteratively, with each output, feeding into the next input Example :- List<Integer> results = new LazyReact() .<Integer> react((input) -> input + 1,iterate(0).times(1).offset(10))
<U> LazyFutureStream<U>	react(java.util.Iterator<U> iterator, int maxTimes) Start a LazyFutureStream from a JDK Iterator
<U> LazyFutureStream<U>	react(java.util.List<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> s, Generator t) Start a LazyFutureStream from a single Supplier, which will be executed repeatedly according to rules defined by the generator.
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 LazyFutureStream The flow will run indefinitely unless / until the provided Supplier throws an Exception
<R> LazyFutureStream<R>	reactToCollection(java.util.Collection<R> collection) Start a LazyFutureStream from a Collection

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

getExecutor, getRetrier, isEager, iterate, react, times, timesInSequence

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.ExecutorService executor)

Construct a LazyReact builder with provided ExecutorService

Parameters:

executor - ExecutorService to use

Method Detail

construct

public <U> LazyFutureStream<U> 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 <U> LazyFutureStream<U> fromStream(java.util.stream.Stream<java.util.concurrent.CompletableFuture<U>> 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

fromStreamWithoutFutures

public <U> LazyFutureStream<U> fromStreamWithoutFutures(java.util.stream.Stream<U> stream)

Description copied from class: BaseSimpleReact

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 <U> LazyFutureStream<U> of(U... array)

Overrides:

of in class BaseSimpleReact

react

public <U> LazyFutureStream<U> react(java.util.List<java.util.function.Supplier<U>> 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

react

public <U> LazyFutureStream<U> react(java.util.Iterator<U> iterator,
                                     int maxTimes)

Start a LazyFutureStream 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> LazyFutureStream<R> reactToCollection(java.util.Collection<R> collection)

Start a LazyFutureStream from a Collection

Overrides:

reactToCollection in class BaseSimpleReact

Parameters:

collection - - Collection Stream will be formed from

Returns:

Next stage in the reactive flow

react

public <U> LazyFutureStream<U> react(java.util.function.Supplier<U> s,
                                     Generator t)

Start a LazyFutureStream 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 LazyReact() .<Integer> react(() -> count++ ,LazyReact.times(4)) To skip the first 5 iterations and take the next 5 * List<String> strings = new LazyReact() .<Integer> react(() -> count++ ,LazyReact.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 <U> LazyFutureStream<U> reactInfinitely(java.util.function.Supplier<U> s)

Generate an infinite LazyFutureStream 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 <U> LazyFutureStream<U> iterateInfinitely(U seed,
                                                 java.util.function.UnaryOperator<U> f)

Overrides:

iterateInfinitely in class BaseSimpleReact

react

public <U> LazyFutureStream<U> react(java.util.function.Function<U,U> f,
                                     ReactIterator<U> t)

Start a LazyFutureStream that calls the supplied function iteratively, with each output, feeding into the next input Example :- List<Integer> results = new LazyReact() .<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

reactI

protected <U> LazyFutureStream<U> reactI(java.util.function.Supplier<U>... 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