Stage (simple-react 0.3 API)

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

Type Parameters:

U - Return parameter for this stage

All Implemented Interfaces:

java.lang.AutoCloseable, java.lang.Iterable, java.util.stream.BaseStream<U,java.util.stream.Stream>, java.util.stream.Stream, org.jooq.lambda.Seq
```
public class Stage
extends java.lang.Object
implements org.jooq.lambda.Seq
```
An Immutable Builder Class that represents a stage in a SimpleReact Dataflow. Chain stages together to build complext reactive dataflows. Access the underlying CompletableFutures via the 'with' method. Return to using JDK Collections and (parrellel) Streams via 'allOf' or 'block'

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.stream.Stream
 java.util.stream.Stream.Builder<T>

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allMatch(java.util.function.Predicate<? super U> predicate)`
`<T,R> Stage<R>`	`allOf(java.util.stream.Collector collector, java.util.function.Function<T,R> fn)`
`<T,R> Stage<R>`	`allOf(java.util.function.Function<java.util.List<T>,R> fn)` React and allOf allOf is a non-blocking equivalent of block.
`boolean`	`anyMatch(java.util.function.Predicate<? super U> predicate)`
`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.
`<R> R`	`block(java.util.stream.Collector collector)`
`<R> R`	`block(java.util.stream.Collector collector, java.util.function.Predicate<Status> breakout)`
`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.
`<R> R`	`blockAndExtract(Extractor extractor)` Block until tasks complete and return a value determined by the extractor supplied.
`<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.
`Stage<U>`	`capture(java.util.function.Consumer<? extends java.lang.Throwable> errorHandler)` React capture While onFail is used for disaster recovery (when it is possible to recover) - capture is used to capture those occasions where the full pipeline has failed and is unrecoverable.
`void`	`close()`
`<R,A> R`	`collect(java.util.stream.Collector<? super U,A,R> collector)`
`<R> R`	`collect(java.util.function.Supplier<R> supplier, java.util.function.BiConsumer<R,? super U> accumulator, java.util.function.BiConsumer<R,R> combiner)`
`ReactCollector<U>`	`collectResults()` This provides a mechanism to collect all of the results of active tasks inside a dataflow stage.
`long`	`count()`
`org.jooq.lambda.Seq<U>`	`distinct()`
`Stage<U>`	`filter(java.util.function.Predicate<? super U> p)` Removes elements that do not match the supplied predicate from the dataflow
`java.util.Optional<U>`	`findAny()`
`java.util.Optional<U>`	`findFirst()`
`U`	`first()` Block until first result received
`<R> Stage<R>`	`flatMap(java.util.function.Function<? super U,? extends java.util.stream.Stream<? extends R>> flatFn)`
`java.util.stream.DoubleStream`	`flatMapToDouble(java.util.function.Function<? super U,? extends java.util.stream.DoubleStream> mapper)`
`java.util.stream.IntStream`	`flatMapToInt(java.util.function.Function<? super U,? extends java.util.stream.IntStream> mapper)`
`java.util.stream.LongStream`	`flatMapToLong(java.util.function.Function<? super U,? extends java.util.stream.LongStream> mapper)`
`void`	`forEach(java.util.function.Consumer<? super U> action)`
`void`	`forEachOrdered(java.util.function.Consumer<? super U> action)`
`boolean`	`isParallel()`
`java.util.Iterator<U>`	`iterator()` Stream and Seq supporting methods
`U`	`last()` Block until all results received.
`org.jooq.lambda.Seq<U>`	`limit(long maxSize)`
`<R> Stage<R>`	`map(java.util.function.Function<? super U,? extends R> mapper)`
`java.util.stream.DoubleStream`	`mapToDouble(java.util.function.ToDoubleFunction<? super U> mapper)`
`java.util.stream.IntStream`	`mapToInt(java.util.function.ToIntFunction<? super U> mapper)`
`java.util.stream.LongStream`	`mapToLong(java.util.function.ToLongFunction<? super U> mapper)`
`java.util.Optional<U>`	`max(java.util.Comparator<? super U> comparator)`
`Stage<U>`	`merge(Stage<U> s)` Merge this reactive dataflow with another of the same type.
`static <R> Stage<R>`	`merge(Stage s1, Stage s2)` Merge this reactive dataflow with another - recommended for merging different types.
`java.util.Optional<U>`	`min(java.util.Comparator<? super U> comparator)`
`boolean`	`noneMatch(java.util.function.Predicate<? super U> predicate)`
`org.jooq.lambda.Seq<U>`	`onClose(java.lang.Runnable closeHandler)`
`Stage<U>`	`onFail(java.util.function.Function<? extends java.lang.Throwable,U> fn)` React onFail Define a function that can be used to recover from exceptions during the preceeding stage of the dataflow.
`Stage<U>`	`parallel()`
`Stage<U>`	`peek(java.util.function.Consumer<? super U> consumer)` Peek asynchronously at the results in the current stage.
`java.util.Optional<U>`	`reduce(java.util.function.BinaryOperator<U> accumulator)`
`<R> R`	`reduce(R identity, java.util.function.BiFunction<R,? super U,R> accumulator, java.util.function.BinaryOperator<R> combiner)`
`U`	`reduce(U identity, java.util.function.BinaryOperator<U> accumulator)`
`<R> Stage<R>`	`retry(java.util.function.Function<U,R> fn)` Will execute this phase on the RetryExecutor (default or user supplied).
`void`	`run()` Trigger a lazy stream
`void`	`run(java.util.concurrent.ExecutorService e)` Trigger a lazy stream as a task on the provided ExecutorService
`void`	`run(java.util.concurrent.ExecutorService e, java.lang.Runnable r)`
`<C extends java.util.Collection<U>> C`	`run(java.util.function.Supplier<C> collector)` Trigger a lazy stream and return the results in the Collection created by the collector
`Stage<U>`	`self(java.util.function.Consumer<Stage<U>> consumer)` Give a function access to the current stage of a SimpleReact Stream
`org.jooq.lambda.Seq<U>`	`sequential()`
`org.jooq.lambda.Seq<U>`	`skip(long n)`
`org.jooq.lambda.Seq<U>`	`sorted()`
`org.jooq.lambda.Seq<U>`	`sorted(java.util.Comparator<? super U> comparator)`
`java.util.Spliterator<U>`	`spliterator()`
`java.util.stream.Stream<U>`	`stream()`
`<T> java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>>`	`streamCompletableFutures()`
`<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.
`<R> Stage<R>`	`then(java.util.function.Function<U,R> fn)` React then Unlike 'with' this method is fluent, and returns another Stage Builder that can represent the next stage in the dataflow.
`java.lang.Object[]`	`toArray()`
`<A> A[]`	`toArray(java.util.function.IntFunction<A[]> generator)`
`Queue<U>`	`toQueue()` Convert the current Stream to a SimpleReact Queue
`Stage<U>`	`unordered()`
`<R> java.util.List<java.util.concurrent.CompletableFuture<R>>`	`with(java.util.function.Function<U,R> fn)` React with Asynchronously apply the function supplied to the currently active event tasks in the dataflow.

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

Methods inherited from interface org.jooq.lambda.Seq
cast, cast, concat, concat, concat, concat, cycle, cycle, duplicate, duplicate, empty, foldLeft, foldLeft, foldRight, foldRight, generate, generate, generate, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, intersperse, intersperse, iterate, join, join, join, join, join, join, limit, limitUntil, limitUntil, limitWhile, limitWhile, maxBy, maxBy, minBy, minBy, of, of, ofType, ofType, partition, partition, reverse, reverse, scanLeft, scanLeft, scanRight, scanRight, seq, seq, seq, seq, seq, shuffle, shuffle, shuffle, shuffle, skip, skipUntil, skipUntil, skipWhile, skipWhile, slice, slice, splitAt, splitAt, splitAtHead, splitAtHead, toCollection, toCollection, toList, toList, toMap, toMap, toMap, toSet, toSet, toString, toString, toString, unfold, unzip, unzip, unzip, unzip, zip, zip, zip, zip, zipWithIndex, zipWithIndex

Methods inherited from interface java.util.stream.Stream
builder, concat

- Method Detail
 - submitAndBlock
```
public <R> R submitAndBlock(java.util.function.Function<java.util.List,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)
 - with
```
public <R> java.util.List<java.util.concurrent.CompletableFuture<R>> with(java.util.function.Function<U,R> fn)
```
 React with Asynchronously apply the function supplied to the currently active event tasks in the dataflow. While most methods in this class are fluent, and return a reference to a SimpleReact Stage builder, this method can be used this method to access the underlying CompletableFutures. List<CompletableFuture<Integer>> futures = new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3) .with((it) -> it * 100); In this instance, 3 suppliers generate 3 numbers. These may be executed in parallel, when they complete each number will be multiplied by 100 - as a separate parrellel task (handled by a ForkJoinPool or configurable task executor). A List of Future objects will be returned immediately from Simple React and the tasks will be executed asynchronously. React with does not block.
 
 Parameters:
 
 fn - Function to be applied to the results of the currently active event tasks
 
 Returns:
 
 A list of CompletableFutures which will contain the result of the application of the supplied function
 - then
```
public <R> Stage<R> then(java.util.function.Function<U,R> fn)
```
 React then Unlike 'with' this method is fluent, and returns another Stage Builder that can represent the next stage in the dataflow. new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3) .then((it) -> it * 100) .then((it) -> "*" + it) React then allows event reactors to be chained. Unlike React with, which returns a collection of Future references, React then is a fluent interface that returns the React builder - allowing further reactors to be added to the chain. React then does not block. React with can be called after React then which gives access to the full CompleteableFuture api. CompleteableFutures can be passed back into SimpleReact via SimpleReact.react(streamOfCompleteableFutures); See this blog post for examples of what can be achieved via CompleteableFuture :- http://www.nurkiewicz.com/2013/12/promises-and-completablefuture.html
 
 Parameters:
 
 fn - Function to be applied to the results of the currently active event tasks
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - flatMap
```
public <R> Stage<R> flatMap(java.util.function.Function<? super U,? extends java.util.stream.Stream<? extends R>> flatFn)
```
 Specified by:
 
 flatMap in interface java.util.stream.Stream
 
 Specified by:
 
 flatMap in interface org.jooq.lambda.Seq
 - retry
```
public <R> Stage<R> retry(java.util.function.Function<U,R> fn)
```
 Will execute this phase on the RetryExecutor (default or user supplied). The RetryExecutor can be changed via withRetrier. This stage will be retried according to the configured rules. See https://github.com/nurkiewicz/async-retry for detailed advice on how to conifugre
 
 Parameters:
 
 fn - Function that will be executed and retried on failure
 
 Returns:
 
 Next Stage in the Strea,
 - peek
```
public Stage peek(java.util.function.Consumer<? super U> consumer)
```
 Peek asynchronously at the results in the current stage. Current results are passed through to the next stage.
 
 Specified by:
 
 peek in interface java.util.stream.Stream
 
 Specified by:
 
 peek in interface org.jooq.lambda.Seq
 
 Parameters:
 
 consumer - That will recieve current results
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - filter
```
public Stage filter(java.util.function.Predicate<? super U> p)
```
 Removes elements that do not match the supplied predicate from the dataflow
 
 Specified by:
 
 filter in interface java.util.stream.Stream
 
 Specified by:
 
 filter in interface org.jooq.lambda.Seq
 
 Parameters:
 
 p - Predicate that will be used to filter elements from the dataflow
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - streamCompletableFutures
```
public <T> java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> streamCompletableFutures()
```
 Returns:
 
 A Stream of CompletableFutures that represent this stage in the dataflow
 - merge
```
public Stage merge(Stage s)
```
 Merge this reactive dataflow with another of the same type. To merge flows of different types use the static method merge and merge to a common ancestor.
 
 Parameters:
 
 s - Reactive stage builder to merge with
 
 Returns:
 
 Merged dataflow
 - merge
```
public static <R> Stage<R> merge(Stage s1,
 Stage s2)
```
 Merge this reactive dataflow with another - recommended for merging different types. To merge flows of the same type the instance method merge is more appropriate.
 
 Parameters:
 
 s1 - Reactive stage builder to merge
 
 s2 - Reactive stage builder to merge
 
 Returns:
 
 Merged dataflow
 - onFail
```
public Stage onFail(java.util.function.Function<? extends java.lang.Throwable,U> fn)
```
 React onFail Define a function that can be used to recover from exceptions during the preceeding stage of the dataflow. e.g. onFail allows disaster recovery for each task (a separate onFail should be configured for each react phase that can fail). E.g. if reading data from an external service fails, but default value is acceptable - onFail is a suitable mechanism to set the default value. Asynchronously apply the function supplied to the currently active event tasks in the dataflow. List<String> strings = new SimpleReact().<Integer, Integer> react(() -> 100, () -> 2, () -> 3) .then(it -> { if (it == 100) throw new RuntimeException("boo!"); return it; }) .onFail(e -> 1) .then(it -> "*" + it) .block(); In this example onFail recovers from the RuntimeException thrown when the input to the first 'then' stage is 100.
 
 Parameters:
 
 fn - Recovery function, the exception is input, and the recovery value is output
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - capture
```
public Stage capture(java.util.function.Consumer<? extends java.lang.Throwable> errorHandler)
```
 React capture While onFail is used for disaster recovery (when it is possible to recover) - capture is used to capture those occasions where the full pipeline has failed and is unrecoverable. List<String> strings = new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3) .then(it -> it * 100) .then(it -> { if (it == 100) throw new RuntimeException("boo!"); return it; }) .onFail(e -> 1) .then(it -> "*" + it) .then(it -> { if ("*200".equals(it)) throw new RuntimeException("boo!"); return it; }) .capture(e -> logger.error(e.getMessage(),e)) .block(); In this case, strings will only contain the two successful results (for ()->1 and ()->3), an exception for the chain starting from Supplier ()->2 will be logged by capture. Capture will not capture the exception thrown when an Integer value of 100 is found, but will catch the exception when the String value "*200" is passed along the chain.
 
 Parameters:
 
 errorHandler - A consumer that recieves and deals with an unrecoverable error in the dataflow
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - collectResults
```
public ReactCollector 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
```
public java.util.List 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
```
public <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
 - first
```
public U first()
```
 Block until first result received
 
 Returns:
 
 first result. throws InterruptedException,ExecutionException
 - last
```
public U last()
```
 Block until all results received.
 
 Returns:
 
 last result throws InterruptedException,ExecutionException
 - blockAndExtract
```
public <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
```
public <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
```
public java.util.List 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
```
public <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
 - allOf
```
public <T,R> Stage<R> allOf(java.util.function.Function<java.util.List<T>,R> fn)
```
 React and allOf allOf is a non-blocking equivalent of block. The current thread is not impacted by the calculations, but the reactive chain does not continue until all currently alloted tasks complete. The allOf task is then provided with a list of the results from the previous tasks in the chain. boolean blocked[] = {false}; new SimpleReact().<Integer, Integer> react(() -> 1, () -> 2, () -> 3) .then(it -> { try { Thread.sleep(50000); } catch (Exception e) { } blocked[0] =true; return 10; }) .allOf( it -> it.size()); assertThat(blocked[0],is(false)); In this example, the current thread will continue and assert that it is not blocked, allOf could continue and be executed in a separate thread.
 
 Parameters:
 
 fn - Function that recieves the results of all currently active tasks as input
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - allOf
```
public <T,R> Stage<R> allOf(java.util.stream.Collector collector,
 java.util.function.Function<T,R> fn)
```
 Parameters:
 
 collector - to perform aggregation / reduction operation on the results from active stage (e.g. to Collect into a List or String)
 
 fn - Function that receives the results of all currently active tasks as input
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - run
```
public void run(java.util.concurrent.ExecutorService e)
```
 Trigger a lazy stream as a task on the provided ExecutorService
 
 Parameters:
 
 e - Executor service to trigger lazy stream on (Stream CompletableFutures will use ExecutorService associated with this Stage may not be the same one).
 - run
```
public void run(java.util.concurrent.ExecutorService e,
 java.lang.Runnable r)
```
 - run
```
public void run()
```
 Trigger a lazy stream
 - run
```
public <C extends java.util.Collection> C run(java.util.function.Supplier<C> collector)
```
 Trigger a lazy stream and return the results in the Collection created by the collector
 
 Parameters:
 
 collector - Supplier that creates a collection to store results in
 
 Returns:
 
 Collection of results
 - iterator
```
public java.util.Iterator iterator()
```
 Stream and Seq supporting methods
 
 Specified by:
 
 iterator in interface java.lang.Iterable
 
 Specified by:
 
 iterator in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 - spliterator
```
public java.util.Spliterator spliterator()
```
 Specified by:
 
 spliterator in interface java.lang.Iterable
 
 Specified by:
 
 spliterator in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 spliterator in interface org.jooq.lambda.Seq
 - isParallel
```
public boolean isParallel()
```
 Specified by:
 
 isParallel in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 - sequential
```
public org.jooq.lambda.Seq sequential()
```
 Specified by:
 
 sequential in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 sequential in interface org.jooq.lambda.Seq
 - parallel
```
public Stage parallel()
```
 Specified by:
 
 parallel in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 parallel in interface org.jooq.lambda.Seq
 - unordered
```
public Stage unordered()
```
 Specified by:
 
 unordered in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 unordered in interface org.jooq.lambda.Seq
 - onClose
```
public org.jooq.lambda.Seq onClose(java.lang.Runnable closeHandler)
```
 Specified by:
 
 onClose in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 onClose in interface org.jooq.lambda.Seq
 - close
```
public void close()
```
 Specified by:
 
 close in interface java.lang.AutoCloseable
 
 Specified by:
 
 close in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 close in interface org.jooq.lambda.Seq
 - map
```
public <R> Stage<R> map(java.util.function.Function<? super U,? extends R> mapper)
```
 Specified by:
 
 map in interface java.util.stream.Stream
 
 Specified by:
 
 map in interface org.jooq.lambda.Seq
 - mapToInt
```
public java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super U> mapper)
```
 Specified by:
 
 mapToInt in interface java.util.stream.Stream
 
 Specified by:
 
 mapToInt in interface org.jooq.lambda.Seq
 - mapToLong
```
public java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super U> mapper)
```
 Specified by:
 
 mapToLong in interface java.util.stream.Stream
 
 Specified by:
 
 mapToLong in interface org.jooq.lambda.Seq
 - mapToDouble
```
public java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super U> mapper)
```
 Specified by:
 
 mapToDouble in interface java.util.stream.Stream
 
 Specified by:
 
 mapToDouble in interface org.jooq.lambda.Seq
 - flatMapToInt
```
public java.util.stream.IntStream flatMapToInt(java.util.function.Function<? super U,? extends java.util.stream.IntStream> mapper)
```
 Specified by:
 
 flatMapToInt in interface java.util.stream.Stream
 
 Specified by:
 
 flatMapToInt in interface org.jooq.lambda.Seq
 - flatMapToLong
```
public java.util.stream.LongStream flatMapToLong(java.util.function.Function<? super U,? extends java.util.stream.LongStream> mapper)
```
 Specified by:
 
 flatMapToLong in interface java.util.stream.Stream
 
 Specified by:
 
 flatMapToLong in interface org.jooq.lambda.Seq
 - flatMapToDouble
```
public java.util.stream.DoubleStream flatMapToDouble(java.util.function.Function<? super U,? extends java.util.stream.DoubleStream> mapper)
```
 Specified by:
 
 flatMapToDouble in interface java.util.stream.Stream
 
 Specified by:
 
 flatMapToDouble in interface org.jooq.lambda.Seq
 - distinct
```
public org.jooq.lambda.Seq distinct()
```
 Specified by:
 
 distinct in interface java.util.stream.Stream
 
 Specified by:
 
 distinct in interface org.jooq.lambda.Seq
 - sorted
```
public org.jooq.lambda.Seq sorted()
```
 Specified by:
 
 sorted in interface java.util.stream.Stream
 
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 - sorted
```
public org.jooq.lambda.Seq sorted(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 sorted in interface java.util.stream.Stream
 
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 - self
```
public Stage self(java.util.function.Consumer<Stage> consumer)
```
 Give a function access to the current stage of a SimpleReact Stream
 
 Parameters:
 
 consumer - Consumer that will recieve current stage
 
 Returns:
 
 Self (current stage)
 - toQueue
```
public Queue toQueue()
```
 Convert the current Stream to a SimpleReact Queue
 
 Returns:
 
 Queue populated asynchrnously by this Stream
 - limit
```
public org.jooq.lambda.Seq limit(long maxSize)
```
 Specified by:
 
 limit in interface java.util.stream.Stream
 
 Specified by:
 
 limit in interface org.jooq.lambda.Seq
 - skip
```
public org.jooq.lambda.Seq skip(long n)
```
 Specified by:
 
 skip in interface java.util.stream.Stream
 
 Specified by:
 
 skip in interface org.jooq.lambda.Seq
 - forEach
```
public void forEach(java.util.function.Consumer<? super U> action)
```
 Specified by:
 
 forEach in interface java.lang.Iterable
 
 Specified by:
 
 forEach in interface java.util.stream.Stream
 
 Specified by:
 
 forEach in interface org.jooq.lambda.Seq
 - forEachOrdered
```
public void forEachOrdered(java.util.function.Consumer<? super U> action)
```
 Specified by:
 
 forEachOrdered in interface java.util.stream.Stream
 - toArray
```
public java.lang.Object[] toArray()
```
 Specified by:
 
 toArray in interface java.util.stream.Stream
 - toArray
```
public <A> A[] toArray(java.util.function.IntFunction<A[]> generator)
```
 Specified by:
 
 toArray in interface java.util.stream.Stream
 - reduce
```
public U reduce(U identity,
 java.util.function.BinaryOperator accumulator)
```
 Specified by:
 
 reduce in interface java.util.stream.Stream
 - reduce
```
public java.util.Optional reduce(java.util.function.BinaryOperator accumulator)
```
 Specified by:
 
 reduce in interface java.util.stream.Stream
 - collect
```
public <R> R collect(java.util.function.Supplier<R> supplier,
 java.util.function.BiConsumer<R,? super U> accumulator,
 java.util.function.BiConsumer<R,R> combiner)
```
 Specified by:
 
 collect in interface java.util.stream.Stream
 - collect
```
public <R,A> R collect(java.util.stream.Collector<? super U,A,R> collector)
```
 Specified by:
 
 collect in interface java.util.stream.Stream
 - min
```
public java.util.Optional min(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 min in interface java.util.stream.Stream
 - max
```
public java.util.Optional max(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 max in interface java.util.stream.Stream
 - count
```
public long count()
```
 Specified by:
 
 count in interface java.util.stream.Stream
 - anyMatch
```
public boolean anyMatch(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 anyMatch in interface java.util.stream.Stream
 - allMatch
```
public boolean allMatch(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 allMatch in interface java.util.stream.Stream
 - noneMatch
```
public boolean noneMatch(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 noneMatch in interface java.util.stream.Stream
 - findFirst
```
public java.util.Optional findFirst()
```
 Specified by:
 
 findFirst in interface java.util.stream.Stream
 - findAny
```
public java.util.Optional findAny()
```
 Specified by:
 
 findAny in interface java.util.stream.Stream
 - reduce
```
public <R> R reduce(R identity,
 java.util.function.BiFunction<R,? super U,R> accumulator,
 java.util.function.BinaryOperator<R> combiner)
```
 Specified by:
 
 reduce in interface java.util.stream.Stream
 - stream
```
public java.util.stream.Stream stream()
```
 Specified by:
 
 stream in interface org.jooq.lambda.Seq

Class Stage<U>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.stream.Stream

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.jooq.lambda.Seq

Methods inherited from interface java.util.stream.Stream

Method Detail

submitAndBlock

with

then

flatMap

retry

peek

filter

streamCompletableFutures

merge

merge

onFail

capture

collectResults

block

block

first

last

blockAndExtract

blockAndExtract

block

block

allOf

allOf

run

run

run

run

iterator

spliterator

isParallel

sequential

parallel

unordered

onClose

close

map

mapToInt

mapToLong

mapToDouble

flatMapToInt

flatMapToLong

flatMapToDouble

distinct

sorted

sorted

self

toQueue

limit

skip

forEach

forEachOrdered

toArray

toArray

reduce

reduce

collect

collect

min

max

count

anyMatch

allMatch

noneMatch

findFirst

findAny

reduce

stream