Package io.activej.promise

Class Promises

java.lang.Object

io.activej.promise.Promises

public class Promises
extends Object

Allows managing multiple Promises.

Constructor Summary

Constructors

Constructor	Description
Promises()

Method Summary

Modifier and Type	Method	Description
static Promise<Void>	all()
static Promise<Void>	all(Promise<?> promise1)
static Promise<Void>	all(Promise<?>... promises)
static Promise<Void>	all(Promise<?> promise1, Promise<?> promise2)	Optimized for 2 promises.
static Promise<Void>	all(Iterator<? extends Promise<?>> promises)	Returns Promise that completes when all of the promises are completed.
static Promise<Void>	all(List<? extends Promise<?>> promises)	Returns a Promise that completes when all of the promises are completed.
static Promise<Void>	all(Stream<? extends Promise<?>> promises)
static <T> Promise<T>	any()	Returns a CompleteExceptionallyPromise with Exception, since this method doesn't accept any Promises
static <T> Promise<T>	any(Promise<? extends T> promise1)
static <T> Promise<T>	any(Promise<? extends T>... promises)
static <T> Promise<T>	any(Promise<? extends T> promise1, Promise<? extends T> promise2)	Optimized for 2 promises.
static <T> Promise<T>	any(BiPredicate<? super T,Exception> predicate, Promise<? extends T> promise1)
static <T> Promise<T>	any(BiPredicate<? super T,Exception> predicate, Promise<? extends T>... promises)
static <T> Promise<T>	any(BiPredicate<? super T,Exception> predicate, Promise<? extends T> promise1, Promise<? extends T> promise2)
static <T> Promise<T>	any(BiPredicate<? super T,Exception> predicate, Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	any(BiPredicate<? super T,Exception> predicate, List<? extends Promise<? extends T>> promises)
static <T> Promise<T>	any(BiPredicate<? super T,Exception> predicate, Stream<? extends Promise<? extends T>> promises)
static <T> Promise<T>	any(Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	any(List<? extends Promise<? extends T>> promises)
static <T> Promise<T>	any(Stream<? extends Promise<? extends T>> promises)
static <T> Iterator<Promise<T>>	asPromises(AsyncSupplier<? extends T>... tasks)	Transforms an AsyncSupplier tasks to a collection of Promises.
static <T> Iterator<Promise<T>>	asPromises(Iterable<? extends AsyncSupplier<? extends T>> tasks)	Transforms an Iterable of AsyncSupplier tasks to a collection of Promises.
static <T> Iterator<Promise<T>>	asPromises(Iterator<? extends AsyncSupplier<? extends T>> tasks)	Transforms a collection of AsyncSupplier tasks to a collection of Promises.
static <T> Iterator<Promise<T>>	asPromises(Stream<? extends AsyncSupplier<? extends T>> tasks)	Transforms a Stream of AsyncSupplier tasks to a collection of Promises.
static <T, A, R> AsyncFunction<T,R>	coalesce(Supplier<A> argumentAccumulatorSupplier, BiConsumer<A,T> argumentAccumulatorFn, AsyncFunction<A,R> fn)
static Promise<Void>	delay(long delayMillis)
static <T> Promise<T>	delay(long delayMillis, Promise<T> promise)	Delays completion of provided promise for the defined period of time.
static <T> Promise<T>	delay(long delayMillis, T value)
static Promise<Void>	delay(ReactorScheduler reactor, long delayMillis)
static <T> Promise<T>	delay(ReactorScheduler reactor, long delayMillis, Promise<T> promise)
static <T> Promise<T>	delay(ReactorScheduler reactor, long delayMillis, T value)
static Promise<Void>	delay(ReactorScheduler reactor, Duration delay)
static <T> Promise<T>	delay(ReactorScheduler reactor, Duration delay, Promise<T> promise)
static <T> Promise<T>	delay(ReactorScheduler reactor, Duration delay, T value)
static Promise<Void>	delay(Duration delay)
static <T> Promise<T>	delay(Duration delay, Promise<T> promise)
static <T> Promise<T>	delay(Duration delay, T value)
static <T> Promise<T>	first(AsyncSupplier<? extends T>... promises)	Picks the first Promise that was completed without exception.
static <T> Promise<T>	first(Iterable<? extends AsyncSupplier<? extends T>> promises)
static <T> Promise<T>	first(BiPredicate<? super T,? super Exception> predicate, AsyncSupplier<? extends T>... promises)
static <T> Promise<T>	first(BiPredicate<? super T,? super Exception> predicate, Iterable<? extends AsyncSupplier<? extends T>> promises)
static <T> Promise<T>	first(BiPredicate<? super T,? super Exception> predicate, Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	first(BiPredicate<? super T,? super Exception> predicate, Stream<? extends AsyncSupplier<? extends T>> promises)
static <T> Promise<T>	first(Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	first(Stream<? extends AsyncSupplier<? extends T>> promises)
static <T> Promise<T>	interval(long intervalMillis, Promise<T> promise)
static <T> Promise<T>	interval(ReactorScheduler reactor, long intervalMillis, Promise<T> promise)
static <T> Promise<T>	interval(ReactorScheduler reactor, Duration interval, Promise<T> promise)
static <T> Promise<T>	interval(Duration interval, Promise<T> promise)
static <T> Promise<T>	loop(T seed, Predicate<T> loopCondition, io.activej.common.function.FunctionEx<T,Promise<T>> next)	Repeats provided FunctionEx until can pass Predicate test.
static <T, T1, R, R1> AsyncFunction<T,R>	mapTuple(io.activej.common.tuple.TupleConstructor1<R1,R> constructor, Function<? super T,T1> getter1, Function<T1,Promise<R1>> fn1)
static <T, T1, T2, R, R1, R2> AsyncFunction<T,R>	mapTuple(io.activej.common.tuple.TupleConstructor2<R1,R2,R> constructor, Function<? super T,T1> getter1, Function<T1,Promise<R1>> fn1, Function<? super T,T2> getter2, Function<T2,Promise<R2>> fn2)
static <T, T1, T2, T3, R, R1, R2, R3> AsyncFunction<T,R>	mapTuple(io.activej.common.tuple.TupleConstructor3<R1,R2,R3,R> constructor, Function<? super T,T1> getter1, Function<T1,Promise<R1>> fn1, Function<? super T,T2> getter2, Function<T2,Promise<R2>> fn2, Function<? super T,T3> getter3, Function<T3,Promise<R3>> fn3)
static <T, T1, T2, T3, T4, R, R1, R2, R3, R4> AsyncFunction<T,R>	mapTuple(io.activej.common.tuple.TupleConstructor4<R1,R2,R3,R4,R> constructor, Function<? super T,T1> getter1, Function<T1,Promise<R1>> fn1, Function<? super T,T2> getter2, Function<T2,Promise<R2>> fn2, Function<? super T,T3> getter3, Function<T3,Promise<R3>> fn3, Function<? super T,T4> getter4, Function<T4,Promise<R4>> fn4)
static <T, T1, T2, T3, T4, T5, R, R1, R2, R3, R4, R5> AsyncFunction<T,R>	mapTuple(io.activej.common.tuple.TupleConstructor5<R1,R2,R3,R4,R5,R> constructor, Function<? super T,T1> getter1, Function<T1,Promise<R1>> fn1, Function<? super T,T2> getter2, Function<T2,Promise<R2>> fn2, Function<? super T,T3> getter3, Function<T3,Promise<R3>> fn3, Function<? super T,T4> getter4, Function<T4,Promise<R4>> fn4, Function<? super T,T5> getter5, Function<T5,Promise<R5>> fn5)
static <T, T1, T2, T3, T4, T5, T6, R, R1, R2, R3, R4, R5, R6> AsyncFunction<T,R>	mapTuple(io.activej.common.tuple.TupleConstructor6<R1,R2,R3,R4,R5,R6,R> constructor, Function<? super T,T1> getter1, Function<T1,Promise<R1>> fn1, Function<? super T,T2> getter2, Function<T2,Promise<R2>> fn2, Function<? super T,T3> getter3, Function<T3,Promise<R3>> fn3, Function<? super T,T4> getter4, Function<T4,Promise<R4>> fn4, Function<? super T,T5> getter5, Function<T5,Promise<R5>> fn5, Function<? super T,T6> getter6, Function<T6,Promise<R6>> fn6)
static <T, A, R> Promise<R>	reduce(A accumulator, io.activej.common.function.BiConsumerEx<A,T> combiner, io.activej.common.function.FunctionEx<A,R> finisher, int maxCalls, Iterator<Promise<T>> promises)	Asynchronously reduce Iterator of Promise<T>s into a Promise<R>.
static <T, A, R> Promise<R>	reduce(A accumulator, io.activej.common.function.BiConsumerEx<A,T> combiner, io.activej.common.function.FunctionEx<A,R> finisher, Collection<Promise<T>> promises)
static <T, A, R> Promise<R>	reduce(A accumulator, io.activej.common.function.BiConsumerEx<A,T> combiner, io.activej.common.function.FunctionEx<A,R> finisher, Iterator<Promise<T>> promises)	Asynchronously reduce Iterator of Promise<T>s into a Promise<R>.
static <T, A, R> Promise<R>	reduce(A accumulator, io.activej.common.function.BiConsumerEx<A,T> combiner, io.activej.common.function.FunctionEx<A,R> finisher, Stream<Promise<T>> promises)
static <T, A, R> Promise<R>	reduce(Collector<T,A,R> collector, int maxCalls, Iterator<Promise<T>> promises)	Asynchronously reduce Iterator of Promise<T>s into a Promise<R> with the help of Collector.
static Promise<Void>	repeat(AsyncSupplier<Boolean> supplier)	Repeats the operations of provided AsyncSupplier<Boolean> infinitely, until one of the Promises completes exceptionally or supplier returns a promise of false.
static <T> Promise<T>	retry(AsyncSupplier<T> supplier)
static <T> Promise<T>	retry(AsyncSupplier<T> supplier, RetryPolicy<?> retryPolicy)
static <T> Promise<T>	retry(AsyncSupplier<T> supplier, BiPredicate<T,Exception> breakCondition, RetryPolicy<?> retryPolicy)
static <T> Promise<T>	retry(BiPredicate<? super T,Exception> breakCondition, AsyncSupplier<T> supplier)
static Promise<Void>	schedule(long timestamp)
static <T> Promise<T>	schedule(long timestamp, Promise<T> promise)	Schedules completion of the Promise so that it will be completed after the timestamp even if its operations were completed earlier.
static <T> Promise<T>	schedule(long timestamp, T value)
static Promise<Void>	schedule(ReactorScheduler reactor, long timestamp)
static <T> Promise<T>	schedule(ReactorScheduler reactor, long timestamp, Promise<T> promise)
static <T> Promise<T>	schedule(ReactorScheduler reactor, long timestamp, T value)
static Promise<Void>	schedule(ReactorScheduler reactor, Instant instant)
static <T> Promise<T>	schedule(ReactorScheduler reactor, Instant instant, Promise<T> promise)
static <T> Promise<T>	schedule(ReactorScheduler reactor, Instant instant, T value)
static Promise<Void>	schedule(Instant instant)
static <T> Promise<T>	schedule(Instant instant, Promise<T> promise)
static <T> Promise<T>	schedule(Instant instant, T value)
static Promise<Void>	sequence()	Returns a CompleteNullPromise
static Promise<Void>	sequence(AsyncRunnable runnable)	Executes an AsyncRunnable, returning a Promise<Void> as a mark for completion
static Promise<Void>	sequence(AsyncRunnable... runnables)
static Promise<Void>	sequence(AsyncRunnable runnable1, AsyncRunnable runnable2)	Executes both AsyncRunnables consequently, returning a Promise<Void> as a mark for completion
static Promise<Void>	sequence(Iterable<? extends AsyncRunnable> runnables)
static Promise<Void>	sequence(Iterator<? extends Promise<Void>> promises)	Calls every Promise from promises in sequence and discards their results.Returns a SettablePromise with null result as a marker when all of the promises are completed.
static Promise<Void>	sequence(Stream<? extends AsyncRunnable> runnables)
static <T> Promise<T>	timeout(long delay, Promise<T> promise)	Waits until the delay passes and if the Promise is still not complete, tries to complete it with TIMEOUT_EXCEPTION.
static <T> Promise<T>	timeout(ReactorScheduler reactor, long delay, Promise<T> promise)
static <T> Promise<T>	timeout(ReactorScheduler reactor, Duration delay, Promise<T> promise)
static <T> Promise<T>	timeout(Duration delay, Promise<T> promise)
static <T> Promise<T[]>	toArray(Class<T> type)	Returns an array of provided type and length 0 wrapped in Promise.
static <T> Promise<T[]>	toArray(Class<T> type, Promise<? extends T> promise1)	Returns an array with promise1 result.
static <T> Promise<T[]>	toArray(Class<T> type, Promise<? extends T>... promises)
static <T> Promise<T[]>	toArray(Class<T> type, Promise<? extends T> promise1, Promise<? extends T> promise2)	Returns an array with promise1 and promise2 results.
static <T> Promise<T[]>	toArray(Class<T> type, Iterable<? extends Promise<? extends T>> promises)
static <T> Promise<T[]>	toArray(Class<T> type, Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T[]>	toArray(Class<T> type, List<? extends Promise<? extends T>> promises)	Reduces promises into Promise<Array>
static <T> Promise<T[]>	toArray(Class<T> type, Stream<? extends Promise<? extends T>> promises)
static <T> Promise<List<T>>	toList()	Returns a successfully completed Promise with an empty list as the result.
static <T> Promise<List<T>>	toList(Promise<? extends T> promise1)	Returns a completed Promise with a result wrapped in List.
static <T> Promise<List<T>>	toList(Promise<? extends T>... promises)
static <T> Promise<List<T>>	toList(Promise<? extends T> promise1, Promise<? extends T> promise2)	Returns Promise with a list of promise1 and promise2 results.
static <T> Promise<List<T>>	toList(Iterable<? extends Promise<? extends T>> promises)
static <T> Promise<List<T>>	toList(Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<List<T>>	toList(List<? extends Promise<? extends T>> promises)	Reduces list of Promises into Promise<List>.
static <T> Promise<List<T>>	toList(Stream<? extends Promise<? extends T>> promises)
static <T1, R> Promise<R>	toTuple(io.activej.common.tuple.TupleConstructor1<T1,R> constructor, Promise<? extends T1> promise1)
static <T1, T2, R> Promise<R>	toTuple(io.activej.common.tuple.TupleConstructor2<T1,T2,R> constructor, Promise<? extends T1> promise1, Promise<? extends T2> promise2)
static <T1, T2, T3, R> Promise<R>	toTuple(io.activej.common.tuple.TupleConstructor3<T1,T2,T3,R> constructor, Promise<? extends T1> promise1, Promise<? extends T2> promise2, Promise<? extends T3> promise3)
static <T1, T2, T3, T4, R> Promise<R>	toTuple(io.activej.common.tuple.TupleConstructor4<T1,T2,T3,T4,R> constructor, Promise<? extends T1> promise1, Promise<? extends T2> promise2, Promise<? extends T3> promise3, Promise<? extends T4> promise4)
static <T1, T2, T3, T4, T5, R> Promise<R>	toTuple(io.activej.common.tuple.TupleConstructor5<T1,T2,T3,T4,T5,R> constructor, Promise<? extends T1> promise1, Promise<? extends T2> promise2, Promise<? extends T3> promise3, Promise<? extends T4> promise4, Promise<? extends T5> promise5)
static <T1, T2, T3, T4, T5, T6, R> Promise<R>	toTuple(io.activej.common.tuple.TupleConstructor6<T1,T2,T3,T4,T5,T6,R> constructor, Promise<? extends T1> promise1, Promise<? extends T2> promise2, Promise<? extends T3> promise3, Promise<? extends T4> promise4, Promise<? extends T5> promise5, Promise<? extends T6> promise6)
static <T1> Promise<io.activej.common.tuple.Tuple1<T1>>	toTuple(Promise<? extends T1> promise1)
static <T1, T2> Promise<io.activej.common.tuple.Tuple2<T1,T2>>	toTuple(Promise<? extends T1> promise1, Promise<? extends T2> promise2)
static <T1, T2, T3> Promise<io.activej.common.tuple.Tuple3<T1,T2,T3>>	toTuple(Promise<? extends T1> promise1, Promise<? extends T2> promise2, Promise<? extends T3> promise3)
static <T1, T2, T3, T4> Promise<io.activej.common.tuple.Tuple4<T1,T2,T3,T4>>	toTuple(Promise<? extends T1> promise1, Promise<? extends T2> promise2, Promise<? extends T3> promise3, Promise<? extends T4> promise4)
static <T1, T2, T3, T4, T5> Promise<io.activej.common.tuple.Tuple5<T1,T2,T3,T4,T5>>	toTuple(Promise<? extends T1> promise1, Promise<? extends T2> promise2, Promise<? extends T3> promise3, Promise<? extends T4> promise4, Promise<? extends T5> promise5)
static <T1, T2, T3, T4, T5, T6> Promise<io.activej.common.tuple.Tuple6<T1,T2,T3,T4,T5,T6>>	toTuple(Promise<? extends T1> promise1, Promise<? extends T2> promise2, Promise<? extends T3> promise3, Promise<? extends T4> promise4, Promise<? extends T5> promise5, Promise<? extends T6> promise6)
static <T> Promise<T>	until(T seed, io.activej.common.function.FunctionEx<T,Promise<T>> next, Predicate<T> breakCondition)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

Promises

public Promises()

Method Details

timeout

@Contract(pure=true)
public static <T> Promise<T> timeout(Duration delay,
 Promise<T> promise)

See Also:

• timeout(long, Promise)

timeout

public static <T> Promise<T> timeout(ReactorScheduler reactor,
 Duration delay,
 Promise<T> promise)

timeout

@Contract(pure=true)
public static <T> Promise<T> timeout(long delay,
 Promise<T> promise)

Waits until the delay passes and if the Promise is still not complete, tries to complete it with TIMEOUT_EXCEPTION.

Parameters:

delay - time of delay

promise - the Promise to be tracked

Returns:

Promise

timeout

public static <T> Promise<T> timeout(ReactorScheduler reactor,
 long delay,
 Promise<T> promise)

delay

@Contract(pure=true)
public static Promise<Void> delay(Duration delay)

delay

public static Promise<Void> delay(ReactorScheduler reactor,
 Duration delay)

delay

@Contract(pure=true)
public static Promise<Void> delay(long delayMillis)

delay

public static Promise<Void> delay(ReactorScheduler reactor,
 long delayMillis)

delay

@Contract(pure=true)
public static <T> Promise<T> delay(Duration delay,
 T value)

delay

public static <T> Promise<T> delay(ReactorScheduler reactor,
 Duration delay,
 T value)

delay

@Contract(pure=true)
public static <T> Promise<T> delay(long delayMillis,
 T value)

delay

public static <T> Promise<T> delay(ReactorScheduler reactor,
 long delayMillis,
 T value)

delay

@Contract(pure=true)
public static <T> Promise<T> delay(Duration delay,
 Promise<T> promise)

See Also:

• delay(long, Promise)

delay

public static <T> Promise<T> delay(ReactorScheduler reactor,
 Duration delay,
 Promise<T> promise)

delay

@Contract(pure=true)
public static <T> Promise<T> delay(long delayMillis,
 Promise<T> promise)

Delays completion of provided promise for the defined period of time.

Parameters:

delayMillis - delay in millis

promise - the Promise to be delayed

Returns:

completed Promise

delay

public static <T> Promise<T> delay(ReactorScheduler reactor,
 long delayMillis,
 Promise<T> promise)

interval

@Contract(pure=true)
public static <T> Promise<T> interval(Duration interval,
 Promise<T> promise)

interval

public static <T> Promise<T> interval(ReactorScheduler reactor,
 Duration interval,
 Promise<T> promise)

interval

@Contract(pure=true)
public static <T> Promise<T> interval(long intervalMillis,
 Promise<T> promise)

interval

public static <T> Promise<T> interval(ReactorScheduler reactor,
 long intervalMillis,
 Promise<T> promise)

schedule

@Contract(pure=true)
public static Promise<Void> schedule(Instant instant)

See Also:

• schedule(long, Promise)

schedule

public static Promise<Void> schedule(ReactorScheduler reactor,
 Instant instant)

schedule

@Contract(pure=true)
public static Promise<Void> schedule(long timestamp)

See Also:

• schedule(long, Promise)

schedule

public static Promise<Void> schedule(ReactorScheduler reactor,
 long timestamp)

schedule

@Contract(pure=true)
public static <T> Promise<T> schedule(Instant instant,
 T value)

See Also:

• schedule(long, Promise)

schedule

public static <T> Promise<T> schedule(ReactorScheduler reactor,
 Instant instant,
 T value)

schedule

@Contract(pure=true)
public static <T> Promise<T> schedule(long timestamp,
 T value)

See Also:

• schedule(long, Promise)

schedule

public static <T> Promise<T> schedule(ReactorScheduler reactor,
 long timestamp,
 T value)

schedule

@Contract(pure=true)
public static <T> Promise<T> schedule(Instant instant,
 Promise<T> promise)

See Also:

• schedule(long, Promise)

schedule

public static <T> Promise<T> schedule(ReactorScheduler reactor,
 Instant instant,
 Promise<T> promise)

schedule

@Contract(pure=true)
public static <T> Promise<T> schedule(long timestamp,
 Promise<T> promise)

Schedules completion of the Promise so that it will be completed after the timestamp even if its operations were completed earlier.

schedule

public static <T> Promise<T> schedule(ReactorScheduler reactor,
 long timestamp,
 Promise<T> promise)

all

@Contract(pure=true)
public static Promise<Void> all()

See Also:

• all(List)

all

@Contract(pure=true)
public static Promise<Void> all(Promise<?> promise1)

See Also:

• all(List)

all

@Contract(pure=true)
public static Promise<Void> all(Promise<?> promise1,
 Promise<?> promise2)

Optimized for 2 promises.

See Also:

• all(List)

all

@Contract(pure=true)
public static Promise<Void> all(Promise<?>... promises)

See Also:

• all(List)

all

@Contract(pure=true)
public static Promise<Void> all(List<? extends Promise<?>> promises)

Returns a Promise that completes when all of the promises are completed.

all

@Contract(pure=true)
public static Promise<Void> all(Stream<? extends Promise<?>> promises)

See Also:

• all(List)

all

public static Promise<Void> all(Iterator<? extends Promise<?>> promises)

Returns Promise that completes when all of the promises are completed. If at least one of the promises completes exceptionally, a CompleteExceptionallyPromise will be returned.

any

@Contract(pure=true)
public static <T> Promise<T> any()

Returns a CompleteExceptionallyPromise with Exception, since this method doesn't accept any Promises

See Also:

• any(Iterator)

any

@Contract(pure=true)
public static <T> Promise<T> any(Promise<? extends T> promise1)

See Also:

• any(Iterator)

any

@Contract(pure=true)
public static <T> Promise<T> any(Promise<? extends T> promise1,
 Promise<? extends T> promise2)

Optimized for 2 promises.

See Also:

• any(Iterator)

any

@Contract(pure=true)
@SafeVarargs
public static <T> Promise<T> any(Promise<? extends T>... promises)

See Also:

• any(Iterator)

any

@Contract(pure=true)
public static <T> Promise<T> any(List<? extends Promise<? extends T>> promises)

See Also:

• any(Iterator)

any

@Contract(pure=true)
public static <T> Promise<T> any(Stream<? extends Promise<? extends T>> promises)

See Also:

• any(Iterator)

any

public static <T> Promise<T> any(Iterator<? extends Promise<? extends T>> promises)

any

@Contract(pure=true)
public static <T> Promise<T> any(BiPredicate<? super T,Exception> predicate,
 Promise<? extends T> promise1)

any

@Contract(pure=true)
public static <T> Promise<T> any(BiPredicate<? super T,Exception> predicate,
 Promise<? extends T> promise1,
 Promise<? extends T> promise2)

any

@Contract(pure=true)
@SafeVarargs
public static <T> Promise<T> any(BiPredicate<? super T,Exception> predicate,
 Promise<? extends T>... promises)

any

@Contract(pure=true)
public static <T> Promise<T> any(BiPredicate<? super T,Exception> predicate,
 Stream<? extends Promise<? extends T>> promises)

any

@Contract(pure=true)
public static <T> Promise<T> any(BiPredicate<? super T,Exception> predicate,
 List<? extends Promise<? extends T>> promises)

any

public static <T> Promise<T> any(BiPredicate<? super T,Exception> predicate,
 Iterator<? extends Promise<? extends T>> promises)

toList

@Contract(pure=true)
public static <T> Promise<List<T>> toList()

Returns a successfully completed Promise with an empty list as the result.

toList

@Contract(pure=true)
public static <T> Promise<List<T>> toList(Promise<? extends T> promise1)

Returns a completed Promise with a result wrapped in List.

toList

@Contract(pure=true)
public static <T> Promise<List<T>> toList(Promise<? extends T> promise1,
 Promise<? extends T> promise2)

Returns Promise with a list of promise1 and promise2 results.

toList

@Contract(pure=true)
@SafeVarargs
public static <T> Promise<List<T>> toList(Promise<? extends T>... promises)

See Also:

• toList(List)

toList

@Contract(pure=true)
public static <T> Promise<List<T>> toList(List<? extends Promise<? extends T>> promises)

Reduces list of Promises into Promise<List>.

toList

@Contract(pure=true)
public static <T> Promise<List<T>> toList(Stream<? extends Promise<? extends T>> promises)

See Also:

• toList(List)

toList

@Contract(pure=true)
public static <T> Promise<List<T>> toList(Iterable<? extends Promise<? extends T>> promises)

See Also:

• toList(List)

toList

@Contract(pure=true)
public static <T> Promise<List<T>> toList(Iterator<? extends Promise<? extends T>> promises)

See Also:

• toList(List)

toArray

@Contract(pure=true)
public static <T> Promise<T[]> toArray(Class<T> type)

Returns an array of provided type and length 0 wrapped in Promise.

toArray

@Contract(pure=true)
public static <T> Promise<T[]> toArray(Class<T> type,
 Promise<? extends T> promise1)

Returns an array with promise1 result.

toArray

@Contract(pure=true)
public static <T> Promise<T[]> toArray(Class<T> type,
 Promise<? extends T> promise1,
 Promise<? extends T> promise2)

Returns an array with promise1 and promise2 results.

toArray

@Contract(pure=true)
@SafeVarargs
public static <T> Promise<T[]> toArray(Class<T> type,
 Promise<? extends T>... promises)

See Also:

• toArray(Class, List)

toArray

@Contract(pure=true)
public static <T> Promise<T[]> toArray(Class<T> type,
 List<? extends Promise<? extends T>> promises)

Reduces promises into Promise<Array>

toArray

@Contract(pure=true)
public static <T> Promise<T[]> toArray(Class<T> type,
 Stream<? extends Promise<? extends T>> promises)

See Also:

• toArray(Class, List)

toArray

@Contract(pure=true)
public static <T> Promise<T[]> toArray(Class<T> type,
 Iterable<? extends Promise<? extends T>> promises)

See Also:

• toArray(Class, List)

toArray

@Contract(pure=true)
public static <T> Promise<T[]> toArray(Class<T> type,
 Iterator<? extends Promise<? extends T>> promises)

See Also:

• toArray(Class, List)

toTuple

@Contract(pure=true)
public static <T1,
R> Promise<R> toTuple(io.activej.common.tuple.TupleConstructor1<T1,R> constructor,
 Promise<? extends T1> promise1)

toTuple

@Contract(pure=true)
public static <T1,
T2,
R> Promise<R> toTuple(io.activej.common.tuple.TupleConstructor2<T1,T2,R> constructor,
 Promise<? extends T1> promise1,
 Promise<? extends T2> promise2)

toTuple

@Contract(pure=true)
public static <T1,
T2,
T3,
R> Promise<R> toTuple(io.activej.common.tuple.TupleConstructor3<T1,T2,T3,R> constructor,
 Promise<? extends T1> promise1,
 Promise<? extends T2> promise2,
 Promise<? extends T3> promise3)

toTuple

@Contract(pure=true)
public static <T1,
T2,
T3,
T4,
R> Promise<R> toTuple(io.activej.common.tuple.TupleConstructor4<T1,T2,T3,T4,R> constructor,
 Promise<? extends T1> promise1,
 Promise<? extends T2> promise2,
 Promise<? extends T3> promise3,
 Promise<? extends T4> promise4)

toTuple

@Contract(pure=true)
public static <T1,
T2,
T3,
T4,
T5,
R> Promise<R> toTuple(io.activej.common.tuple.TupleConstructor5<T1,T2,T3,T4,T5,R> constructor,
 Promise<? extends T1> promise1,
 Promise<? extends T2> promise2,
 Promise<? extends T3> promise3,
 Promise<? extends T4> promise4,
 Promise<? extends T5> promise5)

toTuple

@Contract(pure=true)
public static <T1,
T2,
T3,
T4,
T5,
T6,
R> Promise<R> toTuple(io.activej.common.tuple.TupleConstructor6<T1,T2,T3,T4,T5,T6,R> constructor,
 Promise<? extends T1> promise1,
 Promise<? extends T2> promise2,
 Promise<? extends T3> promise3,
 Promise<? extends T4> promise4,
 Promise<? extends T5> promise5,
 Promise<? extends T6> promise6)

toTuple

@Contract(pure=true)
public static <T1>
Promise<io.activej.common.tuple.Tuple1<T1>> toTuple(Promise<? extends T1> promise1)

toTuple

@Contract(pure=true)
public static <T1,
T2>
Promise<io.activej.common.tuple.Tuple2<T1,T2>> toTuple(Promise<? extends T1> promise1,
 Promise<? extends T2> promise2)

toTuple

@Contract(pure=true)
public static <T1,
T2,
T3>
Promise<io.activej.common.tuple.Tuple3<T1,T2,T3>> toTuple(Promise<? extends T1> promise1,
 Promise<? extends T2> promise2,
 Promise<? extends T3> promise3)

toTuple

@Contract(pure=true)
public static <T1,
T2,
T3,
T4>
Promise<io.activej.common.tuple.Tuple4<T1,T2,T3,T4>> toTuple(Promise<? extends T1> promise1,
 Promise<? extends T2> promise2,
 Promise<? extends T3> promise3,
 Promise<? extends T4> promise4)

toTuple

@Contract(pure=true)
public static <T1,
T2,
T3,
T4,
T5>
Promise<io.activej.common.tuple.Tuple5<T1,T2,T3,T4,T5>> toTuple(Promise<? extends T1> promise1,
 Promise<? extends T2> promise2,
 Promise<? extends T3> promise3,
 Promise<? extends T4> promise4,
 Promise<? extends T5> promise5)

toTuple

@Contract(pure=true)
public static <T1,
T2,
T3,
T4,
T5,
T6>
Promise<io.activej.common.tuple.Tuple6<T1,T2,T3,T4,T5,T6>> toTuple(Promise<? extends T1> promise1,
 Promise<? extends T2> promise2,
 Promise<? extends T3> promise3,
 Promise<? extends T4> promise4,
 Promise<? extends T5> promise5,
 Promise<? extends T6> promise6)

mapTuple

@Contract(pure=true)
public static <T,
T1,
R,
R1> AsyncFunction<T,R> mapTuple(io.activej.common.tuple.TupleConstructor1<R1,R> constructor,
 Function<? super T,T1> getter1,
 Function<T1,Promise<R1>> fn1)

mapTuple

@Contract(pure=true)
public static <T,
T1,
T2,
R,
R1,
R2> AsyncFunction<T,R> mapTuple(io.activej.common.tuple.TupleConstructor2<R1,R2,R> constructor,
 Function<? super T,T1> getter1,
 Function<T1,Promise<R1>> fn1,
 Function<? super T,T2> getter2,
 Function<T2,Promise<R2>> fn2)

mapTuple

@Contract(pure=true)
public static <T,
T1,
T2,
T3,
R,
R1,
R2,
R3>
AsyncFunction<T,R> mapTuple(io.activej.common.tuple.TupleConstructor3<R1,R2,R3,R> constructor,
 Function<? super T,T1> getter1,
 Function<T1,Promise<R1>> fn1,
 Function<? super T,T2> getter2,
 Function<T2,Promise<R2>> fn2,
 Function<? super T,T3> getter3,
 Function<T3,Promise<R3>> fn3)

mapTuple

@Contract(pure=true)
public static <T,
T1,
T2,
T3,
T4,
R,
R1,
R2,
R3,
R4>
AsyncFunction<T,R> mapTuple(io.activej.common.tuple.TupleConstructor4<R1,R2,R3,R4,R> constructor,
 Function<? super T,T1> getter1,
 Function<T1,Promise<R1>> fn1,
 Function<? super T,T2> getter2,
 Function<T2,Promise<R2>> fn2,
 Function<? super T,T3> getter3,
 Function<T3,Promise<R3>> fn3,
 Function<? super T,T4> getter4,
 Function<T4,Promise<R4>> fn4)

mapTuple

@Contract(pure=true)
public static <T,
T1,
T2,
T3,
T4,
T5,
R,
R1,
R2,
R3,
R4,
R5>
AsyncFunction<T,R> mapTuple(io.activej.common.tuple.TupleConstructor5<R1,R2,R3,R4,R5,R> constructor,
 Function<? super T,T1> getter1,
 Function<T1,Promise<R1>> fn1,
 Function<? super T,T2> getter2,
 Function<T2,Promise<R2>> fn2,
 Function<? super T,T3> getter3,
 Function<T3,Promise<R3>> fn3,
 Function<? super T,T4> getter4,
 Function<T4,Promise<R4>> fn4,
 Function<? super T,T5> getter5,
 Function<T5,Promise<R5>> fn5)

mapTuple

@Contract(pure=true)
public static <T,
T1,
T2,
T3,
T4,
T5,
T6,
R,
R1,
R2,
R3,
R4,
R5,
R6>
AsyncFunction<T,R> mapTuple(io.activej.common.tuple.TupleConstructor6<R1,R2,R3,R4,R5,R6,R> constructor,
 Function<? super T,T1> getter1,
 Function<T1,Promise<R1>> fn1,
 Function<? super T,T2> getter2,
 Function<T2,Promise<R2>> fn2,
 Function<? super T,T3> getter3,
 Function<T3,Promise<R3>> fn3,
 Function<? super T,T4> getter4,
 Function<T4,Promise<R4>> fn4,
 Function<? super T,T5> getter5,
 Function<T5,Promise<R5>> fn5,
 Function<? super T,T6> getter6,
 Function<T6,Promise<R6>> fn6)

sequence

public static Promise<Void> sequence()

Returns a CompleteNullPromise

sequence

public static Promise<Void> sequence(AsyncRunnable runnable)

Executes an AsyncRunnable, returning a Promise<Void> as a mark for completion

sequence

public static Promise<Void> sequence(AsyncRunnable runnable1,
 AsyncRunnable runnable2)

Executes both AsyncRunnables consequently, returning a Promise<Void> as a mark for completion

sequence

public static Promise<Void> sequence(AsyncRunnable... runnables)

See Also:

• sequence(Iterator)

sequence

public static Promise<Void> sequence(Iterable<? extends AsyncRunnable> runnables)

See Also:

• sequence(Iterator)

sequence

public static Promise<Void> sequence(Stream<? extends AsyncRunnable> runnables)

See Also:

• sequence(Iterator)

sequence

public static Promise<Void> sequence(Iterator<? extends Promise<Void>> promises)

Calls every Promise from promises in sequence and discards their results.Returns a SettablePromise with null result as a marker when all of the promises are completed.

Returns:

Promise that completes when all promises are completed

first

@SafeVarargs
public static <T> Promise<T> first(AsyncSupplier<? extends T>... promises)

Picks the first Promise that was completed without exception.

See Also:

• first(BiPredicate, Iterator)

first

public static <T> Promise<T> first(Iterable<? extends AsyncSupplier<? extends T>> promises)

See Also:

• first(AsyncSupplier[])
• first(BiPredicate, Iterator)

first

public static <T> Promise<T> first(Stream<? extends AsyncSupplier<? extends T>> promises)

See Also:

• first(AsyncSupplier[])
• first(BiPredicate, Iterator)

first

public static <T> Promise<T> first(Iterator<? extends Promise<? extends T>> promises)

See Also:

• first(AsyncSupplier[])
• first(BiPredicate, Iterator)

first

@SafeVarargs
public static <T> Promise<T> first(BiPredicate<? super T,? super Exception> predicate,
 AsyncSupplier<? extends T>... promises)

See Also:

• first(BiPredicate, Iterator)

first

public static <T> Promise<T> first(BiPredicate<? super T,? super Exception> predicate,
 Iterable<? extends AsyncSupplier<? extends T>> promises)

See Also:

• first(BiPredicate, Iterator)

first

public static <T> Promise<T> first(BiPredicate<? super T,? super Exception> predicate,
 Stream<? extends AsyncSupplier<? extends T>> promises)

See Also:

• first(BiPredicate, Iterator)

first

public static <T> Promise<T> first(BiPredicate<? super T,? super Exception> predicate,
 Iterator<? extends Promise<? extends T>> promises)

Parameters:

predicate - filters results, consumes result of Promise

Returns:

first completed result of Promise that satisfies predicate

repeat

public static Promise<Void> repeat(AsyncSupplier<Boolean> supplier)

Repeats the operations of provided AsyncSupplier<Boolean> infinitely, until one of the Promises completes exceptionally or supplier returns a promise of false.

loop

public static <T> Promise<T> loop(@Nullable
 T seed,
 Predicate<T> loopCondition,
 io.activej.common.function.FunctionEx<T,Promise<T>> next)

Repeats provided FunctionEx until can pass Predicate test. Resembles a simple Java for() loop but with async capabilities.

Parameters:

seed - start value

loopCondition - a boolean function which checks if this loop can continue

next - a function applied to the seed, returns Promise

Returns:

SettablePromise with null result if it was completed successfully, otherwise returns a SettablePromise with an exception. In both situations returned Promise is a marker of completion of the loop.

until

public static <T> Promise<T> until(@Nullable
 T seed,
 io.activej.common.function.FunctionEx<T,Promise<T>> next,
 Predicate<T> breakCondition)

retry

public static <T> Promise<T> retry(AsyncSupplier<T> supplier)

retry

public static <T> Promise<T> retry(BiPredicate<? super T,Exception> breakCondition,
 AsyncSupplier<T> supplier)

retry

public static <T> Promise<T> retry(AsyncSupplier<T> supplier,
 RetryPolicy<?> retryPolicy)

retry

public static <T> Promise<T> retry(AsyncSupplier<T> supplier,
 BiPredicate<T,Exception> breakCondition,
 RetryPolicy<?> retryPolicy)

asPromises

public static <T> Iterator<Promise<T>> asPromises(Iterator<? extends AsyncSupplier<? extends T>> tasks)

Transforms a collection of AsyncSupplier tasks to a collection of Promises.

asPromises

public static <T> Iterator<Promise<T>> asPromises(Stream<? extends AsyncSupplier<? extends T>> tasks)

Transforms a Stream of AsyncSupplier tasks to a collection of Promises.

asPromises

public static <T> Iterator<Promise<T>> asPromises(Iterable<? extends AsyncSupplier<? extends T>> tasks)

Transforms an Iterable of AsyncSupplier tasks to a collection of Promises.

asPromises

@SafeVarargs
public static <T> Iterator<Promise<T>> asPromises(AsyncSupplier<? extends T>... tasks)

Transforms an AsyncSupplier tasks to a collection of Promises.

reduce

public static <T,
A,
R> Promise<R> reduce(@Nullable
 A accumulator,
 io.activej.common.function.BiConsumerEx<A,T> combiner,
 io.activej.common.function.FunctionEx<A,R> finisher,
 Collection<Promise<T>> promises)

See Also:

• #reduce(A, BiConsumerEx, FunctionEx, Iterator)

reduce

public static <T,
A,
R> Promise<R> reduce(@Nullable
 A accumulator,
 io.activej.common.function.BiConsumerEx<A,T> combiner,
 io.activej.common.function.FunctionEx<A,R> finisher,
 Stream<Promise<T>> promises)

See Also:

• #reduce(A, BiConsumerEx, FunctionEx, Iterator)

reduce

public static <T,
A,
R> Promise<R> reduce(@Nullable
 A accumulator,
 io.activej.common.function.BiConsumerEx<A,T> combiner,
 io.activej.common.function.FunctionEx<A,R> finisher,
 Iterator<Promise<T>> promises)

Asynchronously reduce Iterator of Promise<T>s into a Promise<R>.

To reduce promises a following arguments should be supplied an accumulator, a combiner, a finisher and an iterator of promises

Reduction principle is somewhat similar to the Collector.of(Supplier, BiConsumer, BinaryOperator, Function, Collector.Characteristics...)

If one of the Promises completes exceptionally, a resulting promise will be completed exceptionally as well.

Type Parameters:

T - type of input elements for this operation

A - type of accumulator of intermediate promise results

R - the result type of the reduction

Parameters:

accumulator - a promise result accumulator that holds intermediate promise results

combiner - a combiner consumer that defines how promise results should be accumulated

finisher - a finisher function that maps an accumulator to a result value

promises - Iterator of Promises

Returns:

a Promise of the accumulated result of the reduction.

reduce

public static <T,
A,
R> Promise<R> reduce(Collector<T,A,R> collector,
 int maxCalls,
 Iterator<Promise<T>> promises)

Asynchronously reduce Iterator of Promise<T>s into a Promise<R> with the help of Collector.

You can control the amount of concurrently running Promises.

If one of the Promises completes exceptionally, a resulting promise will be completed exceptionally as well.

This method is universal and allows implementing app-specific logic.

Type Parameters:

T - type of input elements for this operation

A - type of accumulator of intermediate promise results

R - the result type of the reduction

Parameters:

collector - mutable reduction operation that accumulates input elements into a mutable result container

maxCalls - max number of concurrently running Promises

promises - Iterable of Promises

Returns:

a Promise of the accumulated result of the reduction.

reduce

public static <T,
A,
R> Promise<R> reduce(@Nullable
 A accumulator,
 io.activej.common.function.BiConsumerEx<A,T> combiner,
 io.activej.common.function.FunctionEx<A,R> finisher,
 int maxCalls,
 Iterator<Promise<T>> promises)

Asynchronously reduce Iterator of Promise<T>s into a Promise<R>.

To reduce promises a following arguments should be supplied an accumulator, a combiner, a finisher and an iterator of promises

You can control the amount of concurrently running Promises.

Reduction principle is somewhat similar to the Collector.of(Supplier, BiConsumer, BinaryOperator, Function, Collector.Characteristics...)

If one of the Promises completes exceptionally, a resulting promise will be completed exceptionally as well.

Type Parameters:

T - type of input elements for this operation

A - type of accumulator of intermediate promise results

R - the result type of the reduction

Parameters:

accumulator - a promise result accumulator that holds intermediate promise results

combiner - a combiner consumer that defines how promise results should be accumulated

finisher - a finisher function that maps an accumulator to a result value

maxCalls - max number of concurrently running Promises

promises - Iterator of Promises

Returns:

a Promise of the accumulated result of the reduction.

coalesce

@Contract(pure=true)
public static <T,
A,
R> AsyncFunction<T,R> coalesce(Supplier<A> argumentAccumulatorSupplier,
 BiConsumer<A,T> argumentAccumulatorFn,
 AsyncFunction<A,R> fn)