Uses of Interface
io.activej.promise.Promise

Packages that use Promise

Package	Description
io.activej.async
io.activej.async.file
io.activej.async.function
io.activej.async.process
io.activej.async.service
io.activej.promise
io.activej.promise.jmx

Uses of Promise in io.activej.async

Methods in io.activej.async that return Promise

Modifier and Type	Method	Description
<V, T> Promise<T>	AsyncBuffer.add(BiConsumer<A,V> argumentAccumulator, io.activej.common.function.FunctionEx<R,T> resultExtractor, V argument)
<V> Promise<R>	AsyncBuffer.add(BiConsumer<A,V> argumentAccumulator, V argument)
Promise<Void>	AsyncBuffer.flush()
Promise<A>	AsyncAccumulator.get()
Promise<R>	AsyncBuffer.getBufferedPromise()
Promise<A>	AsyncAccumulator.run()
Promise<A>	AsyncAccumulator.run(Promise<Void> runtimePromise)

Methods in io.activej.async with parameters of type Promise

Modifier and Type	Method	Description
<T> void	AsyncAccumulator.addPromise(Promise<T> promise, io.activej.common.function.BiConsumerEx<A,T> consumer)
Promise<A>	AsyncAccumulator.run(Promise<Void> runtimePromise)
<T> AsyncAccumulator<A>.Builder	AsyncAccumulator.Builder.withPromise(Promise<T> promise, io.activej.common.function.BiConsumerEx<A,T> accumulator)

Uses of Promise in io.activej.async.file

Methods in io.activej.async.file that return Promise

Modifier and Type	Method	Description
Promise<Integer>	ExecutorFileService.read(FileChannel channel, long position, byte[] array, int offset, int size)
Promise<Integer>	IFileService.read(FileChannel channel, long position, byte[] array, int offset, int size)
Promise<Integer>	ExecutorFileService.write(FileChannel channel, long position, byte[] array, int offset, int size)
Promise<Integer>	IFileService.write(FileChannel channel, long position, byte[] array, int offset, int size)

Uses of Promise in io.activej.async.function

Methods in io.activej.async.function that return Promise

Modifier and Type	Method	Description
Promise<Void>	AsyncBiConsumer.accept(T t, U u)
Promise<Void>	AsyncBiConsumerEx.accept(T t, U u)
Promise<Void>	AsyncConsumer.accept(T value)	Consumes some data asynchronously.
Promise<Void>	AsyncConsumerEx.accept(T value)	Consumes some data asynchronously.
Promise<R>	AsyncBiFunction.apply(T t, U u)
Promise<R>	AsyncBiFunctionEx.apply(T t, U u)
Promise<R>	AsyncFunction.apply(T t)
Promise<R>	AsyncFunctionEx.apply(T t)
Promise<T>	AsyncSupplier.get()	Gets Promise of data item asynchronously.
Promise<T>	AsyncSupplierEx.get()	Gets Promise of data item asynchronously.
Promise<Void>	AsyncRunnable.run()
Promise<Void>	AsyncRunnableEx.run()
Promise<Boolean>	AsyncBiPredicate.test(T t, U u)
Promise<Boolean>	AsyncBiPredicateEx.test(T t, U u)
Promise<Boolean>	AsyncPredicate.test(T t)
Promise<Boolean>	AsyncPredicateEx.test(T t)

Uses of Promise in io.activej.async.process

Methods in io.activej.async.process that return Promise

Modifier and Type	Method	Description
default <T> Promise<T>	AsyncExecutor.call(Callable<T> callable)
protected final <T> Promise<T>	AbstractAsyncCloseable.doSanitize(T value, @Nullable Exception e)
<T> Promise<T>	AsyncExecutor.execute(AsyncSupplier<T> supplier)
Promise<Void>	ReactiveProcess.getProcessCompletion()
default Promise<Void>	AsyncExecutor.run(Runnable runnable)
final <T> Promise<T>	AbstractAsyncCloseable.sanitize(Promise<T> promise)
Promise<Void>	ReactiveProcess.startProcess()

Methods in io.activej.async.process with parameters of type Promise

Modifier and Type	Method	Description
final <T> Promise<T>	AbstractAsyncCloseable.sanitize(Promise<T> promise)

Uses of Promise in io.activej.async.service

Methods in io.activej.async.service that return Promise

Modifier and Type	Method	Description
Promise<?>	ReactiveService.start()	Starts this component asynchronously.
Promise<?>	TaskScheduler.start()
Promise<?>	ReactiveService.stop()	Stops this component asynchronously.
Promise<?>	TaskScheduler.stop()

Uses of Promise in io.activej.promise

Classes in io.activej.promise that implement Promise

Modifier and Type	Class	Description
class	AbstractPromise<T>
static final class	AbstractPromise.EitherPromise<T>
static class	AbstractPromise.PromiseBoth<T>
static class	AbstractPromise.PromiseCombine<T,V,U>
final class	CompleteExceptionallyPromise<T>	Represents a Promise which is completed with an exception.
final class	CompleteNullPromise<T>	Represents a CompletePromise with result that equals null.
class	CompletePromise<T>	Represents a completed Promise with a result of unspecified type.
final class	CompleteResultPromise<T>	Represents a CompletePromise with a result of unspecified type.
class	NextPromise<T,R>	Helps to create sequent chains of Promises.
final class	SettablePromise<T>	Represents a Promise which can be completed or completedExceptionally manually at once or later in the future.

Methods in io.activej.promise that return Promise

Modifier and Type	Method	Description
static Promise<Void>	Promises.all()
static Promise<Void>	Promises.all(Promise<?> promise1)
static Promise<Void>	Promises.all(Promise<?>... promises)
static Promise<Void>	Promises.all(Promise<?> promise1, Promise<?> promise2)	Optimized for 2 promises.
static Promise<Void>	Promises.all(Iterator<? extends Promise<?>> promises)	Returns Promise that completes when all of the promises are completed.
static Promise<Void>	Promises.all(List<? extends Promise<?>> promises)	Returns a Promise that completes when all of the promises are completed.
static Promise<Void>	Promises.all(Stream<? extends Promise<?>> promises)
static <T> Promise<T>	Promises.any()	Returns a CompleteExceptionallyPromise with Exception, since this method doesn't accept any Promises
static <T> Promise<T>	Promises.any(Promise<? extends T> promise1)
static <T> Promise<T>	Promises.any(Promise<? extends T>... promises)
static <T> Promise<T>	Promises.any(Promise<? extends T> promise1, Promise<? extends T> promise2)	Optimized for 2 promises.
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, Promise<? extends T> promise1)
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, Promise<? extends T>... promises)
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, Promise<? extends T> promise1, Promise<? extends T> promise2)
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, List<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, Stream<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.any(Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.any(List<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.any(Stream<? extends Promise<? extends T>> promises)
Promise<T>	AbstractPromise.async()
Promise<T>	CompleteExceptionallyPromise.async()
final Promise<T>	CompletePromise.async()
Promise<T>	Promise.async()	Ensures that Promise completes asynchronously: if this Promise is already completed, its completion will be posted to the next reactor tick.
Promise<Void>	AbstractPromise.both(Promise<?> other)
Promise<Void>	CompleteExceptionallyPromise.both(Promise<?> other)
final Promise<Void>	CompletePromise.both(Promise<?> other)
Promise<Void>	Promise.both(Promise<?> other)	Returns a new Promise when both this and provided other Promises complete.
default <U> Promise<U>	Promise.cast()	Casts this promise to a promise of some other type Promise
default <U> Promise<U>	Promise.cast(Class<? extends U> cls)	Casts this promise to a promise of some other type Promise
<U, V> Promise<V>	AbstractPromise.combine(Promise<? extends U> other, io.activej.common.function.BiFunctionEx<? super T,? super U,? extends V> fn)
<U, V> Promise<V>	CompleteExceptionallyPromise.combine(Promise<? extends U> other, io.activej.common.function.BiFunctionEx<? super T,? super U,? extends V> fn)
final <U, V> Promise<V>	CompletePromise.combine(Promise<? extends U> other, io.activej.common.function.BiFunctionEx<? super T,? super U,? extends V> fn)
<U, V> Promise<V>	Promise.combine(Promise<? extends U> other, io.activej.common.function.BiFunctionEx<? super T,? super U,? extends V> fn)	Returns a new Promise that, when this and the other given Promise both complete, is executed with the two results as arguments to the supplied function.
static Promise<Void>	Promise.complete()	Creates successfully completed Promise
static Promise<Void>	Promises.delay(long delayMillis)
static <T> Promise<T>	Promises.delay(long delayMillis, Promise<T> promise)	Delays completion of provided promise for the defined period of time.
static <T> Promise<T>	Promises.delay(long delayMillis, T value)
static Promise<Void>	Promises.delay(ReactorScheduler reactor, long delayMillis)
static <T> Promise<T>	Promises.delay(ReactorScheduler reactor, long delayMillis, Promise<T> promise)
static <T> Promise<T>	Promises.delay(ReactorScheduler reactor, long delayMillis, T value)
static Promise<Void>	Promises.delay(ReactorScheduler reactor, Duration delay)
static <T> Promise<T>	Promises.delay(ReactorScheduler reactor, Duration delay, Promise<T> promise)
static <T> Promise<T>	Promises.delay(ReactorScheduler reactor, Duration delay, T value)
static Promise<Void>	Promises.delay(Duration delay)
static <T> Promise<T>	Promises.delay(Duration delay, Promise<T> promise)
static <T> Promise<T>	Promises.delay(Duration delay, T value)
Promise<T>	AbstractPromise.either(Promise<? extends T> other)
Promise<T>	CompleteExceptionallyPromise.either(Promise<? extends T> other)
final Promise<T>	CompletePromise.either(Promise<? extends T> other)
Promise<T>	Promise.either(Promise<? extends T> other)	Returns the Promise which was completed first.
static <T> Promise<T>	Promises.first(AsyncSupplier<? extends T>... promises)	Picks the first Promise that was completed without exception.
static <T> Promise<T>	Promises.first(Iterable<? extends AsyncSupplier<? extends T>> promises)
static <T> Promise<T>	Promises.first(BiPredicate<? super T,? super Exception> predicate, AsyncSupplier<? extends T>... promises)
static <T> Promise<T>	Promises.first(BiPredicate<? super T,? super Exception> predicate, Iterable<? extends AsyncSupplier<? extends T>> promises)
static <T> Promise<T>	Promises.first(BiPredicate<? super T,? super Exception> predicate, Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.first(BiPredicate<? super T,? super Exception> predicate, Stream<? extends AsyncSupplier<? extends T>> promises)
static <T> Promise<T>	Promises.first(Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.first(Stream<? extends AsyncSupplier<? extends T>> promises)
Promise<V>	ResultWithPromise.getPromise()
static <T> Promise<T>	Promises.interval(long intervalMillis, Promise<T> promise)
static <T> Promise<T>	Promises.interval(ReactorScheduler reactor, long intervalMillis, Promise<T> promise)
static <T> Promise<T>	Promises.interval(ReactorScheduler reactor, Duration interval, Promise<T> promise)
static <T> Promise<T>	Promises.interval(Duration interval, Promise<T> promise)
static <T> Promise<T>	Promises.loop(T seed, Predicate<T> loopCondition, io.activej.common.function.FunctionEx<T,Promise<T>> next)	Repeats provided FunctionEx until can pass Predicate test.
<U> Promise<U>	AbstractPromise.map(io.activej.common.function.BiFunctionEx<? super T,Exception,? extends U> fn)
<U> Promise<U>	AbstractPromise.map(io.activej.common.function.FunctionEx<? super T,? extends U> fn)
<U> Promise<U>	AbstractPromise.map(io.activej.common.function.FunctionEx<? super T,? extends U> fn, io.activej.common.function.FunctionEx<Exception,? extends U> exceptionFn)
<U> Promise<U>	CompleteExceptionallyPromise.map(io.activej.common.function.BiFunctionEx<? super T,Exception,? extends U> fn)
<U> Promise<U>	CompleteExceptionallyPromise.map(io.activej.common.function.FunctionEx<? super T,? extends U> fn)
<U> Promise<U>	CompleteExceptionallyPromise.map(io.activej.common.function.FunctionEx<? super T,? extends U> fn, io.activej.common.function.FunctionEx<Exception,? extends U> exceptionFn)
final <U> Promise<U>	CompletePromise.map(io.activej.common.function.BiFunctionEx<? super T,Exception,? extends U> fn)
final <U> Promise<U>	CompletePromise.map(io.activej.common.function.FunctionEx<? super T,? extends U> fn)
<U> Promise<U>	CompletePromise.map(io.activej.common.function.FunctionEx<? super T,? extends U> fn, io.activej.common.function.FunctionEx<Exception,? extends U> exceptionFn)
default <U> Promise<U>	Promise.map(io.activej.common.function.BiFunctionEx<? super T,@Nullable Exception,? extends U> fn)	Returns a new Promise which is obtained by mapping a result and an exception of this promise to some other value.
default <U> Promise<U>	Promise.map(io.activej.common.function.FunctionEx<? super T,? extends U> fn)	Returns a new Promise which is obtained by mapping a result of this promise to some other value.
default <U> Promise<U>	Promise.map(io.activej.common.function.FunctionEx<? super T,? extends U> fn, io.activej.common.function.FunctionEx<Exception,? extends U> exceptionFn)	Returns a new Promise which is obtained by mapping either a result or an exception of this promise to some other values.
Promise<T>	AbstractPromise.mapException(io.activej.common.function.FunctionEx<Exception,Exception> exceptionFn)
<E extends Exception> Promise<T>	AbstractPromise.mapException(Class<E> clazz, io.activej.common.function.FunctionEx<? super E,? extends Exception> exceptionFn)
Promise<T>	CompleteExceptionallyPromise.mapException(io.activej.common.function.FunctionEx<Exception,Exception> exceptionFn)
<E extends Exception> Promise<T>	CompleteExceptionallyPromise.mapException(Class<E> clazz, io.activej.common.function.FunctionEx<? super E,? extends Exception> exceptionFn)
Promise<T>	CompletePromise.mapException(io.activej.common.function.FunctionEx<Exception,Exception> exceptionFn)
<E extends Exception> Promise<T>	CompletePromise.mapException(Class<E> clazz, io.activej.common.function.FunctionEx<? super E,? extends Exception> exceptionFn)
default Promise<T>	Promise.mapException(io.activej.common.function.FunctionEx<Exception,Exception> exceptionFn)	Returns a new Promise which is obtained by mapping an exception of this promise to some other exception.
default <E extends Exception> Promise<T>	Promise.mapException(Class<E> clazz, io.activej.common.function.FunctionEx<? super E,? extends Exception> exceptionFn)	Returns a new Promise which is obtained by mapping an exception of this promise to some other exception.
static <T> Promise<T>	Promise.of(T value)	Creates successfully completed Promise.
static <T> Promise<T>	Promise.of(T value, @Nullable Exception e)	Creates a completed Promise from T value and Exception e parameters, any of them can be null.
static Promise<Void>	Promise.ofBlocking(Executor executor, io.activej.common.function.RunnableEx runnable)	Same as ofBlocking(Executor, SupplierEx), but without a result (returned Promise is only a marker of completion).
static <T> Promise<T>	Promise.ofBlocking(Executor executor, io.activej.common.function.SupplierEx<? extends T> supplier)	Runs some task in another thread (executed by a given Executor) and returns a Promise for it.
static <T> Promise<T>	Promise.ofCallback(CallbackSupplierEx<T> fn)	Creates and returns a new SettablePromise that is accepted by the provided ConsumerEx of SettablePromise
static <T, R> Promise<R>	Promise.ofCallback(T value, @Nullable Exception exception, CallbackBiFunctionEx<? super T,@Nullable Exception,R> fn)
static <T, R> Promise<R>	Promise.ofCallback(T value, @Nullable Exception exception, CallbackFunctionEx<? super T,R> fn, CallbackFunctionEx<Exception,R> fnException)
static <T, R> Promise<R>	Promise.ofCallback(T value, CallbackFunctionEx<? super T,R> fn)
static <T> Promise<T>	Promise.ofCompletionStage(CompletionStage<? extends T> completionStage)	Wraps Java CompletionStage in a Promise, running it in current reactor.
static <T> Promise<T>	Promise.ofException(Exception e)	Creates an exceptionally completed Promise.
static <T> Promise<T>	Promise.ofFuture(CompletableFuture<? extends T> future)	Creates a Promise wrapper around default Java CompletableFuture and runs it immediately.
static <T> Promise<T>	Promise.ofFuture(Executor executor, Future<? extends T> future)	Wraps Java Future in a Promise running it with given Executor.
static <T> Promise<T>	Promise.ofOptional(Optional<T> optional)	Creates a new Promise of the given value
static <T> Promise<T>	Promise.ofOptional(Optional<T> optional, Supplier<? extends Exception> errorSupplier)	Creates a new Promise of the given value.
static <T> Promise<T>	Promise.ofTry(io.activej.common.collection.Try<T> t)	Returns a new CompletePromise or CompleteExceptionallyPromise based on the provided Try.
static <T, A, R> Promise<R>	Promises.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>	Promises.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>	Promises.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>	Promises.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>	Promises.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>	Promises.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>	Promises.retry(AsyncSupplier<T> supplier)
static <T> Promise<T>	Promises.retry(AsyncSupplier<T> supplier, RetryPolicy<?> retryPolicy)
static <T> Promise<T>	Promises.retry(AsyncSupplier<T> supplier, BiPredicate<T,Exception> breakCondition, RetryPolicy<?> retryPolicy)
static <T> Promise<T>	Promises.retry(BiPredicate<? super T,Exception> breakCondition, AsyncSupplier<T> supplier)
static Promise<Void>	Promises.schedule(long timestamp)
static <T> Promise<T>	Promises.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>	Promises.schedule(long timestamp, T value)
static Promise<Void>	Promises.schedule(ReactorScheduler reactor, long timestamp)
static <T> Promise<T>	Promises.schedule(ReactorScheduler reactor, long timestamp, Promise<T> promise)
static <T> Promise<T>	Promises.schedule(ReactorScheduler reactor, long timestamp, T value)
static Promise<Void>	Promises.schedule(ReactorScheduler reactor, Instant instant)
static <T> Promise<T>	Promises.schedule(ReactorScheduler reactor, Instant instant, Promise<T> promise)
static <T> Promise<T>	Promises.schedule(ReactorScheduler reactor, Instant instant, T value)
static Promise<Void>	Promises.schedule(Instant instant)
static <T> Promise<T>	Promises.schedule(Instant instant, Promise<T> promise)
static <T> Promise<T>	Promises.schedule(Instant instant, T value)
static Promise<Void>	Promises.sequence()	Returns a CompleteNullPromise
static Promise<Void>	Promises.sequence(AsyncRunnable runnable)	Executes an AsyncRunnable, returning a Promise<Void> as a mark for completion
static Promise<Void>	Promises.sequence(AsyncRunnable... runnables)
static Promise<Void>	Promises.sequence(AsyncRunnable runnable1, AsyncRunnable runnable2)	Executes both AsyncRunnables consequently, returning a Promise<Void> as a mark for completion
static Promise<Void>	Promises.sequence(Iterable<? extends AsyncRunnable> runnables)
static Promise<Void>	Promises.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>	Promises.sequence(Stream<? extends AsyncRunnable> runnables)
Promise<T>	AbstractPromise.subscribe(Callback<? super T> cb)
Promise<T>	CompleteExceptionallyPromise.subscribe(Callback<? super T> cb)
Promise<T>	CompletePromise.subscribe(Callback<? super T> cb)
Promise<T>	Promise.subscribe(Callback<? super T> cb)
<U> Promise<U>	AbstractPromise.then(AsyncBiFunctionEx<? super T,Exception,U> fn)
<U> Promise<U>	AbstractPromise.then(AsyncFunctionEx<? super T,U> fn)
<U> Promise<U>	AbstractPromise.then(AsyncFunctionEx<? super T,U> fn, AsyncFunctionEx<Exception,U> exceptionFn)
<U> Promise<U>	AbstractPromise.then(AsyncSupplierEx<U> fn)
<U> Promise<U>	CompleteExceptionallyPromise.then(AsyncBiFunctionEx<? super T,Exception,U> fn)
<U> Promise<U>	CompleteExceptionallyPromise.then(AsyncFunctionEx<? super T,U> fn)
<U> Promise<U>	CompleteExceptionallyPromise.then(AsyncFunctionEx<? super T,U> fn, AsyncFunctionEx<Exception,U> exceptionFn)
<U> Promise<U>	CompleteExceptionallyPromise.then(AsyncSupplierEx<U> fn)
final <U> Promise<U>	CompletePromise.then(AsyncBiFunctionEx<? super T,Exception,U> fn)
final <U> Promise<U>	CompletePromise.then(AsyncFunctionEx<? super T,U> fn)
<U> Promise<U>	CompletePromise.then(AsyncFunctionEx<? super T,U> fn, AsyncFunctionEx<Exception,U> exceptionFn)
<U> Promise<U>	CompletePromise.then(AsyncSupplierEx<U> fn)
default <U> Promise<U>	Promise.then(AsyncBiFunctionEx<? super T,@Nullable Exception,U> fn)	Returns a new Promise which is obtained by mapping a result and an exception of this promise to some other promise.
default <U> Promise<U>	Promise.then(AsyncFunctionEx<? super T,U> fn)	Returns a new Promise which is obtained by mapping a result of this promise to some other promise.
default <U> Promise<U>	Promise.then(AsyncFunctionEx<? super T,U> fn, AsyncFunctionEx<Exception,U> exceptionFn)	Returns a new Promise which is obtained by mapping either a result or an exception of this promise to some other promises.
default <U> Promise<U>	Promise.then(AsyncSupplierEx<U> fn)	Returns a new Promise which is obtained by calling a provided supplier of a new promise.
<U> Promise<U>	AbstractPromise.thenCallback(CallbackBiFunctionEx<? super T,@Nullable Exception,U> fn)
<U> Promise<U>	AbstractPromise.thenCallback(CallbackFunctionEx<? super T,U> fn)
<U> Promise<U>	AbstractPromise.thenCallback(CallbackFunctionEx<? super T,U> fn, CallbackFunctionEx<Exception,U> exceptionFn)
<U> Promise<U>	AbstractPromise.thenCallback(CallbackSupplierEx<U> fn)
<U> Promise<U>	CompleteExceptionallyPromise.thenCallback(CallbackBiFunctionEx<? super T,@Nullable Exception,U> fn)
<U> Promise<U>	CompleteExceptionallyPromise.thenCallback(CallbackFunctionEx<? super T,U> fn)
<U> Promise<U>	CompleteExceptionallyPromise.thenCallback(CallbackFunctionEx<? super T,U> fn, CallbackFunctionEx<Exception,U> exceptionFn)
<U> Promise<U>	CompleteExceptionallyPromise.thenCallback(CallbackSupplierEx<U> fn)
<U> Promise<U>	CompletePromise.thenCallback(CallbackBiFunctionEx<? super T,@Nullable Exception,U> fn)
<U> Promise<U>	CompletePromise.thenCallback(CallbackFunctionEx<? super T,U> fn)
<U> Promise<U>	CompletePromise.thenCallback(CallbackFunctionEx<? super T,U> fn, CallbackFunctionEx<Exception,U> exceptionFn)
<U> Promise<U>	CompletePromise.thenCallback(CallbackSupplierEx<U> fn)
<U> Promise<U>	Promise.thenCallback(CallbackBiFunctionEx<? super T,@Nullable Exception,U> fn)
default <U> Promise<U>	Promise.thenCallback(CallbackFunctionEx<? super T,U> fn)
default <U> Promise<U>	Promise.thenCallback(CallbackFunctionEx<? super T,U> fn, CallbackFunctionEx<Exception,U> exceptionFn)
default <U> Promise<U>	Promise.thenCallback(CallbackSupplierEx<U> fn)
static <T> Promise<T>	Promises.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>	Promises.timeout(ReactorScheduler reactor, long delay, Promise<T> promise)
static <T> Promise<T>	Promises.timeout(ReactorScheduler reactor, Duration delay, Promise<T> promise)
static <T> Promise<T>	Promises.timeout(Duration delay, Promise<T> promise)
static <T> Promise<T[]>	Promises.toArray(Class<T> type)	Returns an array of provided type and length 0 wrapped in Promise.
static <T> Promise<T[]>	Promises.toArray(Class<T> type, Promise<? extends T> promise1)	Returns an array with promise1 result.
static <T> Promise<T[]>	Promises.toArray(Class<T> type, Promise<? extends T>... promises)
static <T> Promise<T[]>	Promises.toArray(Class<T> type, Promise<? extends T> promise1, Promise<? extends T> promise2)	Returns an array with promise1 and promise2 results.
static <T> Promise<T[]>	Promises.toArray(Class<T> type, Iterable<? extends Promise<? extends T>> promises)
static <T> Promise<T[]>	Promises.toArray(Class<T> type, Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T[]>	Promises.toArray(Class<T> type, List<? extends Promise<? extends T>> promises)	Reduces promises into Promise<Array>
static <T> Promise<T[]>	Promises.toArray(Class<T> type, Stream<? extends Promise<? extends T>> promises)
static <T> Promise<List<T>>	Promises.toList()	Returns a successfully completed Promise with an empty list as the result.
static <T> Promise<List<T>>	Promises.toList(Promise<? extends T> promise1)	Returns a completed Promise with a result wrapped in List.
static <T> Promise<List<T>>	Promises.toList(Promise<? extends T>... promises)
static <T> Promise<List<T>>	Promises.toList(Promise<? extends T> promise1, Promise<? extends T> promise2)	Returns Promise with a list of promise1 and promise2 results.
static <T> Promise<List<T>>	Promises.toList(Iterable<? extends Promise<? extends T>> promises)
static <T> Promise<List<T>>	Promises.toList(Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<List<T>>	Promises.toList(List<? extends Promise<? extends T>> promises)	Reduces list of Promises into Promise<List>.
static <T> Promise<List<T>>	Promises.toList(Stream<? extends Promise<? extends T>> promises)
Promise<T>	ToPromise.toPromise()
Promise<io.activej.common.collection.Try<T>>	AbstractPromise.toTry()
Promise<io.activej.common.collection.Try<T>>	CompleteExceptionallyPromise.toTry()
final Promise<io.activej.common.collection.Try<T>>	CompletePromise.toTry()
Promise<io.activej.common.collection.Try<T>>	Promise.toTry()	Returns Promise that always completes successfully with result or exception wrapped in Try.
static <T1, R> Promise<R>	Promises.toTuple(io.activej.common.tuple.TupleConstructor1<T1,R> constructor, Promise<? extends T1> promise1)
static <T1, T2, R> Promise<R>	Promises.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>	Promises.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>	Promises.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>	Promises.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>	Promises.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>>	Promises.toTuple(Promise<? extends T1> promise1)
static <T1, T2> Promise<io.activej.common.tuple.Tuple2<T1,T2>>	Promises.toTuple(Promise<? extends T1> promise1, Promise<? extends T2> promise2)
static <T1, T2, T3> Promise<io.activej.common.tuple.Tuple3<T1,T2,T3>>	Promises.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>>	Promises.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>>	Promises.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>>	Promises.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)
Promise<Void>	AbstractPromise.toVoid()
Promise<Void>	CompleteExceptionallyPromise.toVoid()
final Promise<Void>	CompletePromise.toVoid()
Promise<Void>	Promise.toVoid()	Waits for result and discards it.
static <T> Promise<T>	Promises.until(T seed, io.activej.common.function.FunctionEx<T,Promise<T>> next, Predicate<T> breakCondition)
Promise<T>	AbstractPromise.whenComplete(io.activej.common.function.BiConsumerEx<? super T,Exception> fn)
Promise<T>	AbstractPromise.whenComplete(io.activej.common.function.ConsumerEx<? super T> fn, io.activej.common.function.ConsumerEx<Exception> exceptionFn)
Promise<T>	AbstractPromise.whenComplete(io.activej.common.function.RunnableEx action)
Promise<T>	CompleteExceptionallyPromise.whenComplete(io.activej.common.function.BiConsumerEx<? super T,Exception> fn)
Promise<T>	CompleteExceptionallyPromise.whenComplete(io.activej.common.function.ConsumerEx<? super T> fn, io.activej.common.function.ConsumerEx<Exception> exceptionFn)
Promise<T>	CompleteExceptionallyPromise.whenComplete(io.activej.common.function.RunnableEx action)
Promise<T>	CompletePromise.whenComplete(io.activej.common.function.BiConsumerEx<? super T,Exception> fn)
Promise<T>	CompletePromise.whenComplete(io.activej.common.function.ConsumerEx<? super T> fn, io.activej.common.function.ConsumerEx<Exception> exceptionFn)
Promise<T>	CompletePromise.whenComplete(io.activej.common.function.RunnableEx action)
default Promise<T>	Promise.whenComplete(io.activej.common.function.BiConsumerEx<? super T,Exception> fn)	Subscribes given consumer to be executed after this Promise completes (either successfully or exceptionally).
default Promise<T>	Promise.whenComplete(io.activej.common.function.ConsumerEx<? super T> fn, io.activej.common.function.ConsumerEx<Exception> exceptionFn)	Subscribes given consumers to be executed after this Promise completes (either successfully or exceptionally).
default Promise<T>	Promise.whenComplete(io.activej.common.function.RunnableEx action)	Subscribes given runnable to be executed after this Promise completes (either successfully or exceptionally).
Promise<T>	AbstractPromise.whenException(io.activej.common.function.ConsumerEx<Exception> fn)
Promise<T>	AbstractPromise.whenException(io.activej.common.function.RunnableEx action)
Promise<T>	AbstractPromise.whenException(Class<? extends Exception> clazz, io.activej.common.function.RunnableEx action)
<E extends Exception> Promise<T>	AbstractPromise.whenException(Class<E> clazz, io.activej.common.function.ConsumerEx<? super E> fn)
Promise<T>	CompleteExceptionallyPromise.whenException(io.activej.common.function.ConsumerEx<Exception> fn)
Promise<T>	CompleteExceptionallyPromise.whenException(io.activej.common.function.RunnableEx action)
Promise<T>	CompleteExceptionallyPromise.whenException(Class<? extends Exception> clazz, io.activej.common.function.RunnableEx action)
<E extends Exception> Promise<T>	CompleteExceptionallyPromise.whenException(Class<E> clazz, io.activej.common.function.ConsumerEx<? super E> fn)
Promise<T>	CompletePromise.whenException(io.activej.common.function.ConsumerEx<Exception> fn)
Promise<T>	CompletePromise.whenException(io.activej.common.function.RunnableEx action)
Promise<T>	CompletePromise.whenException(Class<? extends Exception> clazz, io.activej.common.function.RunnableEx action)
<E extends Exception> Promise<T>	CompletePromise.whenException(Class<E> clazz, io.activej.common.function.ConsumerEx<? super E> fn)
default Promise<T>	Promise.whenException(io.activej.common.function.ConsumerEx<Exception> fn)	Subscribes given consumer to be executed after this Promise completes exceptionally.
default Promise<T>	Promise.whenException(io.activej.common.function.RunnableEx action)	Subscribes given runnable to be executed after this Promise completes exceptionally.
default Promise<T>	Promise.whenException(Class<? extends Exception> clazz, io.activej.common.function.RunnableEx action)	Subscribes given runnable to be executed after this Promise completes exceptionally and an exception of this Promise is an instance of a given exception Class.
default <E extends Exception> Promise<T>	Promise.whenException(Class<E> clazz, io.activej.common.function.ConsumerEx<? super E> fn)	Subscribes given consumer to be executed after this Promise completes exceptionally and an exception of this Promise is an instance of a given exception Class.
Promise<T>	AbstractPromise.whenResult(io.activej.common.function.ConsumerEx<? super T> fn)
Promise<T>	AbstractPromise.whenResult(io.activej.common.function.RunnableEx action)
Promise<T>	CompleteExceptionallyPromise.whenResult(io.activej.common.function.ConsumerEx<? super T> fn)
Promise<T>	CompleteExceptionallyPromise.whenResult(io.activej.common.function.RunnableEx action)
Promise<T>	CompletePromise.whenResult(io.activej.common.function.ConsumerEx<? super T> fn)
Promise<T>	CompletePromise.whenResult(io.activej.common.function.RunnableEx action)
default Promise<T>	Promise.whenResult(io.activej.common.function.ConsumerEx<? super T> fn)	Subscribes given consumer to be executed after this Promise completes successfully.
default Promise<T>	Promise.whenResult(io.activej.common.function.RunnableEx action)	Subscribes given runnable to be executed after this Promise completes successfully and a result of this Promise satisfy a given Predicate.

Methods in io.activej.promise that return types with arguments of type Promise

Modifier and Type	Method	Description
static <T> Iterator<Promise<T>>	Promises.asPromises(AsyncSupplier<? extends T>... tasks)	Transforms an AsyncSupplier tasks to a collection of Promises.
static <T> Iterator<Promise<T>>	Promises.asPromises(Iterable<? extends AsyncSupplier<? extends T>> tasks)	Transforms an Iterable of AsyncSupplier tasks to a collection of Promises.
static <T> Iterator<Promise<T>>	Promises.asPromises(Iterator<? extends AsyncSupplier<? extends T>> tasks)	Transforms a collection of AsyncSupplier tasks to a collection of Promises.
static <T> Iterator<Promise<T>>	Promises.asPromises(Stream<? extends AsyncSupplier<? extends T>> tasks)	Transforms a Stream of AsyncSupplier tasks to a collection of Promises.

Methods in io.activej.promise with parameters of type Promise

Modifier and Type	Method	Description
static Promise<Void>	Promises.all(Promise<?> promise1)
static Promise<Void>	Promises.all(Promise<?>... promises)
static Promise<Void>	Promises.all(Promise<?> promise1, Promise<?> promise2)	Optimized for 2 promises.
static <T> Promise<T>	Promises.any(Promise<? extends T> promise1)
static <T> Promise<T>	Promises.any(Promise<? extends T>... promises)
static <T> Promise<T>	Promises.any(Promise<? extends T> promise1, Promise<? extends T> promise2)	Optimized for 2 promises.
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, Promise<? extends T> promise1)
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, Promise<? extends T>... promises)
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, Promise<? extends T> promise1, Promise<? extends T> promise2)
static <T> T	TestUtils.await(Promise<T> promise)
static <T> Void	TestUtils.await(Promise<T>... promises)
static <T, E extends Exception> E	TestUtils.awaitException(Promise<T> promise)
static <T, E extends Exception> E	TestUtils.awaitException(Promise<T>... promises)
Promise<Void>	AbstractPromise.both(Promise<?> other)
Promise<Void>	CompleteExceptionallyPromise.both(Promise<?> other)
final Promise<Void>	CompletePromise.both(Promise<?> other)
Promise<Void>	Promise.both(Promise<?> other)	Returns a new Promise when both this and provided other Promises complete.
<U, V> Promise<V>	AbstractPromise.combine(Promise<? extends U> other, io.activej.common.function.BiFunctionEx<? super T,? super U,? extends V> fn)
<U, V> Promise<V>	CompleteExceptionallyPromise.combine(Promise<? extends U> other, io.activej.common.function.BiFunctionEx<? super T,? super U,? extends V> fn)
final <U, V> Promise<V>	CompletePromise.combine(Promise<? extends U> other, io.activej.common.function.BiFunctionEx<? super T,? super U,? extends V> fn)
<U, V> Promise<V>	Promise.combine(Promise<? extends U> other, io.activej.common.function.BiFunctionEx<? super T,? super U,? extends V> fn)	Returns a new Promise that, when this and the other given Promise both complete, is executed with the two results as arguments to the supplied function.
static <T> Promise<T>	Promises.delay(long delayMillis, Promise<T> promise)	Delays completion of provided promise for the defined period of time.
static <T> Promise<T>	Promises.delay(ReactorScheduler reactor, long delayMillis, Promise<T> promise)
static <T> Promise<T>	Promises.delay(ReactorScheduler reactor, Duration delay, Promise<T> promise)
static <T> Promise<T>	Promises.delay(Duration delay, Promise<T> promise)
Promise<T>	AbstractPromise.either(Promise<? extends T> other)
Promise<T>	CompleteExceptionallyPromise.either(Promise<? extends T> other)
final Promise<T>	CompletePromise.either(Promise<? extends T> other)
Promise<T>	Promise.either(Promise<? extends T> other)	Returns the Promise which was completed first.
static <T> Promise<T>	Promises.interval(long intervalMillis, Promise<T> promise)
static <T> Promise<T>	Promises.interval(ReactorScheduler reactor, long intervalMillis, Promise<T> promise)
static <T> Promise<T>	Promises.interval(ReactorScheduler reactor, Duration interval, Promise<T> promise)
static <T> Promise<T>	Promises.interval(Duration interval, Promise<T> promise)
static <T, V> ResultWithPromise<T,V>	ResultWithPromise.of(T result, Promise<V> promise)
static <T> Promise<T>	Promises.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>	Promises.schedule(ReactorScheduler reactor, long timestamp, Promise<T> promise)
static <T> Promise<T>	Promises.schedule(ReactorScheduler reactor, Instant instant, Promise<T> promise)
static <T> Promise<T>	Promises.schedule(Instant instant, Promise<T> promise)
static <T> Promise<T>	Promises.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>	Promises.timeout(ReactorScheduler reactor, long delay, Promise<T> promise)
static <T> Promise<T>	Promises.timeout(ReactorScheduler reactor, Duration delay, Promise<T> promise)
static <T> Promise<T>	Promises.timeout(Duration delay, Promise<T> promise)
static <T> Promise<T[]>	Promises.toArray(Class<T> type, Promise<? extends T> promise1)	Returns an array with promise1 result.
static <T> Promise<T[]>	Promises.toArray(Class<T> type, Promise<? extends T>... promises)
static <T> Promise<T[]>	Promises.toArray(Class<T> type, Promise<? extends T> promise1, Promise<? extends T> promise2)	Returns an array with promise1 and promise2 results.
static <T> Promise<List<T>>	Promises.toList(Promise<? extends T> promise1)	Returns a completed Promise with a result wrapped in List.
static <T> Promise<List<T>>	Promises.toList(Promise<? extends T>... promises)
static <T> Promise<List<T>>	Promises.toList(Promise<? extends T> promise1, Promise<? extends T> promise2)	Returns Promise with a list of promise1 and promise2 results.
static <T1, R> Promise<R>	Promises.toTuple(io.activej.common.tuple.TupleConstructor1<T1,R> constructor, Promise<? extends T1> promise1)
static <T1, T2, R> Promise<R>	Promises.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>	Promises.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>	Promises.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>	Promises.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>	Promises.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>>	Promises.toTuple(Promise<? extends T1> promise1)
static <T1, T2> Promise<io.activej.common.tuple.Tuple2<T1,T2>>	Promises.toTuple(Promise<? extends T1> promise1, Promise<? extends T2> promise2)
static <T1, T2, T3> Promise<io.activej.common.tuple.Tuple3<T1,T2,T3>>	Promises.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>>	Promises.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>>	Promises.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>>	Promises.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)

Method parameters in io.activej.promise with type arguments of type Promise

Modifier and Type	Method	Description
static Promise<Void>	Promises.all(Iterator<? extends Promise<?>> promises)	Returns Promise that completes when all of the promises are completed.
static Promise<Void>	Promises.all(List<? extends Promise<?>> promises)	Returns a Promise that completes when all of the promises are completed.
static Promise<Void>	Promises.all(Stream<? extends Promise<?>> promises)
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, List<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.any(BiPredicate<? super T,Exception> predicate, Stream<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.any(Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.any(List<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.any(Stream<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.first(BiPredicate<? super T,? super Exception> predicate, Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.first(Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.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, A, R> Promise<R>	Promises.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>	Promises.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>	Promises.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>	Promises.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>	Promises.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>	Promises.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 <T> Promise<T[]>	Promises.toArray(Class<T> type, Iterable<? extends Promise<? extends T>> promises)
static <T> Promise<T[]>	Promises.toArray(Class<T> type, Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<T[]>	Promises.toArray(Class<T> type, List<? extends Promise<? extends T>> promises)	Reduces promises into Promise<Array>
static <T> Promise<T[]>	Promises.toArray(Class<T> type, Stream<? extends Promise<? extends T>> promises)
static <T> Promise<List<T>>	Promises.toList(Iterable<? extends Promise<? extends T>> promises)
static <T> Promise<List<T>>	Promises.toList(Iterator<? extends Promise<? extends T>> promises)
static <T> Promise<List<T>>	Promises.toList(List<? extends Promise<? extends T>> promises)	Reduces list of Promises into Promise<List>.
static <T> Promise<List<T>>	Promises.toList(Stream<? extends Promise<? extends T>> promises)
static <T> Promise<T>	Promises.until(T seed, io.activej.common.function.FunctionEx<T,Promise<T>> next, Predicate<T> breakCondition)

Uses of Promise in io.activej.promise.jmx

Methods in io.activej.promise.jmx that return Promise

Modifier and Type	Method	Description
<T> Promise<T>	PromiseStats.monitor(Promise<T> promise)

Methods in io.activej.promise.jmx with parameters of type Promise

Modifier and Type	Method	Description
<T> Promise<T>	PromiseStats.monitor(Promise<T> promise)