FutureStream (simple-react 0.99.2 API)

All Superinterfaces:

java.lang.AutoCloseable, java.util.stream.BaseStream<U,java.util.stream.Stream>, BlockingStream, java.lang.Iterable, org.jooq.lambda.Seq, SimpleReactStream, java.util.stream.Stream, ToQueue

All Known Subinterfaces:

EagerFutureStream, LazyFutureStream

All Known Implementing Classes:

EagerFutureStreamImpl, LazyFutureStreamImpl
```
public interface FutureStream
extends org.jooq.lambda.Seq, SimpleReactStream, ToQueue
```

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

Field Summary

Fields
Modifier and Type Field and Description

static ExceptionSoftener softener

Fields
Modifier and Type	Field and Description
`static ExceptionSoftener`	`softener`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default boolean`	`allMatch(java.util.function.Predicate<? super U> predicate)`
`default boolean`	`anyMatch(java.util.function.Predicate<? super U> predicate)`
`FutureStream<U>`	`async()`
`default <C extends java.util.Collection<U>> FutureStream<C>`	`batch(java.util.function.Function<java.util.function.Supplier<U>,java.util.function.Supplier<C>> fn)` Batch elements into a Stream of collections with user defined function
`default FutureStream<java.util.List<U>>`	`batchBySize(int size)` Batch the elements in this stream into Lists of specified size
`default <C extends java.util.Collection<U>> FutureStream<C>`	`batchBySize(int size, java.util.function.Supplier<C> supplier)` Batch the elements in this stream into Collections of specified size The type of Collection is determined by the specified supplier
`default FutureStream<java.util.List<U>>`	`batchBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit)` Batch the elements in the Stream by a combination of Size and Time If batch exceeds max size it will be split If batch exceeds max time it will be split Excludes Null values (neccessary for timeout handling)
`default <C extends java.util.Collection<U>> FutureStream<C>`	`batchBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory)` Batch the elements in the Stream by a combination of Size and Time If batch exceeds max size it will be split If batch exceeds max time it will be split Excludes Null values (neccessary for timeout handling)
`default FutureStream<java.util.Collection<U>>`	`batchByTime(long time, java.util.concurrent.TimeUnit unit)` Organise elements in a Stream into a Collections based on the time period they pass through this stage Excludes Null values (neccessary for timeout handling)
`default FutureStream<java.util.Collection<U>>`	`batchByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<java.util.Collection<U>> factory)` Organise elements in a Stream into a Collections based on the time period they pass through this stage
`default void`	`cancel()` Cancel the CompletableFutures in this stage of the stream
`FutureStream<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.
`default <U> FutureStream<U>`	`cast(java.lang.Class<U> type)`
`static <T,U> FutureStream<U>`	`cast(FutureStream<T> stream, java.lang.Class<U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default java.util.Iterator<java.util.Collection<U>>`	`chunkLastReadIterator()`
`default FutureStream<java.util.Collection<U>>`	`chunkSinceLastRead()`
`void`	`close()`
`default <R> R`	`collect(java.util.function.Supplier<R> supplier, java.util.function.BiConsumer<R,? super U> accumulator, java.util.function.BiConsumer<R,R> combiner)`
`default FutureStream<U>`	`control(java.util.function.Function<java.util.function.Supplier<U>,java.util.function.Supplier<U>> fn)` Allows clients to control the emission of data for the next phase of the Stream.
`default long`	`count()`
`default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`crossJoin(java.util.stream.Stream<T> other)`
`default FutureStream<U>`	`debounce(long time, java.util.concurrent.TimeUnit unit)` Can be used to debounce (accept a single data point from a unit of time) data.
`FutureStream<U>`	`filter(java.util.function.Predicate<? super U> p)` Removes elements that do not match the supplied predicate from the dataflow
`default java.util.Optional<U>`	`findAny()`
`default java.util.Optional<U>`	`findFirst()`
`default U`	`firstValue()` `int first = LazyFutureStream.of(1,2,3,4) .firstValue(); //first is 1`
`default FutureStream<U>`	`fixedDelay(long time, java.util.concurrent.TimeUnit unit)` Apply a fixed delay before emitting elements to the next phase of the Stream.
`<R> FutureStream<R>`	`flatMap(java.util.function.Function<? super U,? extends java.util.stream.Stream<? extends R>> flatFn)` Allows aggregate values in a Stream to be flatten into a single Stream.
`default java.util.stream.DoubleStream`	`flatMapToDouble(java.util.function.Function<? super U,? extends java.util.stream.DoubleStream> mapper)`
`default java.util.stream.IntStream`	`flatMapToInt(java.util.function.Function<? super U,? extends java.util.stream.IntStream> mapper)`
`default java.util.stream.LongStream`	`flatMapToLong(java.util.function.Function<? super U,? extends java.util.stream.LongStream> mapper)`
`default void`	`forEach(java.util.function.Consumer<? super U> action)` Stream supporting methods
`default void`	`forEachOrdered(java.util.function.Consumer<? super U> action)`
`<R> FutureStream<R>`	`fromStream(java.util.stream.Stream<R> stream)`
`default FutureOps<U>`	`futureOperations()`
`default FutureOps<U>`	`futureOperations(java.util.concurrent.Executor executor)`
`StreamWrapper`	`getLastActive()`
`Continueable`	`getSubscription()`
`java.util.concurrent.Executor`	`getTaskExecutor()`
`default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`innerJoin(java.util.stream.Stream<T> other, java.util.function.BiPredicate<U,T> predicate)`
`static <T> FutureStream<T>`	`intersperse(FutureStream<T> stream, T value)` Returns a stream with a given value interspersed between any two values of this stream.
`default FutureStream<U>`	`intersperse(U value)` Returns a stream with a given value interspersed between any two values of this stream.
`boolean`	`isAsync()`
`default boolean`	`isParallel()`
`default CloseableIterator<U>`	`iterator()`
`default FutureStream<U>`	`jitter(long jitterInNanos)` Introduce a random delay between events in a stream Can be used to prevent behaviour synchronizing within a system
`default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`leftOuterJoin(java.util.stream.Stream<T> other, java.util.function.BiPredicate<U,T> predicate)`
`static <T,R> java.util.function.Function<FutureStream<T>,FutureStream<R>>`	`lift(java.util.function.Function<T,R> fn)`
`static <T1,T2,R> java.util.function.BiFunction<FutureStream<T1>,FutureStream<T2>,FutureStream<R>>`	`lift2(java.util.function.BiFunction<T1,T2,R> fn)`
`default <R> FutureStream<R>`	`map(java.util.function.Function<? super U,? extends R> mapper)`
`default java.util.stream.DoubleStream`	`mapToDouble(java.util.function.ToDoubleFunction<? super U> mapper)`
`default java.util.stream.IntStream`	`mapToInt(java.util.function.ToIntFunction<? super U> mapper)`
`default java.util.stream.LongStream`	`mapToLong(java.util.function.ToLongFunction<? super U> mapper)`
`default java.util.Optional<U>`	`max(java.util.Comparator<? super U> comparator)`
`default java.util.Optional<U>`	`min(java.util.Comparator<? super U> comparator)`
`default boolean`	`noneMatch(java.util.function.Predicate<? super U> predicate)`
`default <U> FutureStream<U>`	`ofType(java.lang.Class<U> type)`
`static <T,U> FutureStream<U>`	`ofType(FutureStream<T> stream, java.lang.Class<U> type)` Keep only those elements in a stream that are of a given type.
`org.jooq.lambda.Seq<U>`	`onClose(java.lang.Runnable closeHandler)`
`default FutureStream<U>`	`onEmpty(U value)` Produce this stream, or an alternative stream from the `value`, in case this stream is empty.
`default FutureStream<U>`	`onEmptyGet(java.util.function.Supplier<U> supplier)` Produce this stream, or an alternative stream from the `supplier`, in case this stream is empty.
`default <X extends java.lang.Throwable> FutureStream<U>`	`onEmptyThrow(java.util.function.Supplier<X> supplier)` Produce this stream, or an alternative stream from the `supplier`, in case this stream is empty.
`default FutureStream<U>`	`onePer(long time, java.util.concurrent.TimeUnit unit)` Slow emissions down, emiting one element per specified time period
`FutureStream<U>`	`onFail(java.util.function.Function<SimpleReactFailedStageException,U> fn)` React onFail Define a function that can be used to recover from exceptions during the preceeding stage of the dataflow.
`FutureStream<U>`	`peek(java.util.function.Consumer<? super U> consumer)` Peek asynchronously at the results in the current stage.
`default java.util.Optional<U>`	`reduce(java.util.function.BinaryOperator<U> accumulator)`
`default <R> R`	`reduce(R identity, java.util.function.BiFunction<R,? super U,R> accumulator, java.util.function.BinaryOperator<R> combiner)`
`default U`	`reduce(U identity, java.util.function.BinaryOperator<U> accumulator)`
`default FutureStream<U>`	`reverse()`
`default java.util.Iterator<U>`	`reversedIterator()`
`default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>>`	`rightOuterJoin(java.util.stream.Stream<T> other, java.util.function.BiPredicate<U,T> predicate)`
`default FutureStream<U>`	`self(java.util.function.Consumer<FutureStream<U>> consumer)` Give a function access to the current stage of a SimpleReact Stream
`org.jooq.lambda.Seq<U>`	`sequential()`
`default <K> java.util.Map<K,? extends FutureStream<U>>`	`shard(java.util.Map<K,Queue<U>> shards, java.util.function.Function<U,K> sharder)` Break a stream into multiple Streams based of some characteristic of the elements of the Stream e.g.
`default U`	`single()` `int num = LazyFutureStream.of(1).single(); //num is 1`
`static <T> org.jooq.lambda.Seq<T>`	`slice(FutureStream<T> stream, long from, long to)` Returns a limited interval from a given Stream.
`default org.jooq.lambda.Seq<U>`	`slice(long from, long to)` Returns a limited interval from a given Stream.
`default FutureStream<java.util.List<U>>`	`sliding(int size)` Create a sliding view over this Stream
`default FutureStream<java.util.List<U>>`	`sliding(int size, int increment)` Create a sliding view over this Stream
`default org.jooq.lambda.Seq<U>`	`sorted()`
`default org.jooq.lambda.Seq<U>`	`sorted(java.util.Comparator<? super U> comparator)`
`default java.util.Spliterator<U>`	`spliterator()`
`default java.util.stream.Stream<U>`	`stream()`
`FutureStream<U>`	`sync()`
`default java.lang.Object[]`	`toArray()`
`default <A> A[]`	`toArray(java.util.function.IntFunction<A[]> generator)`
`default java.util.Collection<U>`	`toConcurrentLazyCollection()` Create a LazyCollection access to which is synchronized
`default java.util.Collection<U>`	`toLazyCollection()` `Collection<Integer> col = LazyFutureStream.of(1,2,3,4,5,6) .map(i->i+2) .toLazyCollection();`
`default FutureStream<U>`	`unordered()`
`FutureStream<U>`	`withQueueFactory(QueueFactory<U> qf)`
`default FutureStream<U>`	`xPer(int x, long time, java.util.concurrent.TimeUnit unit)` Allows x (specified number of) emissions with a time period before stopping emmissions until specified time has elapsed since last emission
`<R> FutureStream<org.jooq.lambda.tuple.Tuple2<U,R>>`	`zipFutures(FutureStream<R> other)` Zip two Streams, zipping against the underlying futures of both Streams Placeholders (Futures) will be populated immediately in the new zipped Stream and results will be populated asyncrhonously
`<R> FutureStream<org.jooq.lambda.tuple.Tuple2<U,R>>`	`zipFutures(java.util.stream.Stream<R> other)` Zip two Streams, zipping against the underlying futures of this stream

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

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

Methods inherited from interface com.aol.simple.react.stream.traits.SimpleReactStream
convertToEagerStream, doOnEach, doOnEachSync, empty, filterSync, flatMapCompletableFuture, flatMapCompletableFutureSync, getQueueFactory, getSimpleReact, of, of, ofThread, ofThread, onFail, parallel, peekSync, react, react, retry, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStream, simpleReactStreamFrom, simpleReactStreamFromIterable, streamCompletableFutures, then, then, thenSync, toQueue, withRetrier, withSubscription

Methods inherited from interface com.aol.simple.react.stream.traits.BlockingStream
block, block, blockAndExtract, blockAndExtract, first, getErrorHandler, last

Methods inherited from interface com.aol.simple.react.stream.traits.ToQueue
addToQueue, getQueueFactory, toQueue, toQueue, toQueue

- Field Detail
 - softener
```
static final ExceptionSoftener softener
```
- Method Detail
 - lift
```
static <T,R> java.util.function.Function<FutureStream<T>,FutureStream<R>> lift(java.util.function.Function<T,R> fn)
```
 - lift2
```
static <T1,T2,R> java.util.function.BiFunction<FutureStream<T1>,FutureStream<T2>,FutureStream<R>> lift2(java.util.function.BiFunction<T1,T2,R> fn)
```
 - iterator
```
default CloseableIterator iterator()
```
 Specified by:
 
 iterator in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 iterator in interface java.lang.Iterable
 
 Specified by:
 
 iterator in interface SimpleReactStream
 - sync
```
FutureStream sync()
```
 Specified by:
 
 sync in interface SimpleReactStream
 - async
```
FutureStream async()
```
 Specified by:
 
 async in interface SimpleReactStream
 - isAsync
```
boolean isAsync()
```
 Specified by:
 
 isAsync in interface SimpleReactStream
 - toLazyCollection
```
default java.util.Collection toLazyCollection()
```
```
 
 Collection<Integer> col = LazyFutureStream.of(1,2,3,4,5,6)
				.map(i->i+2)
				.toLazyCollection();
 
 
```
 Returns:
 
 a LazyCollection from this Stream Collection will not be populated until methods are accessed. (Eager streams may populate a LazyColleciton in the background however)
 - toConcurrentLazyCollection
```
default java.util.Collection toConcurrentLazyCollection()
```
 Create a LazyCollection access to which is synchronized
```
 
 Collection<Integer> col = LazyFutureStream.of(1,2,3,4,5,6)
				.map(i->i+2)
				.toConcurrentLazyCollection();
 
 
```
 Returns:
 
 a LazyCollection from this Stream Collection will not be populated until methods are accessed. (Eager streams may populate a LazyColleciton in the background however)
 - single
```
default U single()
```
```
 
 	 int num =	LazyFutureStream.of(1).single();
 
 //num is 1
 
 
```
 Returns:
 
 single element from this Stream if it is a single element Stream otherwise throw an UnsupportedOperationException
 - zipFutures
```
<R> FutureStream<org.jooq.lambda.tuple.Tuple2<U,R>> zipFutures(java.util.stream.Stream<R> other)
```
 Zip two Streams, zipping against the underlying futures of this stream
 
 Parameters:
 
 other -
 
 Returns:
 - crossJoin
```
default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> crossJoin(java.util.stream.Stream<T> other)
```
 Specified by:
 
 crossJoin in interface org.jooq.lambda.Seq
 - onEmpty
```
default FutureStream onEmpty(U value)
```
 Produce this stream, or an alternative stream from the value, in case this stream is empty.
 
 Specified by:
 
 onEmpty in interface org.jooq.lambda.Seq
 - onEmptyGet
```
default FutureStream onEmptyGet(java.util.function.Supplier supplier)
```
 Produce this stream, or an alternative stream from the supplier, in case this stream is empty.
 
 Specified by:
 
 onEmptyGet in interface org.jooq.lambda.Seq
 - onEmptyThrow
```
default <X extends java.lang.Throwable> FutureStream onEmptyThrow(java.util.function.Supplier<X> supplier)
```
 Produce this stream, or an alternative stream from the supplier, in case this stream is empty.
 
 Specified by:
 
 onEmptyThrow in interface org.jooq.lambda.Seq
 - innerJoin
```
default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> innerJoin(java.util.stream.Stream<T> other,
 java.util.function.BiPredicate<U,T> predicate)
```
 Specified by:
 
 innerJoin in interface org.jooq.lambda.Seq
 - leftOuterJoin
```
default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> leftOuterJoin(java.util.stream.Stream<T> other,
 java.util.function.BiPredicate<U,T> predicate)
```
 Specified by:
 
 leftOuterJoin in interface org.jooq.lambda.Seq
 - rightOuterJoin
```
default <T> FutureStream<org.jooq.lambda.tuple.Tuple2<U,T>> rightOuterJoin(java.util.stream.Stream<T> other,
 java.util.function.BiPredicate<U,T> predicate)
```
 Specified by:
 
 rightOuterJoin in interface org.jooq.lambda.Seq
 - zipFutures
```
<R> FutureStream<org.jooq.lambda.tuple.Tuple2<U,R>> zipFutures(FutureStream<R> other)
```
 Zip two Streams, zipping against the underlying futures of both Streams Placeholders (Futures) will be populated immediately in the new zipped Stream and results will be populated asyncrhonously
 
 Parameters:
 
 other - Another FutureStream to zip Futures with
 
 Returns:
 
 New Sequence of CompletableFutures
 - chunkLastReadIterator
```
default java.util.Iterator<java.util.Collection> chunkLastReadIterator()
```
 Returns:
 
 an Iterator that chunks all completed elements from this stream since last it.next() call into a collection
 - chunkSinceLastRead
```
default FutureStream<java.util.Collection> chunkSinceLastRead()
```
 Returns:
 
 a Stream that batches all completed elements from this stream since last read attempt into a collection
 - withQueueFactory
```
FutureStream withQueueFactory(QueueFactory qf)
```
 Specified by:
 
 withQueueFactory in interface SimpleReactStream
 - shard
```
default <K> java.util.Map<K,? extends FutureStream> shard(java.util.Map<K,Queue> shards,
 java.util.function.Function<U,K> sharder)
```
 Break a stream into multiple Streams based of some characteristic of the elements of the Stream e.g. EagerFutureStream.of(10,20,25,30,41,43).shard(ImmutableMap.of("even",new Queue(),"odd",new Queue(),element-> element%2==0? "even" : "odd"); results in 2 Streams "even": 10,20,30 "odd" : 25,41,43
 
 Parameters:
 
 shards - Map of Queue's keyed by shard identifier
 
 sharder - Function to split split incoming elements into shards
 
 Returns:
 
 Map of new sharded Streams
 - cancel
```
default void cancel()
```
 Cancel the CompletableFutures in this stage of the stream
 - batchBySizeAndTime
```
default FutureStream<java.util.List> batchBySizeAndTime(int size,
 long time,
 java.util.concurrent.TimeUnit unit)
```
 Batch the elements in the Stream by a combination of Size and Time If batch exceeds max size it will be split If batch exceeds max time it will be split Excludes Null values (neccessary for timeout handling)
 
 Returns:
 - batchBySizeAndTime
```
default <C extends java.util.Collection> FutureStream<C> batchBySizeAndTime(int size,
 long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<C> factory)
```
 Batch the elements in the Stream by a combination of Size and Time If batch exceeds max size it will be split If batch exceeds max time it will be split Excludes Null values (neccessary for timeout handling)
 
 Returns:
 - batchBySize
```
default FutureStream<java.util.List> batchBySize(int size)
```
 Batch the elements in this stream into Lists of specified size
 
 Parameters:
 
 size - Size of lists elements should be batched into
 
 Returns:
 
 Stream of Lists
 - batch
```
default <C extends java.util.Collection> FutureStream<C> batch(java.util.function.Function<java.util.function.Supplier,java.util.function.Supplier<C>> fn)
```
 Batch elements into a Stream of collections with user defined function
 
 Parameters:
 
 fn - Function takes a supplier, which can be used repeatedly to get the next value from the Stream. If there are no more values, a ClosedQueueException will be thrown. This function should return a Supplier which creates a collection of the batched values
 
 Returns:
 
 Stream of batched values
 - batchBySize
```
default <C extends java.util.Collection> FutureStream<C> batchBySize(int size,
 java.util.function.Supplier<C> supplier)
```
 Batch the elements in this stream into Collections of specified size The type of Collection is determined by the specified supplier
 
 Parameters:
 
 size - Size of batch
 
 supplier - Create the batch holding collection
 
 Returns:
 
 Stream of Collections
 - jitter
```
default FutureStream jitter(long jitterInNanos)
```
 Introduce a random delay between events in a stream Can be used to prevent behaviour synchronizing within a system
 
 Parameters:
 
 jitterInNanos - Max number of nanos for jitter (random number less than this will be selected)/
 
 Returns:
 
 Next stage in Stream with jitter applied
 - fixedDelay
```
default FutureStream fixedDelay(long time,
 java.util.concurrent.TimeUnit unit)
```
 Apply a fixed delay before emitting elements to the next phase of the Stream. Note this doesn't neccessarily imply a fixed delay between element creation (although it may do). e.g. EagerFutureStream.of(1,2,3,4).fixedDelay(1,TimeUnit.hours); Will emit 1 on start, then 2 after an hour, 3 after 2 hours and so on. However all 4 numbers will be populated in the Stream immediately. LazyFutureStream.of(1,2,3,4).withQueueFactories(QueueFactories.boundedQueue(1)).fixedDelay(1,TimeUnit.hours); Will populate each number in the Stream an hour apart.
 
 Parameters:
 
 time - amount of time between emissions
 
 unit - TimeUnit for emissions
 
 Returns:
 
 Next Stage of the Stream
 - control
```
default FutureStream control(java.util.function.Function<java.util.function.Supplier,java.util.function.Supplier> fn)
```
 Allows clients to control the emission of data for the next phase of the Stream. The user specified function can delay, drop, or change elements
 
 Parameters:
 
 fn - Function takes a supplier, which can be used repeatedly to get the next value from the Stream. If there are no more values, a ClosedQueueException will be thrown. This function should return a Supplier which returns the desired result for the next element (or just the next element).
 
 Returns:
 
 Next stage in Stream
 - debounce
```
default FutureStream debounce(long time,
 java.util.concurrent.TimeUnit unit)
```
 Can be used to debounce (accept a single data point from a unit of time) data. This drops data. For a method that slows emissions and keeps data #see#onePer
 
 Parameters:
 
 time - Time from which to accept only one element
 
 unit - Time unit for specified time
 
 Returns:
 
 Next stage of stream, with only 1 element per specified time windows
 - onePer
```
default FutureStream onePer(long time,
 java.util.concurrent.TimeUnit unit)
```
 Slow emissions down, emiting one element per specified time period
 
 Parameters:
 
 time - Frequency period of element emission
 
 unit - Time unit for frequency period
 
 Returns:
 
 Stream with emissions slowed down by specified emission frequency
 - xPer
```
default FutureStream xPer(int x,
 long time,
 java.util.concurrent.TimeUnit unit)
```
 Allows x (specified number of) emissions with a time period before stopping emmissions until specified time has elapsed since last emission
 
 Parameters:
 
 x - Number of allowable emissions per time period
 
 time - Frequency time period
 
 unit - Frequency time unit
 
 Returns:
 
 Stream with emissions slowed down by specified emission frequency
 - batchByTime
```
default FutureStream<java.util.Collection> batchByTime(long time,
 java.util.concurrent.TimeUnit unit)
```
 Organise elements in a Stream into a Collections based on the time period they pass through this stage Excludes Null values (neccessary for timeout handling)
 
 Parameters:
 
 time - Time period during which all elements should be collected
 
 unit - Time unit during which all elements should be collected
 
 Returns:
 
 Stream of Lists
 - batchByTime
```
default FutureStream<java.util.Collection> batchByTime(long time,
 java.util.concurrent.TimeUnit unit,
 java.util.function.Supplier<java.util.Collection> factory)
```
 Organise elements in a Stream into a Collections based on the time period they pass through this stage
 
 Parameters:
 
 time - Time period during which all elements should be collected
 
 unit - Time unit during which all elements should be collected
 
 factory - Instantiates the collections used in the batching
 
 Returns:
 
 Stream of collections
 - onFail
```
FutureStream onFail(java.util.function.Function<SimpleReactFailedStageException,U> fn)
```
 Description copied from interface: SimpleReactStream
 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.
 Specified by:
 
 onFail in interface SimpleReactStream
 
 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
 - fromStream
```
<R> FutureStream<R> fromStream(java.util.stream.Stream<R> stream)
```
 Specified by:
 
 fromStream in interface SimpleReactStream
 - flatMap
```
<R> FutureStream<R> flatMap(java.util.function.Function<? super U,? extends java.util.stream.Stream<? extends R>> flatFn)
```
 Description copied from interface: SimpleReactStream
 
 Allows aggregate values in a Stream to be flatten into a single Stream. flatMap functions turn each aggregate value into it's own Stream, and SimpleReact aggregates those Streams into a single flattened stream
 
 Specified by:
 
 flatMap in interface org.jooq.lambda.Seq
 
 Specified by:
 
 flatMap in interface SimpleReactStream
 
 Specified by:
 
 flatMap in interface java.util.stream.Stream
 
 Parameters:
 
 flatFn - Function that coverts a value (e.g. a Collection) into a Stream
 
 Returns:
 
 SimpleReactStream
 - filter
```
FutureStream filter(java.util.function.Predicate<? super U> p)
```
 Description copied from interface: SimpleReactStream
 
 Removes elements that do not match the supplied predicate from the dataflow
 
 Specified by:
 
 filter in interface org.jooq.lambda.Seq
 
 Specified by:
 
 filter in interface SimpleReactStream
 
 Specified by:
 
 filter in interface java.util.stream.Stream
 
 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
 - peek
```
FutureStream peek(java.util.function.Consumer<? super U> consumer)
```
 Description copied from interface: SimpleReactStream
 
 Peek asynchronously at the results in the current stage. Current results are passed through to the next stage.
 
 Specified by:
 
 peek in interface org.jooq.lambda.Seq
 
 Specified by:
 
 peek in interface SimpleReactStream
 
 Specified by:
 
 peek in interface java.util.stream.Stream
 
 Parameters:
 
 consumer - That will recieve current results
 
 Returns:
 
 A new builder object that can be used to define the next stage in the dataflow
 - capture
```
FutureStream capture(java.util.function.Consumer<? extends java.lang.Throwable> errorHandler)
```
 Description copied from interface: SimpleReactStream
 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.
 Specified by:
 
 capture in interface SimpleReactStream
 
 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
 - forEach
```
default void forEach(java.util.function.Consumer<? super U> action)
```
 Stream supporting methods
 
 Specified by:
 
 forEach in interface java.lang.Iterable
 
 Specified by:
 
 forEach in interface org.jooq.lambda.Seq
 
 Specified by:
 
 forEach in interface java.util.stream.Stream
 - forEachOrdered
```
default void forEachOrdered(java.util.function.Consumer<? super U> action)
```
 Specified by:
 
 forEachOrdered in interface java.util.stream.Stream
 - toArray
```
default java.lang.Object[] toArray()
```
 Specified by:
 
 toArray in interface java.util.stream.Stream
 - sliding
```
default FutureStream<java.util.List> sliding(int size)
```
 Create a sliding view over this Stream
```
 
 //futureStream of [1,2,3,4,5,6]
		 
 List<List<Integer>> list = futureStream.sliding(2)
									.collect(Collectors.toList());
		
	
		assertThat(list.get(0),hasItems(1,2));
		assertThat(list.get(1),hasItems(2,3));
 
 
```
 Parameters:
 
 size - Size of sliding window
 
 Returns:
 
 Stream with sliding view over data in this stream
 - sliding
```
default FutureStream<java.util.List> sliding(int size,
 int increment)
```
 Create a sliding view over this Stream
```
 
 //futureStream of [1,2,3,4,5,6,7,8]
		 
 List<List<Integer>> list = futureStream.sliding(3,2)
									.collect(Collectors.toList());
		
	
		assertThat(list.get(0),hasItems(1,2,3));
		assertThat(list.get(1),hasItems(3,4,5));
 
 
```
 Parameters:
 
 size - Size of sliding window
 
 Returns:
 
 Stream with sliding view over data in this stream
 - futureOperations
```
default FutureOps futureOperations()
```
 Returns:
 
 An extensive set of asyncrhonous terminal operations
 - futureOperations
```
default FutureOps futureOperations(java.util.concurrent.Executor executor)
```
 Parameters:
 
 executor - to execute terminal ops asynchronously on
 
 Returns:
 
 An extensive set of asyncrhonous terminal operations
 - toArray
```
default <A> A[] toArray(java.util.function.IntFunction<A[]> generator)
```
 Specified by:
 
 toArray in interface java.util.stream.Stream
 - reduce
```
default U reduce(U identity,
 java.util.function.BinaryOperator accumulator)
```
 Specified by:
 
 reduce in interface java.util.stream.Stream
 - reduce
```
default java.util.Optional reduce(java.util.function.BinaryOperator accumulator)
```
 Specified by:
 
 reduce in interface java.util.stream.Stream
 - collect
```
default <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
 - min
```
default java.util.Optional min(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 min in interface java.util.stream.Stream
 - max
```
default java.util.Optional max(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 max in interface java.util.stream.Stream
 - count
```
default long count()
```
 Specified by:
 
 count in interface org.jooq.lambda.Seq
 
 Specified by:
 
 count in interface java.util.stream.Stream
 - anyMatch
```
default boolean anyMatch(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 anyMatch in interface java.util.stream.Stream
 - allMatch
```
default boolean allMatch(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 allMatch in interface java.util.stream.Stream
 - noneMatch
```
default boolean noneMatch(java.util.function.Predicate<? super U> predicate)
```
 Specified by:
 
 noneMatch in interface java.util.stream.Stream
 - findFirst
```
default java.util.Optional findFirst()
```
 Specified by:
 
 findFirst in interface java.util.stream.Stream
 - firstValue
```
default U firstValue()
```
```
 
 	int first = LazyFutureStream.of(1,2,3,4)
 					.firstValue();
 
 //first is 1
 
 
```
 Returns:
 
 the firstValue in this stream - same as findFirst but doesn't return an Optional. Will throw an exception if empty
 - findAny
```
default java.util.Optional findAny()
```
 Specified by:
 
 findAny in interface java.util.stream.Stream
 - reduce
```
default <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
 - reverse
```
default FutureStream reverse()
```
 Specified by:
 
 reverse in interface org.jooq.lambda.Seq
 - reversedIterator
```
default java.util.Iterator reversedIterator()
```
 - spliterator
```
default java.util.Spliterator spliterator()
```
 Specified by:
 
 spliterator in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 
 Specified by:
 
 spliterator in interface java.lang.Iterable
 
 Specified by:
 
 spliterator in interface org.jooq.lambda.Seq
 - isParallel
```
default boolean isParallel()
```
 Specified by:
 
 isParallel in interface java.util.stream.BaseStream<U,java.util.stream.Stream>
 - sequential
```
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
 - stream
```
default java.util.stream.Stream stream()
```
 Specified by:
 
 stream in interface org.jooq.lambda.Seq
 - intersperse
```
default FutureStream intersperse(U value)
```
 Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) LazyFutureStream.of(1, 2, 3, 4).intersperse(0)
 
 Specified by:
 
 intersperse in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.intersperse(Stream, Object)
 - cast
```
default  FutureStream cast(java.lang.Class type)
```
 Specified by:
 
 cast in interface org.jooq.lambda.Seq
 - ofType
```
default  FutureStream ofType(java.lang.Class type)
```
 Specified by:
 
 ofType in interface org.jooq.lambda.Seq
 - ofType
```
static <T,U> FutureStream ofType(FutureStream<T> stream,
 java.lang.Class type)
```
 Keep only those elements in a stream that are of a given type. // (1, 2, 3) EagerFutureStream.of(1, "a", 2, "b", 3).ofType(Integer.class)
 - cast
```
static <T,U> FutureStream cast(FutureStream<T> stream,
 java.lang.Class type)
```
 Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException LazyFutureStream.of(1, "a", 2, "b", 3).cast(Integer.class)
 - intersperse
```
static <T> FutureStream<T> intersperse(FutureStream<T> stream,
 T value)
```
 Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) Seq.of(1, 2, 3, 4).intersperse(0)
 - unordered
```
default FutureStream 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
```
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
```
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
```
default <R> FutureStream<R> map(java.util.function.Function<? super U,? extends R> mapper)
```
 Specified by:
 
 map in interface org.jooq.lambda.Seq
 
 Specified by:
 
 map in interface java.util.stream.Stream
 - mapToInt
```
default java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super U> mapper)
```
 Specified by:
 
 mapToInt in interface org.jooq.lambda.Seq
 
 Specified by:
 
 mapToInt in interface java.util.stream.Stream
 - mapToLong
```
default java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super U> mapper)
```
 Specified by:
 
 mapToLong in interface org.jooq.lambda.Seq
 
 Specified by:
 
 mapToLong in interface java.util.stream.Stream
 - mapToDouble
```
default java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super U> mapper)
```
 Specified by:
 
 mapToDouble in interface org.jooq.lambda.Seq
 
 Specified by:
 
 mapToDouble in interface java.util.stream.Stream
 - flatMapToInt
```
default java.util.stream.IntStream flatMapToInt(java.util.function.Function<? super U,? extends java.util.stream.IntStream> mapper)
```
 Specified by:
 
 flatMapToInt in interface org.jooq.lambda.Seq
 
 Specified by:
 
 flatMapToInt in interface java.util.stream.Stream
 - flatMapToLong
```
default java.util.stream.LongStream flatMapToLong(java.util.function.Function<? super U,? extends java.util.stream.LongStream> mapper)
```
 Specified by:
 
 flatMapToLong in interface org.jooq.lambda.Seq
 
 Specified by:
 
 flatMapToLong in interface java.util.stream.Stream
 - flatMapToDouble
```
default java.util.stream.DoubleStream flatMapToDouble(java.util.function.Function<? super U,? extends java.util.stream.DoubleStream> mapper)
```
 Specified by:
 
 flatMapToDouble in interface org.jooq.lambda.Seq
 
 Specified by:
 
 flatMapToDouble in interface java.util.stream.Stream
 - sorted
```
default org.jooq.lambda.Seq sorted()
```
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 
 Specified by:
 
 sorted in interface java.util.stream.Stream
 - sorted
```
default org.jooq.lambda.Seq sorted(java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 sorted in interface org.jooq.lambda.Seq
 
 Specified by:
 
 sorted in interface java.util.stream.Stream
 - self
```
default FutureStream self(java.util.function.Consumer<FutureStream> 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)
 - slice
```
default org.jooq.lambda.Seq slice(long from,
 long to)
```
 Returns a limited interval from a given Stream. // (4, 5) Seq.of(1, 2, 3, 4, 5, 6).slice(3, 5)
 
 Specified by:
 
 slice in interface org.jooq.lambda.Seq
 
 See Also:
 
 Seq.slice(Stream, long, long)
 - slice
```
static <T> org.jooq.lambda.Seq<T> slice(FutureStream<T> stream,
 long from,
 long to)
```
 Returns a limited interval from a given Stream. // (4, 5) EagerFutureStream.of(1, 2, 3, 4, 5, 6).slice(3, 5)
 - getSubscription
```
Continueable getSubscription()
```
 Specified by:
 
 getSubscription in interface SimpleReactStream
 - getTaskExecutor
```
java.util.concurrent.Executor getTaskExecutor()
```
 Specified by:
 
 getTaskExecutor in interface SimpleReactStream
 - getLastActive
```
StreamWrapper getLastActive()
```
 Specified by:
 
 getLastActive in interface BlockingStream
 
 Specified by:
 
 getLastActive in interface SimpleReactStream

Interface FutureStream<U>

Nested Class Summary

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

Field Summary

Method Summary

Methods inherited from interface org.jooq.lambda.Seq

Methods inherited from interface java.util.stream.Stream

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

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

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

Field Detail

softener

Method Detail

lift

lift2

iterator

sync

async

isAsync

toLazyCollection

toConcurrentLazyCollection

single

zipFutures

crossJoin

onEmpty

onEmptyGet

onEmptyThrow

innerJoin

leftOuterJoin

rightOuterJoin

zipFutures

chunkLastReadIterator

chunkSinceLastRead

withQueueFactory

shard

cancel

batchBySizeAndTime

batchBySizeAndTime

batchBySize

batch

batchBySize

jitter

fixedDelay

control

debounce

onePer

xPer

batchByTime

batchByTime

onFail

fromStream

flatMap

filter

peek

capture

forEach

forEachOrdered

toArray

sliding

sliding

futureOperations

futureOperations

toArray

reduce

reduce

collect

min

max

count

anyMatch

allMatch

noneMatch

findFirst

firstValue

findAny

reduce

reverse

reversedIterator

spliterator

isParallel