com.aol.cyclops.sequence.future

Interface FutureOperations<T>

All Superinterfaces:

DoubleOperators<T>, IntOperators<T>, LongOperators<T>, ReactiveStreamsTerminalFutureOperations<T>

public interface FutureOperations<T>
extends IntOperators<T>, DoubleOperators<T>, LongOperators<T>, ReactiveStreamsTerminalFutureOperations<T>

Method Summary

Modifier and Type	Method and Description
java.util.concurrent.CompletableFuture<java.lang.Boolean>	allMatch(java.util.function.Predicate<? super T> predicate) Perform an asynchronous All Match operation
java.util.concurrent.CompletableFuture<java.lang.Boolean>	anyMatch(java.util.function.Predicate<? super T> predicate) Perform an asynchronous Any Match operation
<R,A> java.util.concurrent.CompletableFuture<R>	collect(java.util.stream.Collector<? super T,A,R> collector) Asynchronously perform a Stream collection
<R> java.util.concurrent.CompletableFuture<R>	collect(java.util.function.Supplier<R> supplier, java.util.function.BiConsumer<R,? super T> accumulator, java.util.function.BiConsumer<R,R> combiner) Asynchronously perform a Stream collection
java.util.concurrent.CompletableFuture<java.lang.Long>	count() Asynchronously perform a Stream count
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	findAny() Perform an asynchronous findAny operation
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	findFirst() Perform an asynchronous findAny operation
java.util.concurrent.CompletableFuture<T>	firstValue() Perform an asynchronous findAny operation
<U> java.util.concurrent.CompletableFuture<U>	foldLeft(U seed, java.util.function.BiFunction<U,? super T,U> function) Perform an asynchronous foldLeft operation
<U> java.util.concurrent.CompletableFuture<U>	foldRight(U seed, java.util.function.BiFunction<? super T,U,U> function) Perform an asynchronous foldRight operation
void	forEach(java.util.function.Consumer<T> object)
<K> java.util.concurrent.CompletableFuture<java.util.Map<K,java.util.List<T>>>	groupBy(java.util.function.Function<? super T,? extends K> classifier) Perform an asyncrhonous groupBy operation
<K,A,D> java.util.concurrent.CompletableFuture<java.util.Map<K,D>>	groupBy(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream) Perform an asyncrhonous groupBy operation
<K,D,A,M extends java.util.Map<K,D>> java.util.concurrent.CompletableFuture<M>	groupBy(java.util.function.Function<? super T,? extends K> classifier, java.util.function.Supplier<M> mapFactory, java.util.stream.Collector<? super T,A,D> downstream) Perform an asyncrhonous groupBy operation
java.util.concurrent.CompletableFuture<java.lang.String>	join() Perform an asynchronous join operation
java.util.concurrent.CompletableFuture<java.lang.String>	join(java.lang.CharSequence sep)
java.util.concurrent.CompletableFuture<java.lang.String>	join(java.lang.CharSequence delimiter, java.lang.CharSequence prefix, java.lang.CharSequence suffix) Perform an asynchronous join operation
java.util.concurrent.CompletableFuture<T>	lastValue()
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	max(java.util.Comparator<? super T> comparator) Perform an asyncrhonous min operation
<U extends java.lang.Comparable<U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>>	maxBy(java.util.function.Function<T,U> function) Asynchronously capture the maximum value in this stream using the provided function
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	min(java.util.Comparator<? super T> comparator) Perform an asyncrhonous min operation
<U extends java.lang.Comparable<U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>>	minBy(java.util.function.Function<T,U> function) Asynchronously capture the minimum value in this stream using the provided function
java.util.concurrent.CompletableFuture<java.lang.Boolean>	noneMatch(java.util.function.Predicate<? super T> predicate) Perform an asynchronous Any Match operation
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	reduce(java.util.function.BinaryOperator<T> accumulator) Asynchronously perform a Stream reduction
java.util.concurrent.CompletableFuture<T>	reduce(T identity, java.util.function.BinaryOperator<T> accumulator) Asynchronously perform a Stream reduction
<U> java.util.concurrent.CompletableFuture<U>	reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner) Asynchronously perform a Stream reduction
java.util.concurrent.CompletableFuture<T>	single()
java.util.concurrent.CompletableFuture<T>	single(java.util.function.Predicate<T> predicate)
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	singleOptional()
java.util.concurrent.CompletableFuture<java.lang.Object[]>	toArray() Asyncrhonously generate an Array
<A> java.util.concurrent.CompletableFuture<A[]>	toArray(java.util.function.IntFunction<A[]> generator) Asyncrhonously generate an Array
<C extends java.util.Collection<T>> java.util.concurrent.CompletableFuture<C>	toCollection(java.util.function.Supplier<C> collectionFactory) Asynchronously perform a Stream collection
java.util.concurrent.CompletableFuture<java.util.List<T>>	toList() Asynchronously convert this Stream into a List
java.util.concurrent.CompletableFuture<java.util.Set<T>>	toSet() Asynchronously convert this Stream into a List

Methods inherited from interface com.aol.cyclops.sequence.future.IntOperators

averageInt, maxInt, minInt, sumInt, summaryStatisticsInt

Methods inherited from interface com.aol.cyclops.sequence.future.DoubleOperators

averageDouble, maxDouble, minDouble, sumDouble, summaryStatisticsDouble

Methods inherited from interface com.aol.cyclops.sequence.future.LongOperators

averageLong, maxLong, minLong, sumLong, summaryStatisticsLong

Methods inherited from interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalFutureOperations

forEachEvent, forEachWithError, forEachX, forEachXEvents, forEachXWithError

Method Detail

toList

java.util.concurrent.CompletableFuture<java.util.List<T>> toList()

Asynchronously convert this Stream into a List

 
  CompletableFuture<List<Data>> myList = EagerFutureStream.of(1,2,3,4)
  														.map(this::loadFromDb)
  														.withTaskExecutor(parallelBuilder().getExecutor())
  														.map(this::processOnDifferentExecutor)
  														.toList();
 
 

Returns:

Future List

lastValue

java.util.concurrent.CompletableFuture<T> lastValue()

Returns:

Last value in this Stream (must be non-empty)

single

java.util.concurrent.CompletableFuture<T> single()

Returns:

the only entry in this Stream if it is a single entry Stream, otherwise throws an UnsupportedOperationException

single

java.util.concurrent.CompletableFuture<T> single(java.util.function.Predicate<T> predicate)

Returns:

the only entry in this Stream if it is a single entry Stream, otherwise throws an UnsupportedOperationException

singleOptional

java.util.concurrent.CompletableFuture<java.util.Optional<T>> singleOptional()

Returns:

the only entry in this Stream if it is a single entry Stream, otherwise throws an UnsupportedOperationException

toSet

java.util.concurrent.CompletableFuture<java.util.Set<T>> toSet()

Asynchronously convert this Stream into a List

 
  CompletableFuture<Set<Data>> myList = LazyFutureStream.of(1,2,3,4)
  														.map(this::loadFromDb)
  														.withTaskExecutor(parallelBuilder().getExecutor())
  														.map(this::processOnDifferentExecutor)
  														.toSet();
 
 

Returns:

Future Set

minBy

<U extends java.lang.Comparable<U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>> minBy(java.util.function.Function<T,U> function)

Asynchronously capture the minimum value in this stream using the provided function

See Also:

Seq.minBy(Function)

maxBy

<U extends java.lang.Comparable<U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>> maxBy(java.util.function.Function<T,U> function)

Asynchronously capture the maximum value in this stream using the provided function

See Also:

Seq.maxBy(Function)

collect

<R,A> java.util.concurrent.CompletableFuture<R> collect(java.util.stream.Collector<? super T,A,R> collector)

Asynchronously perform a Stream collection

See Also:

Stream.collect(Collector)

toCollection

<C extends java.util.Collection<T>> java.util.concurrent.CompletableFuture<C> toCollection(java.util.function.Supplier<C> collectionFactory)

Asynchronously perform a Stream collection

See Also:

Seq.toCollection(Supplier)

toArray

<A> java.util.concurrent.CompletableFuture<A[]> toArray(java.util.function.IntFunction<A[]> generator)

Asyncrhonously generate an Array

See Also:

Stream.toArray(IntFunction)

toArray

java.util.concurrent.CompletableFuture<java.lang.Object[]> toArray()

Asyncrhonously generate an Array

See Also:

Stream.toArray(IntFunction)

groupBy

<K> java.util.concurrent.CompletableFuture<java.util.Map<K,java.util.List<T>>> groupBy(java.util.function.Function<? super T,? extends K> classifier)

Perform an asyncrhonous groupBy operation

See Also:

Seq.groupBy(Function)

groupBy

<K,A,D> java.util.concurrent.CompletableFuture<java.util.Map<K,D>> groupBy(java.util.function.Function<? super T,? extends K> classifier,
                                                                           java.util.stream.Collector<? super T,A,D> downstream)

Perform an asyncrhonous groupBy operation

See Also:

Seq.groupBy(Function, Collector)

groupBy

<K,D,A,M extends java.util.Map<K,D>> java.util.concurrent.CompletableFuture<M> groupBy(java.util.function.Function<? super T,? extends K> classifier,
                                                                                       java.util.function.Supplier<M> mapFactory,
                                                                                       java.util.stream.Collector<? super T,A,D> downstream)

Perform an asyncrhonous groupBy operation

See Also:

Seq.groupBy(Function, Supplier, Collector)

foldLeft

<U> java.util.concurrent.CompletableFuture<U> foldLeft(U seed,
                                                       java.util.function.BiFunction<U,? super T,U> function)

Perform an asynchronous foldLeft operation

See Also:

Seq.foldLeft(Object,BiFunction)

foldRight

<U> java.util.concurrent.CompletableFuture<U> foldRight(U seed,
                                                        java.util.function.BiFunction<? super T,U,U> function)

Perform an asynchronous foldRight operation

See Also:

Seq.foldRight(Object,BiFunction)

min

java.util.concurrent.CompletableFuture<java.util.Optional<T>> min(java.util.Comparator<? super T> comparator)

Perform an asyncrhonous min operation

See Also:

Stream.min(Comparator)

max

java.util.concurrent.CompletableFuture<java.util.Optional<T>> max(java.util.Comparator<? super T> comparator)

Perform an asyncrhonous min operation

See Also:

Stream.max(Comparator)

collect

<R> java.util.concurrent.CompletableFuture<R> collect(java.util.function.Supplier<R> supplier,
                                                      java.util.function.BiConsumer<R,? super T> accumulator,
                                                      java.util.function.BiConsumer<R,R> combiner)

Asynchronously perform a Stream collection

See Also:

Stream.collect(Supplier, BiConsumer, BiConsumer)

reduce

<U> java.util.concurrent.CompletableFuture<U> reduce(U identity,
                                                     java.util.function.BiFunction<U,? super T,U> accumulator,
                                                     java.util.function.BinaryOperator<U> combiner)

Asynchronously perform a Stream reduction

See Also:

Stream.reduce(Object, BiFunction, BinaryOperator)

reduce

java.util.concurrent.CompletableFuture<java.util.Optional<T>> reduce(java.util.function.BinaryOperator<T> accumulator)

Asynchronously perform a Stream reduction

See Also:

Stream.reduce(BinaryOperator)

reduce

java.util.concurrent.CompletableFuture<T> reduce(T identity,
                                                 java.util.function.BinaryOperator<T> accumulator)

Asynchronously perform a Stream reduction

See Also:

Stream.reduce(Object, BinaryOperator)

count

java.util.concurrent.CompletableFuture<java.lang.Long> count()

Asynchronously perform a Stream count

See Also:

Stream.count()

join

java.util.concurrent.CompletableFuture<java.lang.String> join(java.lang.CharSequence sep)

join

java.util.concurrent.CompletableFuture<java.lang.String> join()

Perform an asynchronous join operation

See Also:

Seq.join()

join

java.util.concurrent.CompletableFuture<java.lang.String> join(java.lang.CharSequence delimiter,
                                                              java.lang.CharSequence prefix,
                                                              java.lang.CharSequence suffix)

Perform an asynchronous join operation

See Also:

Seq.join(CharSequence)

findAny

java.util.concurrent.CompletableFuture<java.util.Optional<T>> findAny()

Perform an asynchronous findAny operation

See Also:

Stream.findAny()

findFirst

java.util.concurrent.CompletableFuture<java.util.Optional<T>> findFirst()

Perform an asynchronous findAny operation

See Also:

Stream.findFirst()

firstValue

java.util.concurrent.CompletableFuture<T> firstValue()

Perform an asynchronous findAny operation

See Also:

Stream.findFirst()

allMatch

java.util.concurrent.CompletableFuture<java.lang.Boolean> allMatch(java.util.function.Predicate<? super T> predicate)

Perform an asynchronous All Match operation

See Also:

Stream.allMatch(Predicate)

anyMatch

java.util.concurrent.CompletableFuture<java.lang.Boolean> anyMatch(java.util.function.Predicate<? super T> predicate)

Perform an asynchronous Any Match operation

See Also:

Stream.anyMatch(Predicate)

noneMatch

java.util.concurrent.CompletableFuture<java.lang.Boolean> noneMatch(java.util.function.Predicate<? super T> predicate)

Perform an asynchronous Any Match operation

See Also:

Stream.noneMatch(Predicate)

forEach

void forEach(java.util.function.Consumer<T> object)