com.aol.simple.react.stream.traits

Interface BlockingStream<U>

All Superinterfaces:

ConfigurableStream<U>

All Known Subinterfaces:

EagerFutureStream<U>, FutureStream<U>, LazyFutureStream<U>, SimpleReactStream<U>

All Known Implementing Classes:

EagerFutureStreamImpl, LazyFutureStreamImpl, SimpleReactStreamImpl

public interface BlockingStream<U>
extends ConfigurableStream<U>

Field Summary

Fields

Modifier and Type	Field and Description
static ExceptionSoftener	exceptionSoftener

Method Summary

Modifier and Type	Method and Description
static <R> R	aggregateResults(java.util.stream.Collector collector, java.util.List<java.util.concurrent.CompletableFuture> completedFutures, java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)
default java.util.List<U>	block() React and block List<String> strings = new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3) .then((it) -> it * 100) .then((it) -> "*" + it) .block(); In this example, once the current thread of execution meets the React block method, it will block until all tasks have been completed.
default <R> R	block(java.util.stream.Collector collector)
default <R> R	block(java.util.stream.Collector collector, java.util.function.Predicate<Status> breakout)
default <R> R	block(java.util.stream.Collector collector, StreamWrapper lastActive)
default java.util.List<U>	block(java.util.function.Predicate<Status> breakout) React and block with breakout Sometimes you may not need to block until all the work is complete, one result or a subset may be enough.
default <R> R	blockAndExtract(Extractor extractor) Block until tasks complete and return a value determined by the extractor supplied.
default <R> R	blockAndExtract(Extractor extractor, java.util.function.Predicate<Status> breakout) Block until tasks complete, or breakout conditions met and return a value determined by the extractor supplied.
static void	capture(java.lang.Exception e, java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)
default ReactCollector<U>	collectResults() This provides a mechanism to collect all of the results of active tasks inside a dataflow stage.
default U	first() Block until first result received
static java.lang.Object	getSafe(java.util.concurrent.CompletableFuture next, java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)
default U	last() Block until all results received.
default <R> R	submitAndBlock(java.util.function.Function<java.util.List<U>,R> fn) This method allows the SimpleReact ExecutorService to be reused by JDK parallel streams.

Methods inherited from interface com.aol.simple.react.stream.traits.ConfigurableStream

getErrorHandler, getLastActive, getRetrier, getSimpleReact, getTaskExecutor, isEager, withEager, withErrorHandler, withLastActive, withLazyCollector, withQueueFactory, withRetrier, withTaskExecutor, withWaitStrategy

Field Detail

exceptionSoftener

static final ExceptionSoftener exceptionSoftener

Method Detail

collectResults

default ReactCollector<U> collectResults()

This provides a mechanism to collect all of the results of active tasks inside a dataflow stage. This can then be used to provide those results to a function. Inside that function client code can leverage JDK 8 parallel Streams that will be executed within the SimpleReact ExecutorService if that service is an instance of ForkJoinPool (the default setting). Example : Integer result = new SimpleReact() .<Integer, Integer> react(() -> 1, () -> 2, () -> 3) .then((it) -> { it * 200) .collectResults() .<List<Integer>>block() .submit( it -> it.orElse(new ArrayList()) .parallelStream() .filter(f -> f > 300) .map(m -> m - 5) .reduce(0, (acc, next) -> acc + next));

Returns:

A builder that allows the blocking mechanism for results collection to be set

block

default java.util.List<U> block()

React and block List<String> strings = new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3) .then((it) -> it * 100) .then((it) -> "*" + it) .block(); In this example, once the current thread of execution meets the React block method, it will block until all tasks have been completed. The result will be returned as a List. The Reactive tasks triggered by the Suppliers are non-blocking, and are not impacted by the block method until they are complete. Block, only blocks the current thread.

Returns:

Results of currently active stage aggregated in a List throws InterruptedException,ExecutionException

block

default <R> R block(java.util.stream.Collector collector)

Parameters:

collector - to perform aggregation / reduction operation on the results (e.g. to Collect into a List or String)

Returns:

Results of currently active stage in aggregated in form determined by collector throws InterruptedException,ExecutionException

block

default <R> R block(java.util.stream.Collector collector,
                    StreamWrapper lastActive)

aggregateResults

static <R> R aggregateResults(java.util.stream.Collector collector,
                              java.util.List<java.util.concurrent.CompletableFuture> completedFutures,
                              java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)

capture

static void capture(java.lang.Exception e,
                    java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)

getSafe

static java.lang.Object getSafe(java.util.concurrent.CompletableFuture next,
                                java.util.Optional<java.util.function.Consumer<java.lang.Throwable>> errorHandler)

first

default U first()

Block until first result received

Returns:

first result. throws InterruptedException,ExecutionException

last

default U last()

Block until all results received.

Returns:

last result throws InterruptedException,ExecutionException

blockAndExtract

default <R> R blockAndExtract(Extractor extractor)

Block until tasks complete and return a value determined by the extractor supplied.

Parameters:

extractor - used to determine which value should be returned, recieves current collected input and extracts a return value

Returns:

Value determined by the supplied extractor throws InterruptedException,ExecutionException

blockAndExtract

default <R> R blockAndExtract(Extractor extractor,
                              java.util.function.Predicate<Status> breakout)

Block until tasks complete, or breakout conditions met and return a value determined by the extractor supplied.

Parameters:

extractor - used to determine which value should be returned, recieves current collected input and extracts a return value

breakout - Predicate that determines whether the block should be continued or removed

Returns:

Value determined by the supplied extractor throws InterruptedException,ExecutionException

block

default java.util.List<U> block(java.util.function.Predicate<Status> breakout)

React and block with breakout Sometimes you may not need to block until all the work is complete, one result or a subset may be enough. To faciliate this, block can accept a Predicate functional interface that will allow SimpleReact to stop blocking the current thread when the Predicate has been fulfilled. E.g. List<String> strings = new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3) .then(it -> it * 100) .then(it -> "*" + it) .block(status -> status.getCompleted()>1); In this example the current thread will unblock once more than one result has been returned.

Parameters:

breakout - Predicate that determines whether the block should be continued or removed

Returns:

List of Completed results of currently active stage at full completion point or when breakout triggered (which ever comes first). throws InterruptedException,ExecutionException

block

default <R> R block(java.util.stream.Collector collector,
                    java.util.function.Predicate<Status> breakout)

Parameters:

collector - to perform aggregation / reduction operation on the results (e.g. to Collect into a List or String)

breakout - Predicate that determines whether the block should be continued or removed

Returns:

Completed results of currently active stage at full completion point or when breakout triggered (which ever comes first), in aggregated in form determined by collector throws InterruptedException,ExecutionException

submitAndBlock

default <R> R submitAndBlock(java.util.function.Function<java.util.List<U>,R> fn)

This method allows the SimpleReact ExecutorService to be reused by JDK parallel streams. This offers less control over blocking than raw submit, with the parameterless block() method called.

Parameters:

fn - Function that contains parallelStream code to be executed by the SimpleReact ForkJoinPool (if configured)