java.lang.Object
- io.activej.promise.Promises

public final class Promises
extends Object

Allows to manage multiple Promises.

Constructor Summary

Constructors
Constructor Description

Promises()

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static @NotNull Promise<Void>`	`all()`
`static @NotNull Promise<Void>`	`all(@NotNull Promise<?> promise1)`
`static @NotNull Promise<Void>`	`all(@NotNull Promise<?>... promises)`
`static @NotNull Promise<Void>`	`all(@NotNull Promise<?> promise1, @NotNull Promise<?> promise2)`	Optimized for 2 promises.
`static @NotNull Promise<Void>`	`all(@NotNull Iterator<? extends Promise<?>> promises)`	Returns `Promise` that completes when all of the `promises` are completed.
`static @NotNull Promise<Void>`	`all(@NotNull List<? extends Promise<?>> promises)`	Returns a `Promise` that completes when all of the `promises` are completed.
`static @NotNull Promise<Void>`	`all(@NotNull Stream<? extends Promise<?>> promises)`
`static <T> @NotNull Promise<T>`	`any()`	Returns a `CompleteExceptionallyPromise` with `Exception`, since this method doesn't accept any `Promise`s
`static <T> @NotNull Promise<T>`	`any(@NotNull Promise<? extends T> promise1)`
`static <T> @NotNull Promise<T>`	`any(@NotNull Promise<? extends T>... promises)`
`static <T> @NotNull Promise<T>`	`any(@NotNull Promise<? extends T> promise1, @NotNull Promise<? extends T> promise2)`	Optimized for 2 promises.
`static <T> @NotNull Promise<T>`	`any(@NotNull BiPredicate<T,Throwable> predicate, @NotNull Promise<? extends T> promise1)`
`static <T> @NotNull Promise<T>`	`any(@NotNull BiPredicate<T,Throwable> predicate, @NotNull Promise<? extends T>... promises)`
`static <T> @NotNull Promise<T>`	`any(@NotNull BiPredicate<T,Throwable> predicate, @NotNull Promise<? extends T> promise1, @NotNull Promise<? extends T> promise2)`
`static <T> @NotNull Promise<T>`	`any(@NotNull BiPredicate<T,Throwable> predicate, @NotNull Iterator<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<T>`	`any(@NotNull BiPredicate<T,Throwable> predicate, @NotNull List<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<T>`	`any(@NotNull BiPredicate<T,Throwable> predicate, @NotNull Stream<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<T>`	`any(@NotNull Iterator<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<T>`	`any(@NotNull List<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<T>`	`any(@NotNull Stream<? extends Promise<? extends T>> promises)`
`static <T> Iterator<Promise<T>>`	`asPromises(@NotNull AsyncSupplier<? extends T>... tasks)`	Transforms an `AsyncSupplier` `tasks` to a collection of `Promise`s.
`static <T> Iterator<Promise<T>>`	`asPromises(@NotNull Iterable<? extends AsyncSupplier<? extends T>> tasks)`	Transforms an `Iterable` of `AsyncSupplier` `tasks` to a collection of `Promise`s.
`static <T> @NotNull Iterator<Promise<T>>`	`asPromises(@NotNull Iterator<? extends AsyncSupplier<? extends T>> tasks)`	Transforms a collection of `AsyncSupplier` `tasks` to a collection of `Promise`s.
`static <T> Iterator<Promise<T>>`	`asPromises(@NotNull Stream<? extends AsyncSupplier<? extends T>> tasks)`	Transforms a `Stream` of `AsyncSupplier` `tasks` to a collection of `Promise`s.
`static <T,A,R> @NotNull Function<T,Promise<R>>`	`coalesce(@NotNull Supplier<A> argumentAccumulatorSupplier, @NotNull BiConsumer<A,T> argumentAccumulatorFn, @NotNull Function<A,Promise<R>> fn)`
`static @NotNull Promise<Void>`	`delay(long delayMillis)`
`static <T> @NotNull Promise<T>`	`delay(long delayMillis, @NotNull Promise<T> promise)`	Delays completion of provided `promise` for the defined period of time.
`static <T> @NotNull Promise<T>`	`delay(long delayMillis, T value)`
`static @NotNull Promise<Void>`	`delay(@NotNull Duration delay)`
`static <T> @NotNull Promise<T>`	`delay(@NotNull Duration delay, @NotNull Promise<T> promise)`
`static <T> @NotNull Promise<T>`	`delay(@NotNull Duration delay, T value)`
`static <T> @NotNull Promise<T>`	`first(@NotNull Iterable<? extends AsyncSupplier<? extends T>> promises)`
`static <T> @NotNull Promise<T>`	`first(@NotNull BiPredicate<? super T,? super Throwable> predicate, @NotNull AsyncSupplier<? extends T>... promises)`
`static <T> @NotNull Promise<T>`	`first(@NotNull BiPredicate<? super T,? super Throwable> predicate, @NotNull Iterable<? extends AsyncSupplier<? extends T>> promises)`
`static <T> @NotNull Promise<T>`	`first(@NotNull BiPredicate<? super T,? super Throwable> predicate, @NotNull Iterator<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<T>`	`first(@NotNull BiPredicate<? super T,? super Throwable> predicate, @NotNull Stream<? extends AsyncSupplier<? extends T>> promises)`
`static <T> @NotNull Promise<T>`	`first(@NotNull Iterator<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<T>`	`first(@NotNull Stream<? extends AsyncSupplier<? extends T>> promises)`
`static <T> @NotNull Promise<T>`	`first(AsyncSupplier<? extends T>... promises)`	Picks the first `Promise` that was completed without exception.
`static <T> @NotNull Promise<T>`	`interval(long intervalMillis, @NotNull Promise<T> promise)`
`static <T> @NotNull Promise<T>`	`interval(@NotNull Duration interval, @NotNull Promise<T> promise)`
`static <T> @NotNull BiPredicate<T,Throwable>`	`isError()`	Returns a `BiPredicate` which checks if `Promise` was completed with an exception.
`static <T> @NotNull BiPredicate<T,Throwable>`	`isError(Predicate<? super Throwable> predicate)`
`static <T> @NotNull BiPredicate<T,Throwable>`	`isResult()`	Returns a `BiPredicate` which checks if `Promise` wasn't completed exceptionally.
`static <T> BiPredicate<T,Throwable>`	`isResult(Predicate<? super T> predicate)`
`static <T> BiPredicate<T,Throwable>`	`isResultOrError(Predicate<? super T> predicate)`
`static <T> BiPredicate<T,Throwable>`	`isResultOrError(Predicate<? super T> predicate, Predicate<? super Throwable> predicateError)`
`static <T> Promise<T>`	`loop(T seed, @NotNull Predicate<T> loopCondition, @NotNull Function<T,Promise<T>> next)`	Repeats provided `Function` until can pass `Predicate` test.
`static <T,T1,R,R1> @NotNull Function<T,Promise<R>>`	`mapTuple(@NotNull io.activej.common.tuple.TupleConstructor1<R1,R> constructor, @NotNull Function<? super T,T1> getter1, Function<T1,? extends Promise<R1>> fn1)`
`static <T,T1,T2,R,R1,R2> @NotNull Function<T,Promise<R>>`	`mapTuple(@NotNull io.activej.common.tuple.TupleConstructor2<R1,R2,R> constructor, @NotNull Function<? super T,T1> getter1, Function<T1,? extends Promise<R1>> fn1, @NotNull Function<? super T,T2> getter2, Function<T2,? extends Promise<R2>> fn2)`
`static <T,T1,T2,T3,R,R1,R2,R3> @NotNull Function<T,Promise<R>>`	`mapTuple(@NotNull io.activej.common.tuple.TupleConstructor3<R1,R2,R3,R> constructor, @NotNull Function<? super T,T1> getter1, Function<T1,? extends Promise<R1>> fn1, @NotNull Function<? super T,T2> getter2, Function<T2,? extends Promise<R2>> fn2, @NotNull Function<? super T,T3> getter3, Function<T3,? extends Promise<R3>> fn3)`
`static <T,T1,T2,T3,T4,R,R1,R2,R3,R4> @NotNull Function<T,Promise<R>>`	`mapTuple(@NotNull io.activej.common.tuple.TupleConstructor4<R1,R2,R3,R4,R> constructor, @NotNull Function<? super T,T1> getter1, Function<T1,? extends Promise<R1>> fn1, @NotNull Function<? super T,T2> getter2, Function<T2,? extends Promise<R2>> fn2, @NotNull Function<? super T,T3> getter3, Function<T3,? extends Promise<R3>> fn3, @NotNull Function<? super T,T4> getter4, Function<T4,? extends Promise<R4>> fn4)`
`static <T,T1,T2,T3,T4,T5,R,R1,R2,R3,R4,R5> @NotNull Function<T,Promise<R>>`	mapTuple(@NotNull io.activej.common.tuple.TupleConstructor5<R1,R2,R3,R4,R5,R> constructor, @NotNull Function<? super T,T1> getter1, Function<T1,? extends Promise<R1>> fn1, @NotNull Function<? super T,T2> getter2, Function<T2,? extends Promise<R2>> fn2, @NotNull Function<? super T,T3> getter3, Function<T3,? extends Promise<R3>> fn3, @NotNull Function<? super T,T4> getter4, Function<T4,? extends Promise<R4>> fn4, @NotNull Function<? super T,T5> getter5, Function<T5,? extends Promise<R5>> fn5)
`static <T,T1,T2,T3,T4,T5,T6,R,R1,R2,R3,R4,R5,R6> @NotNull Function<T,Promise<R>>`	mapTuple(@NotNull io.activej.common.tuple.TupleConstructor6<R1,R2,R3,R4,R5,R6,R> constructor, @NotNull Function<? super T,T1> getter1, Function<T1,? extends Promise<R1>> fn1, @NotNull Function<? super T,T2> getter2, Function<T2,? extends Promise<R2>> fn2, @NotNull Function<? super T,T3> getter3, Function<T3,? extends Promise<R3>> fn3, @NotNull Function<? super T,T4> getter4, Function<T4,? extends Promise<R4>> fn4, @NotNull Function<? super T,T5> getter5, Function<T5,? extends Promise<R5>> fn5, @NotNull Function<? super T,T6> getter6, Function<T6,? extends Promise<R6>> fn6)
`static <T,A,R> Promise<R>`	`reduce(@NotNull Collector<T,A,R> collector, int maxCalls, @NotNull Iterator<Promise<T>> promises)`	Allows to asynchronously reduce `Iterator` of `Promise`s into a `Promise` with the help of `Collector`.
`static <T,A,R> Promise<R>`	`reduce(A accumulator, @NotNull BiConsumer<A,T> consumer, @NotNull Function<A,R> finisher, int maxCalls, @NotNull Iterator<Promise<T>> promises)`
`static @NotNull Promise<Void>`	`repeat(@NotNull Supplier<Promise<Boolean>> supplier)`	Repeats the operations of provided `supplier` infinitely, until one of the `Promise`s completes exceptionally.
`static <T> Promise<T>`	`retry(AsyncSupplier<T> asyncSupplier)`
`static <T> Promise<T>`	`retry(AsyncSupplier<T> asyncSupplier, @NotNull RetryPolicy<?> retryPolicy)`
`static <T> Promise<T>`	`retry(AsyncSupplier<T> asyncSupplier, BiPredicate<T,Throwable> breakCondition, @NotNull RetryPolicy<?> retryPolicy)`
`static <T> Promise<T>`	`retry(BiPredicate<T,Throwable> breakCondition, AsyncSupplier<T> asyncSupplier)`
`static @NotNull Promise<Void>`	`schedule(long timestamp)`
`static <T> @NotNull Promise<T>`	`schedule(@NotNull Promise<T> promise, long timestamp)`	Schedules completion of the `Promise` so that it will be completed after the timestamp even if its operations were completed earlier.
`static <T> @NotNull Promise<T>`	`schedule(@NotNull Promise<T> promise, @NotNull Instant instant)`
`static @NotNull Promise<Void>`	`schedule(@NotNull Instant instant)`
`static <T> @NotNull Promise<T>`	`schedule(T value, long timestamp)`
`static <T> @NotNull Promise<T>`	`schedule(T value, @NotNull Instant instant)`
`static @NotNull Promise<Void>`	`sequence()`	Returns a `CompleteNullPromise`
`static @NotNull Promise<Void>`	`sequence(@NotNull AsyncSupplier<Void> promise)`	Gets `Promise` from provided `AsyncSupplier`, waits until it completes and than returns a `Promise<Void>`
`static @NotNull Promise<Void>`	`sequence(@NotNull AsyncSupplier<Void>... promises)`
`static @NotNull Promise<Void>`	`sequence(@NotNull AsyncSupplier<Void> promise1, @NotNull AsyncSupplier<Void> promise2)`	Gets `Promise`s from provided `AsyncSupplier`s, end executes them consequently, discarding their results.
`static @NotNull Promise<Void>`	`sequence(@NotNull Iterable<? extends AsyncSupplier<Void>> promises)`
`static @NotNull Promise<Void>`	`sequence(@NotNull 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 @NotNull Promise<Void>`	`sequence(@NotNull Stream<? extends AsyncSupplier<Void>> promises)`
`static <T> @NotNull Promise<T>`	`timeout(long delay, @NotNull 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> @NotNull Promise<T>`	`timeout(@NotNull Duration delay, @NotNull Promise<T> promise)`
`static <T> @NotNull Promise<T[]>`	`toArray(@NotNull Class<T> type)`	Returns an array of provided `type` and length 0 wrapped in `Promise`.
`static <T> @NotNull Promise<T[]>`	`toArray(@NotNull Class<T> type, @NotNull Promise<? extends T> promise1)`	Returns an array with `promise1` result.
`static <T> @NotNull Promise<T[]>`	`toArray(@NotNull Class<T> type, @NotNull Promise<? extends T>... promises)`
`static <T> @NotNull Promise<T[]>`	`toArray(@NotNull Class<T> type, @NotNull Promise<? extends T> promise1, @NotNull Promise<? extends T> promise2)`	Returns an array with `promise1` and `promise2` results.
`static <T> @NotNull Promise<T[]>`	`toArray(@NotNull Class<T> type, @NotNull Iterable<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<T[]>`	`toArray(@NotNull Class<T> type, @NotNull Iterator<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<T[]>`	`toArray(@NotNull Class<T> type, @NotNull List<? extends Promise<? extends T>> promises)`	Reduces promises into Promise<Array>
`static <T> @NotNull Promise<T[]>`	`toArray(@NotNull Class<T> type, @NotNull Stream<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<List<T>>`	`toList()`	Returns a successfully completed `Promise` with an empty list as the result.
`static <T> @NotNull Promise<List<T>>`	`toList(@NotNull Promise<? extends T> promise1)`	Returns a completed `Promise` with a result wrapped in `List`.
`static <T> @NotNull Promise<List<T>>`	`toList(@NotNull Promise<? extends T>... promises)`
`static <T> @NotNull Promise<List<T>>`	`toList(@NotNull Promise<? extends T> promise1, @NotNull Promise<? extends T> promise2)`	Returns `Promise` with a list of `promise1` and `promise2` results.
`static <T> @NotNull Promise<List<T>>`	`toList(@NotNull Iterable<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<List<T>>`	`toList(@NotNull Iterator<? extends Promise<? extends T>> promises)`
`static <T> @NotNull Promise<List<T>>`	`toList(@NotNull List<? extends Promise<? extends T>> promises)`	Reduces list of `Promise`s into Promise<List>.
`static <T> @NotNull Promise<List<T>>`	`toList(@NotNull Stream<? extends Promise<? extends T>> promises)`
`static <T1,R> @NotNull Promise<R>`	`toTuple(@NotNull io.activej.common.tuple.TupleConstructor1<T1,R> constructor, @NotNull Promise<? extends T1> promise1)`
`static <T1,T2,R> @NotNull Promise<R>`	`toTuple(@NotNull io.activej.common.tuple.TupleConstructor2<T1,T2,R> constructor, @NotNull Promise<? extends T1> promise1, @NotNull Promise<? extends T2> promise2)`
`static <T1,T2,T3,R> @NotNull Promise<R>`	`toTuple(@NotNull io.activej.common.tuple.TupleConstructor3<T1,T2,T3,R> constructor, @NotNull Promise<? extends T1> promise1, @NotNull Promise<? extends T2> promise2, @NotNull Promise<? extends T3> promise3)`
`static <T1,T2,T3,T4,R> @NotNull Promise<R>`	`toTuple(@NotNull io.activej.common.tuple.TupleConstructor4<T1,T2,T3,T4,R> constructor, @NotNull Promise<? extends T1> promise1, @NotNull Promise<? extends T2> promise2, @NotNull Promise<? extends T3> promise3, @NotNull Promise<? extends T4> promise4)`
`static <T1,T2,T3,T4,T5,R> @NotNull Promise<R>`	`toTuple(@NotNull io.activej.common.tuple.TupleConstructor5<T1,T2,T3,T4,T5,R> constructor, @NotNull Promise<? extends T1> promise1, @NotNull Promise<? extends T2> promise2, @NotNull Promise<? extends T3> promise3, @NotNull Promise<? extends T4> promise4, @NotNull Promise<? extends T5> promise5)`
`static <T1,T2,T3,T4,T5,T6,R> @NotNull Promise<R>`	`toTuple(@NotNull io.activej.common.tuple.TupleConstructor6<T1,T2,T3,T4,T5,T6,R> constructor, @NotNull Promise<? extends T1> promise1, @NotNull Promise<? extends T2> promise2, @NotNull Promise<? extends T3> promise3, @NotNull Promise<? extends T4> promise4, @NotNull Promise<? extends T5> promise5, @NotNull Promise<? extends T6> promise6)`
`static <T1> @NotNull Promise<io.activej.common.tuple.Tuple1<T1>>`	`toTuple(@NotNull Promise<? extends T1> promise1)`
`static <T1,T2> @NotNull Promise<io.activej.common.tuple.Tuple2<T1,T2>>`	`toTuple(@NotNull Promise<? extends T1> promise1, @NotNull Promise<? extends T2> promise2)`
`static <T1,T2,T3> @NotNull Promise<io.activej.common.tuple.Tuple3<T1,T2,T3>>`	`toTuple(@NotNull Promise<? extends T1> promise1, @NotNull Promise<? extends T2> promise2, @NotNull Promise<? extends T3> promise3)`
`static <T1,T2,T3,T4> @NotNull Promise<io.activej.common.tuple.Tuple4<T1,T2,T3,T4>>`	`toTuple(@NotNull Promise<? extends T1> promise1, @NotNull Promise<? extends T2> promise2, @NotNull Promise<? extends T3> promise3, @NotNull Promise<? extends T4> promise4)`
`static <T1,T2,T3,T4,T5> @NotNull Promise<io.activej.common.tuple.Tuple5<T1,T2,T3,T4,T5>>`	`toTuple(@NotNull Promise<? extends T1> promise1, @NotNull Promise<? extends T2> promise2, @NotNull Promise<? extends T3> promise3, @NotNull Promise<? extends T4> promise4, @NotNull Promise<? extends T5> promise5)`
`static <T1,T2,T3,T4,T5,T6> @NotNull Promise<io.activej.common.tuple.Tuple6<T1,T2,T3,T4,T5,T6>>`	`toTuple(@NotNull Promise<? extends T1> promise1, @NotNull Promise<? extends T2> promise2, @NotNull Promise<? extends T3> promise3, @NotNull Promise<? extends T4> promise4, @NotNull Promise<? extends T5> promise5, @NotNull Promise<? extends T6> promise6)`
`static <T> Promise<T>`	`until(T seed, @NotNull Function<T,Promise<T>> next, @NotNull Predicate<T> breakCondition)`

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

Constructor Detail
- Promises
```
public Promises()
```

Method Detail

timeout

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

See Also:: timeout(long, Promise)

timeout

@Contract(pure=true)
@NotNull
public static <T> @NotNull Promise<T> timeout(long delay,
                                              @NotNull
                                              @NotNull 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

delay

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

delay

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

delay

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

delay

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

delay

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

See Also:: delay(long, Promise)

delay

@Contract(pure=true)
@NotNull
public static <T> @NotNull Promise<T> delay(long delayMillis,
                                            @NotNull
                                            @NotNull 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

interval

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

interval

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

schedule

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

See Also:: schedule(Promise, long)

schedule

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

See Also:: schedule(Promise, long)

schedule

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

See Also:: schedule(Promise, long)

schedule

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

See Also:: schedule(Promise, long)

schedule

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

See Also:: schedule(Promise, long)

schedule

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

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

all

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

See Also:: all(List)

all

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

See Also:: all(List)

all

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

Optimized for 2 promises.

See Also:: all(List)

all

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

See Also:: all(List)

all

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

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

all

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

See Also:: all(List)

all
```
@NotNull
public static @NotNull Promise<Void> all(@NotNull
                                         @NotNull 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)
@NotNull
public static <T> @NotNull Promise<T> any()
```
Returns a CompleteExceptionallyPromise with Exception, since this method doesn't accept any Promises

See Also:

any(Iterator)

any

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

See Also:: any(Iterator)

any

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

Optimized for 2 promises.

See Also:: any(Iterator)

any

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

See Also:: any(Iterator)

any

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

See Also:: any(Iterator)

any

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

See Also:: any(Iterator)

any

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

any

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

any

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

any

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

any

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

any

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

any

@NotNull
public static <T> @NotNull Promise<T> any(@NotNull
                                          @NotNull BiPredicate<T,Throwable> predicate,
                                          @NotNull
                                          @NotNull Iterator<? extends Promise<? extends T>> promises)

toList

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

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

toList

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

Returns a completed Promise with a result wrapped in List.

toList

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

Returns Promise with a list of promise1 and promise2 results.

toList

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

See Also:: toList(List)

toList

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

Reduces list of Promises into Promise<List>.

toList

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

See Also:: toList(List)

toList

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

See Also:: toList(List)

toList

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

See Also:: toList(List)

toArray

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

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

toArray

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

Returns an array with promise1 result.

toArray

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

Returns an array with promise1 and promise2 results.

toArray

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

See Also:: toArray(Class, List)

toArray

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

Reduces promises into Promise<Array>

toArray

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

See Also:: toArray(Class, List)

toArray

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

See Also:: toArray(Class, List)

toArray

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

See Also:: toArray(Class, List)

toTuple

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

toTuple

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

toTuple

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

toTuple

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

toTuple

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

toTuple

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

toTuple

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

toTuple

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

toTuple

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

toTuple

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

toTuple

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

toTuple

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

mapTuple

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

mapTuple

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

mapTuple

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

mapTuple

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

mapTuple

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

mapTuple

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

sequence

@NotNull
public static @NotNull Promise<Void> sequence()

Returns a CompleteNullPromise

sequence

@NotNull
public static @NotNull Promise<Void> sequence(@NotNull
                                              @NotNull AsyncSupplier<Void> promise)

Gets Promise from provided AsyncSupplier, waits until it completes and than returns a Promise<Void>

sequence

@NotNull
public static @NotNull Promise<Void> sequence(@NotNull
                                              @NotNull AsyncSupplier<Void> promise1,
                                              @NotNull
                                              @NotNull AsyncSupplier<Void> promise2)

Gets Promises from provided AsyncSuppliers, end executes them consequently, discarding their results.

sequence

@NotNull
@SafeVarargs
public static @NotNull Promise<Void> sequence(@NotNull
                                              @NotNull AsyncSupplier<Void>... promises)

See Also:: sequence(Iterator)

sequence

@NotNull
public static @NotNull Promise<Void> sequence(@NotNull
                                              @NotNull Iterable<? extends AsyncSupplier<Void>> promises)

See Also:: sequence(Iterator)

sequence

@NotNull
public static @NotNull Promise<Void> sequence(@NotNull
                                              @NotNull Stream<? extends AsyncSupplier<Void>> promises)

See Also:: sequence(Iterator)

sequence
```
@NotNull
public static @NotNull Promise<Void> sequence(@NotNull
                                              @NotNull 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

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

Picks the first Promise that was completed without exception.

See Also:: first(BiPredicate, Iterator)

first

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

See Also:: first(AsyncSupplier[]), first(BiPredicate, Iterator)

first

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

See Also:: first(AsyncSupplier[]), first(BiPredicate, Iterator)

first

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

See Also:: first(AsyncSupplier[]), first(BiPredicate, Iterator)

first

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

See Also:: first(BiPredicate, Iterator)

first

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

See Also:: first(BiPredicate, Iterator)

first

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

See Also:: first(BiPredicate, Iterator)

first

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

Parameters:: predicate - filters results, consumes result of Promise
Returns:: first completed result of Promise that satisfies predicate

isResult
```
@NotNull
public static <T> @NotNull BiPredicate<T,Throwable> isResult()
```
Returns a BiPredicate which checks if Promise wasn't completed exceptionally.

isResult

public static <T> BiPredicate<T,Throwable> isResult(Predicate<? super T> predicate)

isResultOrError

public static <T> BiPredicate<T,Throwable> isResultOrError(Predicate<? super T> predicate)

isResultOrError

public static <T> BiPredicate<T,Throwable> isResultOrError(Predicate<? super T> predicate,
                                                                 Predicate<? super Throwable> predicateError)

isError
```
@NotNull
public static <T> @NotNull BiPredicate<T,Throwable> isError()
```
Returns a BiPredicate which checks if Promise was completed with an exception.

isError

@NotNull
public static <T> @NotNull BiPredicate<T,Throwable> isError(Predicate<? super Throwable> predicate)

repeat

@NotNull
public static @NotNull Promise<Void> repeat(@NotNull
                                            @NotNull Supplier<Promise<Boolean>> supplier)

Repeats the operations of provided supplier infinitely, until one of the Promises completes exceptionally.

loop
```
public static <T> Promise<T> loop(@Nullable
                                  T seed,
                                  @NotNull
                                  @NotNull Predicate<T> loopCondition,
                                  @NotNull
                                  @NotNull Function<T,Promise<T>> next)
```
Repeats provided Function 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,
                                   @NotNull
                                   @NotNull Function<T,Promise<T>> next,
                                   @NotNull
                                   @NotNull Predicate<T> breakCondition)

retry

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

retry

public static <T> Promise<T> retry(BiPredicate<T,Throwable> breakCondition,
                                   AsyncSupplier<T> asyncSupplier)

retry

public static <T> Promise<T> retry(AsyncSupplier<T> asyncSupplier,
                                   @NotNull
                                   @NotNull RetryPolicy<?> retryPolicy)

retry

public static <T> Promise<T> retry(AsyncSupplier<T> asyncSupplier,
                                   BiPredicate<T,Throwable> breakCondition,
                                   @NotNull
                                   @NotNull RetryPolicy<?> retryPolicy)

asPromises

@NotNull
public static <T> @NotNull Iterator<Promise<T>> asPromises(@NotNull
                                                           @NotNull 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(@NotNull
                                                  @NotNull 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(@NotNull
                                                  @NotNull 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(@NotNull
                                                  @NotNull AsyncSupplier<? extends T>... tasks)

Transforms an AsyncSupplier tasks to a collection of Promises.

reduce
```
public static <T,A,R> Promise<R> reduce(@NotNull
                                                    @NotNull Collector<T,A,R> collector,
                                                    int maxCalls,
                                                    @NotNull
                                                    @NotNull Iterator<Promise<T>> promises)
```
Allows to asynchronously reduce Iterator of Promises into a Promise with the help of Collector. You can control the amount of concurrently running Promise.
This method is universal and allows to implement app-specific logic.

Type Parameters:

T - type of input elements for this operation

A - mutable accumulation type of the operation

R - the result type of the operation

Parameters:

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

maxCalls - max amount of concurrently running Promises

promises - Iterable of Promises

Returns:

a Promise which wraps the accumulated result of the reduction. If one of the promises completed exceptionally, a Promise with an exception will be returned.

reduce
```
public static <T,A,R> Promise<R> reduce(A accumulator,
                                                    @NotNull
                                                    @NotNull BiConsumer<A,T> consumer,
                                                    @NotNull
                                                    @NotNull Function<A,R> finisher,
                                                    int maxCalls,
                                                    @NotNull
                                                    @NotNull Iterator<Promise<T>> promises)
```
Type Parameters:

T - type of input elements for this operation

A - mutable accumulation type of the operation

R - result type of the reduction operation

Parameters:

accumulator - supplier of the result

consumer - a BiConsumer which folds a result of each of the completed promises into accumulator

finisher - a Function which performs the final transformation from the intermediate accumulations

maxCalls - max amount of concurrently running Promises

promises - Iterable of Promises

Returns:

a Promise which wraps the accumulated result of the reduction. If one of the promises completed exceptionally, a Promise with an exception will be returned.

See Also:

reduce(Collector, int, Iterator)

coalesce

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

Class Promises

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Promises

Method Detail

timeout

timeout

delay

delay

delay

delay

delay

delay

interval

interval

schedule

schedule

schedule

schedule

schedule

schedule

all

all

all

all

all

all

all

any

any

any

any

any

any

any

any

any

any

any

any

any

toList

toList

toList

toList

toList

toList

toList

toList

toArray

toArray

toArray

toArray

toArray

toArray

toArray

toArray

toTuple

toTuple

toTuple

toTuple

toTuple

toTuple

toTuple

toTuple

toTuple

toTuple

toTuple

toTuple

mapTuple

mapTuple

mapTuple

mapTuple

mapTuple

mapTuple

sequence

sequence

sequence