me.lucko.helper.promise

Interface Promise<V>

Type Parameters:

V - the result type

All Superinterfaces:

AutoCloseable, Future<V>, Terminable

public interface Promise<V>
extends Future<V>, Terminable

An object that acts as a proxy for a result that is initially unknown, usually because the computation of its value is yet incomplete.

This interface carries similar method signatures to those of CompletionStage and CompletableFuture.

However, a distinction is made between actions which are executed on the main server thread vs asynchronously.

Field Summary

Fields inherited from interface me.lucko.helper.terminable.Terminable

EMPTY

Method Summary

Modifier and Type	Method and Description
default boolean	cancel() Attempts to cancel execution of this task.
static <U> Promise<U>	completed(U value) Returns a Promise which is already completed with the given value.
static <U> Promise<U>	empty() Returns a new empty Promise
default Promise<V>	exceptionally(ThreadContext context, Function<Throwable,? extends V> fn) Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function.
static <U> Promise<U>	exceptionally(Throwable exception) Returns a Promise which is already completed with the given exception.
Promise<V>	exceptionallyAsync(Function<Throwable,? extends V> fn) Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function.
default Promise<V>	exceptionallyDelayed(ThreadContext context, Function<Throwable,? extends V> fn, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed.
default Promise<V>	exceptionallyDelayed(ThreadContext context, Function<Throwable,? extends V> fn, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed.
Promise<V>	exceptionallyDelayedAsync(Function<Throwable,? extends V> fn, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed.
Promise<V>	exceptionallyDelayedAsync(Function<Throwable,? extends V> fn, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed.
Promise<V>	exceptionallyDelayedSync(Function<Throwable,? extends V> fn, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed.
Promise<V>	exceptionallyDelayedSync(Function<Throwable,? extends V> fn, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed.
Promise<V>	exceptionallySync(Function<Throwable,? extends V> fn) Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function.
V	getNow(V valueIfAbsent) Returns the result value (or throws any encountered exception) if completed, else returns the given valueIfAbsent.
V	join() Returns the result value when complete, or throws an (unchecked) exception if completed exceptionally.
static Promise<Void>	start() Returns a new base promise to be built on top of.
default Promise<V>	supply(ThreadContext context, Supplier<V> supplier) Schedules the supply of the Promise's result, via the given supplier.
Promise<V>	supply(V value) Supplies the Promise's result.
Promise<V>	supplyAsync(Supplier<V> supplier) Schedules the supply of the Promise's result, via the given supplier.
default Promise<V>	supplyDelayed(ThreadContext context, Supplier<V> supplier, long delayTicks) Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.
default Promise<V>	supplyDelayed(ThreadContext context, Supplier<V> supplier, long delay, TimeUnit unit) Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.
Promise<V>	supplyDelayedAsync(Supplier<V> supplier, long delayTicks) Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.
Promise<V>	supplyDelayedAsync(Supplier<V> supplier, long delay, TimeUnit unit) Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.
Promise<V>	supplyDelayedSync(Supplier<V> supplier, long delayTicks) Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.
Promise<V>	supplyDelayedSync(Supplier<V> supplier, long delay, TimeUnit unit) Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.
Promise<V>	supplyException(Throwable exception) Supplies an exceptional result to the Promise.
default Promise<V>	supplyExceptionally(ThreadContext context, Callable<V> callable) Schedules the supply of the Promise's result, via the given callable.
Promise<V>	supplyExceptionallyAsync(Callable<V> callable) Schedules the supply of the Promise's result, via the given callable.
default Promise<V>	supplyExceptionallyDelayed(ThreadContext context, Callable<V> callable, long delayTicks) Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.
default Promise<V>	supplyExceptionallyDelayed(ThreadContext context, Callable<V> callable, long delay, TimeUnit unit) Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.
Promise<V>	supplyExceptionallyDelayedAsync(Callable<V> callable, long delayTicks) Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.
Promise<V>	supplyExceptionallyDelayedAsync(Callable<V> callable, long delay, TimeUnit unit) Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.
Promise<V>	supplyExceptionallyDelayedSync(Callable<V> callable, long delayTicks) Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.
Promise<V>	supplyExceptionallyDelayedSync(Callable<V> callable, long delay, TimeUnit unit) Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.
Promise<V>	supplyExceptionallySync(Callable<V> callable) Schedules the supply of the Promise's result, via the given callable.
static <U> Promise<U>	supplying(ThreadContext context, Supplier<U> supplier) Returns a new Promise, and schedules it's population via the given supplier.
static <U> Promise<U>	supplyingAsync(Supplier<U> supplier) Returns a new Promise, and schedules it's population via the given supplier.
static <U> Promise<U>	supplyingDelayed(ThreadContext context, Supplier<U> supplier, long delayTicks) Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.
static <U> Promise<U>	supplyingDelayed(ThreadContext context, Supplier<U> supplier, long delay, TimeUnit unit) Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.
static <U> Promise<U>	supplyingDelayedAsync(Supplier<U> supplier, long delayTicks) Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.
static <U> Promise<U>	supplyingDelayedAsync(Supplier<U> supplier, long delay, TimeUnit unit) Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.
static <U> Promise<U>	supplyingDelayedSync(Supplier<U> supplier, long delayTicks) Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.
static <U> Promise<U>	supplyingDelayedSync(Supplier<U> supplier, long delay, TimeUnit unit) Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.
static <U> Promise<U>	supplyingExceptionally(ThreadContext context, Callable<U> callable) Returns a new Promise, and schedules it's population via the given callable.
static <U> Promise<U>	supplyingExceptionallyAsync(Callable<U> callable) Returns a new Promise, and schedules it's population via the given callable.
static <U> Promise<U>	supplyingExceptionallyDelayed(ThreadContext context, Callable<U> callable, long delayTicks) Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.
static <U> Promise<U>	supplyingExceptionallyDelayed(ThreadContext context, Callable<U> callable, long delay, TimeUnit unit) Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.
static <U> Promise<U>	supplyingExceptionallyDelayedAsync(Callable<U> callable, long delayTicks) Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.
static <U> Promise<U>	supplyingExceptionallyDelayedAsync(Callable<U> callable, long delay, TimeUnit unit) Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.
static <U> Promise<U>	supplyingExceptionallyDelayedSync(Callable<U> callable, long delayTicks) Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.
static <U> Promise<U>	supplyingExceptionallyDelayedSync(Callable<U> callable, long delay, TimeUnit unit) Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.
static <U> Promise<U>	supplyingExceptionallySync(Callable<U> callable) Returns a new Promise, and schedules it's population via the given callable.
static <U> Promise<U>	supplyingSync(Supplier<U> supplier) Returns a new Promise, and schedules it's population via the given supplier.
Promise<V>	supplySync(Supplier<V> supplier) Schedules the supply of the Promise's result, via the given supplier.
default Promise<Void>	thenAccept(ThreadContext context, Consumer<? super V> action) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action.
default Promise<Void>	thenAcceptAsync(Consumer<? super V> action) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action.
default Promise<Void>	thenAcceptDelayed(ThreadContext context, Consumer<? super V> action, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.
default Promise<Void>	thenAcceptDelayed(ThreadContext context, Consumer<? super V> action, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.
default Promise<Void>	thenAcceptDelayedAsync(Consumer<? super V> action, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.
default Promise<Void>	thenAcceptDelayedAsync(Consumer<? super V> action, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.
default Promise<Void>	thenAcceptDelayedSync(Consumer<? super V> action, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.
default Promise<Void>	thenAcceptDelayedSync(Consumer<? super V> action, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.
default Promise<Void>	thenAcceptSync(Consumer<? super V> action) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action.
default <U> Promise<U>	thenApply(ThreadContext context, Function<? super V,? extends U> fn) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.
<U> Promise<U>	thenApplyAsync(Function<? super V,? extends U> fn) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.
default <U> Promise<U>	thenApplyDelayed(ThreadContext context, Function<? super V,? extends U> fn, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
default <U> Promise<U>	thenApplyDelayed(ThreadContext context, Function<? super V,? extends U> fn, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
<U> Promise<U>	thenApplyDelayedAsync(Function<? super V,? extends U> fn, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
<U> Promise<U>	thenApplyDelayedAsync(Function<? super V,? extends U> fn, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
<U> Promise<U>	thenApplyDelayedSync(Function<? super V,? extends U> fn, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
<U> Promise<U>	thenApplyDelayedSync(Function<? super V,? extends U> fn, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
<U> Promise<U>	thenApplySync(Function<? super V,? extends U> fn) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.
default <U> Promise<U>	thenCompose(ThreadContext context, Function<? super V,? extends Promise<U>> fn) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.
<U> Promise<U>	thenComposeAsync(Function<? super V,? extends Promise<U>> fn) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.
<U> Promise<U>	thenComposeDelayedAsync(Function<? super V,? extends Promise<U>> fn, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
<U> Promise<U>	thenComposeDelayedAsync(Function<? super V,? extends Promise<U>> fn, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
<U> Promise<U>	thenComposeDelayedSync(Function<? super V,? extends Promise<U>> fn, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
<U> Promise<U>	thenComposeDelayedSync(Function<? super V,? extends Promise<U>> fn, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
default <U> Promise<U>	thenComposeDelayedSync(ThreadContext context, Function<? super V,? extends Promise<U>> fn, long delayTicks) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
default <U> Promise<U>	thenComposeDelayedSync(ThreadContext context, Function<? super V,? extends Promise<U>> fn, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.
<U> Promise<U>	thenComposeSync(Function<? super V,? extends Promise<U>> fn) Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.
default Promise<Void>	thenRun(ThreadContext context, Runnable action) Returns a new Promise that, when this promise completes normally, executes the given task.
default Promise<Void>	thenRunAsync(Runnable action) Returns a new Promise that, when this promise completes normally, executes the given task.
default Promise<Void>	thenRunDelayed(ThreadContext context, Runnable action, long delayTicks) Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.
default Promise<Void>	thenRunDelayed(ThreadContext context, Runnable action, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.
default Promise<Void>	thenRunDelayedAsync(Runnable action, long delayTicks) Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.
default Promise<Void>	thenRunDelayedAsync(Runnable action, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.
default Promise<Void>	thenRunDelayedSync(Runnable action, long delayTicks) Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.
default Promise<Void>	thenRunDelayedSync(Runnable action, long delay, TimeUnit unit) Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.
default Promise<Void>	thenRunSync(Runnable action) Returns a new Promise that, when this promise completes normally, executes the given task.
CompletableFuture<V>	toCompletableFuture() Returns a CompletableFuture maintaining the same completion properties as this Promise.
static <U> Promise<U>	wrapFuture(Future<U> future) Returns a Promise which represents the given future.

Methods inherited from interface java.util.concurrent.Future

cancel, get, get, isCancelled, isDone

Methods inherited from interface me.lucko.helper.terminable.Terminable

bindWith, close, closeAndReportException, closeSilently, isClosed

Method Detail

empty

@Nonnull
static <U> Promise<U> empty()

Returns a new empty Promise

An empty promise can be 'completed' via the supply methods.

Type Parameters:

U - the result type

Returns:

a new empty promise

start

@Nonnull
static Promise<Void> start()

Returns a new base promise to be built on top of.

Returns:

a new promise

completed

@Nonnull
static <U> Promise<U> completed(@Nullable
                                         U value)

Returns a Promise which is already completed with the given value.

Type Parameters:

U - the result type

Parameters:

value - the value

Returns:

a new completed promise

exceptionally

@Nonnull
static <U> Promise<U> exceptionally(@Nonnull
                                             Throwable exception)

Returns a Promise which is already completed with the given exception.

Type Parameters:

U - the result type

Parameters:

exception - the exception

Returns:

the new completed promise

wrapFuture

@Nonnull
static <U> Promise<U> wrapFuture(@Nonnull
                                          Future<U> future)

Returns a Promise which represents the given future.

The implementation will make an attempt to wrap the future without creating a new process to await the result (by casting to CompletionStage or ListenableFuture).

Calls to cancel the returned promise will not affected the wrapped future.

Type Parameters:

U - the result type

Parameters:

future - the future to wrap

Returns:

the new promise

supplying

@Nonnull
static <U> Promise<U> supplying(@Nonnull
                                         ThreadContext context,
                                         @Nonnull
                                         Supplier<U> supplier)

Returns a new Promise, and schedules it's population via the given supplier.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

supplier - the value supplier

Returns:

the promise

supplyingSync

@Nonnull
static <U> Promise<U> supplyingSync(@Nonnull
                                             Supplier<U> supplier)

Returns a new Promise, and schedules it's population via the given supplier.

Type Parameters:

U - the result type

Parameters:

supplier - the value supplier

Returns:

the promise

supplyingAsync

@Nonnull
static <U> Promise<U> supplyingAsync(@Nonnull
                                              Supplier<U> supplier)

Returns a new Promise, and schedules it's population via the given supplier.

Type Parameters:

U - the result type

Parameters:

supplier - the value supplier

Returns:

the promise

supplyingDelayed

@Nonnull
static <U> Promise<U> supplyingDelayed(@Nonnull
                                                ThreadContext context,
                                                @Nonnull
                                                Supplier<U> supplier,
                                                long delayTicks)

Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

supplier - the value supplier

delayTicks - the delay in ticks

Returns:

the promise

supplyingDelayed

@Nonnull
static <U> Promise<U> supplyingDelayed(@Nonnull
                                                ThreadContext context,
                                                @Nonnull
                                                Supplier<U> supplier,
                                                long delay,
                                                @Nonnull
                                                TimeUnit unit)

Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

supplier - the value supplier

delay - the delay

unit - the unit of delay

Returns:

the promise

supplyingDelayedSync

@Nonnull
static <U> Promise<U> supplyingDelayedSync(@Nonnull
                                                    Supplier<U> supplier,
                                                    long delayTicks)

Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

supplier - the value supplier

delayTicks - the delay in ticks

Returns:

the promise

supplyingDelayedSync

@Nonnull
static <U> Promise<U> supplyingDelayedSync(@Nonnull
                                                    Supplier<U> supplier,
                                                    long delay,
                                                    @Nonnull
                                                    TimeUnit unit)

Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

supplier - the value supplier

delay - the delay

unit - the unit of delay

Returns:

the promise

supplyingDelayedAsync

@Nonnull
static <U> Promise<U> supplyingDelayedAsync(@Nonnull
                                                     Supplier<U> supplier,
                                                     long delayTicks)

Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

supplier - the value supplier

delayTicks - the delay in ticks

Returns:

the promise

supplyingDelayedAsync

@Nonnull
static <U> Promise<U> supplyingDelayedAsync(@Nonnull
                                                     Supplier<U> supplier,
                                                     long delay,
                                                     @Nonnull
                                                     TimeUnit unit)

Returns a new Promise, and schedules it's population via the given supplier, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

supplier - the value supplier

delay - the delay

unit - the unit of delay

Returns:

the promise

supplyingExceptionally

@Nonnull
static <U> Promise<U> supplyingExceptionally(@Nonnull
                                                      ThreadContext context,
                                                      @Nonnull
                                                      Callable<U> callable)

Returns a new Promise, and schedules it's population via the given callable.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

callable - the value callable

Returns:

the promise

supplyingExceptionallySync

@Nonnull
static <U> Promise<U> supplyingExceptionallySync(@Nonnull
                                                          Callable<U> callable)

Returns a new Promise, and schedules it's population via the given callable.

Type Parameters:

U - the result type

Parameters:

callable - the value callable

Returns:

the promise

supplyingExceptionallyAsync

@Nonnull
static <U> Promise<U> supplyingExceptionallyAsync(@Nonnull
                                                           Callable<U> callable)

Returns a new Promise, and schedules it's population via the given callable.

Type Parameters:

U - the result type

Parameters:

callable - the value callable

Returns:

the promise

supplyingExceptionallyDelayed

@Nonnull
static <U> Promise<U> supplyingExceptionallyDelayed(@Nonnull
                                                             ThreadContext context,
                                                             @Nonnull
                                                             Callable<U> callable,
                                                             long delayTicks)

Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

callable - the value callable

delayTicks - the delay in ticks

Returns:

the promise

supplyingExceptionallyDelayed

@Nonnull
static <U> Promise<U> supplyingExceptionallyDelayed(@Nonnull
                                                             ThreadContext context,
                                                             @Nonnull
                                                             Callable<U> callable,
                                                             long delay,
                                                             @Nonnull
                                                             TimeUnit unit)

Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

callable - the value callable

delay - the delay

unit - the unit of delay

Returns:

the promise

supplyingExceptionallyDelayedSync

@Nonnull
static <U> Promise<U> supplyingExceptionallyDelayedSync(@Nonnull
                                                                 Callable<U> callable,
                                                                 long delayTicks)

Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

callable - the value callable

delayTicks - the delay in ticks

Returns:

the promise

supplyingExceptionallyDelayedSync

@Nonnull
static <U> Promise<U> supplyingExceptionallyDelayedSync(@Nonnull
                                                                 Callable<U> callable,
                                                                 long delay,
                                                                 @Nonnull
                                                                 TimeUnit unit)

Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

callable - the value callable

delay - the delay

unit - the unit of delay

Returns:

the promise

supplyingExceptionallyDelayedAsync

@Nonnull
static <U> Promise<U> supplyingExceptionallyDelayedAsync(@Nonnull
                                                                  Callable<U> callable,
                                                                  long delayTicks)

Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

callable - the value callable

delayTicks - the delay in ticks

Returns:

the promise

supplyingExceptionallyDelayedAsync

@Nonnull
static <U> Promise<U> supplyingExceptionallyDelayedAsync(@Nonnull
                                                                  Callable<U> callable,
                                                                  long delay,
                                                                  @Nonnull
                                                                  TimeUnit unit)

Returns a new Promise, and schedules it's population via the given callable, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

callable - the value callable

delay - the delay

unit - the unit of delay

Returns:

the promise

cancel

default boolean cancel()

Attempts to cancel execution of this task.

Returns:

false if the task could not be cancelled, typically because it has already completed normally; true otherwise

join

V join()

Returns the result value when complete, or throws an (unchecked) exception if completed exceptionally.

To better conform with the use of common functional forms, if a computation involved in the completion of this Promise threw an exception, this method throws an (unchecked) CompletionException with the underlying exception as its cause.

Returns:

the result value

Throws:

CancellationException - if the computation was cancelled

CompletionException - if this future completed exceptionally or a completion computation threw an exception

getNow

V getNow(V valueIfAbsent)

Returns the result value (or throws any encountered exception) if completed, else returns the given valueIfAbsent.

Parameters:

valueIfAbsent - the value to return if not completed

Returns:

the result value, if completed, else the given valueIfAbsent

Throws:

CancellationException - if the computation was cancelled

CompletionException - if this future completed exceptionally or a completion computation threw an exception

supply

@Nonnull
Promise<V> supply(@Nullable
                           V value)

Supplies the Promise's result.

Parameters:

value - the object to pass to the promise

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyException

@Nonnull
Promise<V> supplyException(@Nonnull
                                    Throwable exception)

Supplies an exceptional result to the Promise.

Parameters:

exception - the exception to supply

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supply

@Nonnull
default Promise<V> supply(@Nonnull
                                   ThreadContext context,
                                   @Nonnull
                                   Supplier<V> supplier)

Schedules the supply of the Promise's result, via the given supplier.

Parameters:

context - the type of executor to use to supply the promise

supplier - the supplier

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplySync

@Nonnull
Promise<V> supplySync(@Nonnull
                               Supplier<V> supplier)

Schedules the supply of the Promise's result, via the given supplier.

Parameters:

supplier - the supplier

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyAsync

@Nonnull
Promise<V> supplyAsync(@Nonnull
                                Supplier<V> supplier)

Schedules the supply of the Promise's result, via the given supplier.

Parameters:

supplier - the supplier

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyDelayed

@Nonnull
default Promise<V> supplyDelayed(@Nonnull
                                          ThreadContext context,
                                          @Nonnull
                                          Supplier<V> supplier,
                                          long delayTicks)

Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.

Parameters:

context - the type of executor to use to supply the promise

supplier - the supplier

delayTicks - the delay in ticks

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyDelayed

@Nonnull
default Promise<V> supplyDelayed(@Nonnull
                                          ThreadContext context,
                                          @Nonnull
                                          Supplier<V> supplier,
                                          long delay,
                                          @Nonnull
                                          TimeUnit unit)

Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.

Parameters:

context - the type of executor to use to supply the promise

supplier - the supplier

delay - the delay

unit - the unit of delay

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyDelayedSync

@Nonnull
Promise<V> supplyDelayedSync(@Nonnull
                                      Supplier<V> supplier,
                                      long delayTicks)

Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.

Parameters:

supplier - the supplier

delayTicks - the delay in ticks

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyDelayedSync

@Nonnull
Promise<V> supplyDelayedSync(@Nonnull
                                      Supplier<V> supplier,
                                      long delay,
                                      @Nonnull
                                      TimeUnit unit)

Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.

Parameters:

supplier - the supplier

delay - the delay

unit - the unit of delay

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyDelayedAsync

@Nonnull
Promise<V> supplyDelayedAsync(@Nonnull
                                       Supplier<V> supplier,
                                       long delayTicks)

Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.

Parameters:

supplier - the supplier

delayTicks - the delay in ticks

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyDelayedAsync

@Nonnull
Promise<V> supplyDelayedAsync(@Nonnull
                                       Supplier<V> supplier,
                                       long delay,
                                       @Nonnull
                                       TimeUnit unit)

Schedules the supply of the Promise's result, via the given supplier, after the delay has elapsed.

Parameters:

supplier - the supplier

delay - the delay

unit - the unit of delay

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyExceptionally

@Nonnull
default Promise<V> supplyExceptionally(@Nonnull
                                                ThreadContext context,
                                                @Nonnull
                                                Callable<V> callable)

Schedules the supply of the Promise's result, via the given callable.

Parameters:

context - the type of executor to use to supply the promise

callable - the callable

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyExceptionallySync

@Nonnull
Promise<V> supplyExceptionallySync(@Nonnull
                                            Callable<V> callable)

Schedules the supply of the Promise's result, via the given callable.

Parameters:

callable - the callable

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyExceptionallyAsync

@Nonnull
Promise<V> supplyExceptionallyAsync(@Nonnull
                                             Callable<V> callable)

Schedules the supply of the Promise's result, via the given callable.

Parameters:

callable - the callable

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyExceptionallyDelayed

@Nonnull
default Promise<V> supplyExceptionallyDelayed(@Nonnull
                                                       ThreadContext context,
                                                       @Nonnull
                                                       Callable<V> callable,
                                                       long delayTicks)

Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.

Parameters:

context - the type of executor to use to supply the promise

callable - the callable

delayTicks - the delay in ticks

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyExceptionallyDelayed

@Nonnull
default Promise<V> supplyExceptionallyDelayed(@Nonnull
                                                       ThreadContext context,
                                                       @Nonnull
                                                       Callable<V> callable,
                                                       long delay,
                                                       @Nonnull
                                                       TimeUnit unit)

Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.

Parameters:

context - the type of executor to use to supply the promise

callable - the callable

delay - the delay

unit - the unit of delay

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyExceptionallyDelayedSync

@Nonnull
Promise<V> supplyExceptionallyDelayedSync(@Nonnull
                                                   Callable<V> callable,
                                                   long delayTicks)

Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.

Parameters:

callable - the callable

delayTicks - the delay in ticks

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyExceptionallyDelayedSync

@Nonnull
Promise<V> supplyExceptionallyDelayedSync(@Nonnull
                                                   Callable<V> callable,
                                                   long delay,
                                                   @Nonnull
                                                   TimeUnit unit)

Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.

Parameters:

callable - the callable

delay - the delay

unit - the unit of delay

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyExceptionallyDelayedAsync

@Nonnull
Promise<V> supplyExceptionallyDelayedAsync(@Nonnull
                                                    Callable<V> callable,
                                                    long delayTicks)

Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.

Parameters:

callable - the callable

delayTicks - the delay in ticks

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

supplyExceptionallyDelayedAsync

@Nonnull
Promise<V> supplyExceptionallyDelayedAsync(@Nonnull
                                                    Callable<V> callable,
                                                    long delay,
                                                    @Nonnull
                                                    TimeUnit unit)

Schedules the supply of the Promise's result, via the given callable, after the delay has elapsed.

Parameters:

callable - the callable

delay - the delay

unit - the unit of delay

Returns:

the same promise

Throws:

IllegalStateException - if the promise is already being supplied, or has already been completed.

thenApply

@Nonnull
default <U> Promise<U> thenApply(@Nonnull
                                          ThreadContext context,
                                          @Nonnull
                                          Function<? super V,? extends U> fn)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

fn - the function to use to compute the value

Returns:

the new promise

thenApplySync

@Nonnull
<U> Promise<U> thenApplySync(@Nonnull
                                      Function<? super V,? extends U> fn)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

Returns:

the new promise

thenApplyAsync

@Nonnull
<U> Promise<U> thenApplyAsync(@Nonnull
                                       Function<? super V,? extends U> fn)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

Returns:

the new promise

thenApplyDelayed

@Nonnull
default <U> Promise<U> thenApplyDelayed(@Nonnull
                                                 ThreadContext context,
                                                 @Nonnull
                                                 Function<? super V,? extends U> fn,
                                                 long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

fn - the function to use to compute the value

delayTicks - the delay in ticks

Returns:

the new promise

thenApplyDelayed

@Nonnull
default <U> Promise<U> thenApplyDelayed(@Nonnull
                                                 ThreadContext context,
                                                 @Nonnull
                                                 Function<? super V,? extends U> fn,
                                                 long delay,
                                                 @Nonnull
                                                 TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

fn - the function to use to compute the value

delay - the delay

unit - the unit of delay

Returns:

the new promise

thenApplyDelayedSync

@Nonnull
<U> Promise<U> thenApplyDelayedSync(@Nonnull
                                             Function<? super V,? extends U> fn,
                                             long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

delayTicks - the delay in ticks

Returns:

the new promise

thenApplyDelayedSync

@Nonnull
<U> Promise<U> thenApplyDelayedSync(@Nonnull
                                             Function<? super V,? extends U> fn,
                                             long delay,
                                             @Nonnull
                                             TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

delay - the delay

unit - the unit of delay

Returns:

the new promise

thenApplyDelayedAsync

@Nonnull
<U> Promise<U> thenApplyDelayedAsync(@Nonnull
                                              Function<? super V,? extends U> fn,
                                              long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

delayTicks - the delay in ticks

Returns:

the new promise

thenApplyDelayedAsync

@Nonnull
<U> Promise<U> thenApplyDelayedAsync(@Nonnull
                                              Function<? super V,? extends U> fn,
                                              long delay,
                                              @Nonnull
                                              TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

delay - the delay

unit - the unit of delay

Returns:

the new promise

thenAccept

@Nonnull
default Promise<Void> thenAccept(@Nonnull
                                          ThreadContext context,
                                          @Nonnull
                                          Consumer<? super V> action)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action.

Parameters:

context - the type of executor to use to supply the promise

action - the action to perform before completing the returned future

Returns:

the new promise

thenAcceptSync

@Nonnull
default Promise<Void> thenAcceptSync(@Nonnull
                                              Consumer<? super V> action)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action.

Parameters:

action - the action to perform before completing the returned future

Returns:

the new promise

thenAcceptAsync

@Nonnull
default Promise<Void> thenAcceptAsync(@Nonnull
                                               Consumer<? super V> action)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action.

Parameters:

action - the action to perform before completing the returned future

Returns:

the new promise

thenAcceptDelayed

@Nonnull
default Promise<Void> thenAcceptDelayed(@Nonnull
                                                 ThreadContext context,
                                                 @Nonnull
                                                 Consumer<? super V> action,
                                                 long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.

Parameters:

context - the type of executor to use to supply the promise

action - the action to perform before completing the returned future

delayTicks - the delay in ticks

Returns:

the new promise

thenAcceptDelayed

@Nonnull
default Promise<Void> thenAcceptDelayed(@Nonnull
                                                 ThreadContext context,
                                                 @Nonnull
                                                 Consumer<? super V> action,
                                                 long delay,
                                                 @Nonnull
                                                 TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.

Parameters:

context - the type of executor to use to supply the promise

action - the action to perform before completing the returned future

delay - the delay

unit - the unit of delay

Returns:

the new promise

thenAcceptDelayedSync

@Nonnull
default Promise<Void> thenAcceptDelayedSync(@Nonnull
                                                     Consumer<? super V> action,
                                                     long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.

Parameters:

action - the action to perform before completing the returned future

delayTicks - the delay in ticks

Returns:

the new promise

thenAcceptDelayedSync

@Nonnull
default Promise<Void> thenAcceptDelayedSync(@Nonnull
                                                     Consumer<? super V> action,
                                                     long delay,
                                                     @Nonnull
                                                     TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.

Parameters:

action - the action to perform before completing the returned future

delay - the delay

unit - the unit of delay

Returns:

the new promise

thenAcceptDelayedAsync

@Nonnull
default Promise<Void> thenAcceptDelayedAsync(@Nonnull
                                                      Consumer<? super V> action,
                                                      long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.

Parameters:

action - the action to perform before completing the returned future

delayTicks - the delay in ticks

Returns:

the new promise

thenAcceptDelayedAsync

@Nonnull
default Promise<Void> thenAcceptDelayedAsync(@Nonnull
                                                      Consumer<? super V> action,
                                                      long delay,
                                                      @Nonnull
                                                      TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given action, after the delay has elapsed.

Parameters:

action - the action to perform before completing the returned future

delay - the delay

unit - the unit of delay

Returns:

the new promise

thenRun

@Nonnull
default Promise<Void> thenRun(@Nonnull
                                       ThreadContext context,
                                       @Nonnull
                                       Runnable action)

Returns a new Promise that, when this promise completes normally, executes the given task.

Parameters:

context - the type of executor to use to supply the promise

action - the action to run before completing the returned future

Returns:

the new promise

thenRunSync

@Nonnull
default Promise<Void> thenRunSync(@Nonnull
                                           Runnable action)

Returns a new Promise that, when this promise completes normally, executes the given task.

Parameters:

action - the action to run before completing the returned future

Returns:

the new promise

thenRunAsync

@Nonnull
default Promise<Void> thenRunAsync(@Nonnull
                                            Runnable action)

Returns a new Promise that, when this promise completes normally, executes the given task.

Parameters:

action - the action to run before completing the returned future

Returns:

the new promise

thenRunDelayed

@Nonnull
default Promise<Void> thenRunDelayed(@Nonnull
                                              ThreadContext context,
                                              @Nonnull
                                              Runnable action,
                                              long delayTicks)

Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.

Parameters:

context - the type of executor to use to supply the promise

action - the action to run before completing the returned future

delayTicks - the delay in ticks

Returns:

the new promise

thenRunDelayed

@Nonnull
default Promise<Void> thenRunDelayed(@Nonnull
                                              ThreadContext context,
                                              @Nonnull
                                              Runnable action,
                                              long delay,
                                              @Nonnull
                                              TimeUnit unit)

Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.

Parameters:

context - the type of executor to use to supply the promise

action - the action to run before completing the returned future

delay - the delay

unit - the unit of delay

Returns:

the new promise

thenRunDelayedSync

@Nonnull
default Promise<Void> thenRunDelayedSync(@Nonnull
                                                  Runnable action,
                                                  long delayTicks)

Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.

Parameters:

action - the action to run before completing the returned future

delayTicks - the delay in ticks

Returns:

the new promise

thenRunDelayedSync

@Nonnull
default Promise<Void> thenRunDelayedSync(@Nonnull
                                                  Runnable action,
                                                  long delay,
                                                  @Nonnull
                                                  TimeUnit unit)

Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.

Parameters:

action - the action to run before completing the returned future

delay - the delay

unit - the unit of delay

Returns:

the new promise

thenRunDelayedAsync

@Nonnull
default Promise<Void> thenRunDelayedAsync(@Nonnull
                                                   Runnable action,
                                                   long delayTicks)

Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.

Parameters:

action - the action to run before completing the returned future

delayTicks - the delay in ticks

Returns:

the new promise

thenRunDelayedAsync

@Nonnull
default Promise<Void> thenRunDelayedAsync(@Nonnull
                                                   Runnable action,
                                                   long delay,
                                                   @Nonnull
                                                   TimeUnit unit)

Returns a new Promise that, when this promise completes normally, executes the given task, after the delay has elapsed.

Parameters:

action - the action to run before completing the returned future

delay - the delay

unit - the unit of delay

Returns:

the new promise

thenCompose

@Nonnull
default <U> Promise<U> thenCompose(@Nonnull
                                            ThreadContext context,
                                            @Nonnull
                                            Function<? super V,? extends Promise<U>> fn)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

fn - the function to use to compute the value

Returns:

the new promise

thenComposeSync

@Nonnull
<U> Promise<U> thenComposeSync(@Nonnull
                                        Function<? super V,? extends Promise<U>> fn)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

Returns:

the new promise

thenComposeAsync

@Nonnull
<U> Promise<U> thenComposeAsync(@Nonnull
                                         Function<? super V,? extends Promise<U>> fn)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

Returns:

the new promise

thenComposeDelayedSync

@Nonnull
default <U> Promise<U> thenComposeDelayedSync(@Nonnull
                                                       ThreadContext context,
                                                       @Nonnull
                                                       Function<? super V,? extends Promise<U>> fn,
                                                       long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

fn - the function to use to compute the value

delayTicks - the delay in ticks

Returns:

the new promise

thenComposeDelayedSync

@Nonnull
default <U> Promise<U> thenComposeDelayedSync(@Nonnull
                                                       ThreadContext context,
                                                       @Nonnull
                                                       Function<? super V,? extends Promise<U>> fn,
                                                       long delay,
                                                       @Nonnull
                                                       TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

context - the type of executor to use to supply the promise

fn - the function to use to compute the value

delay - the delay

unit - the unit of delay

Returns:

the new promise

thenComposeDelayedSync

@Nonnull
<U> Promise<U> thenComposeDelayedSync(@Nonnull
                                               Function<? super V,? extends Promise<U>> fn,
                                               long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

delayTicks - the delay in ticks

Returns:

the new promise

thenComposeDelayedSync

@Nonnull
<U> Promise<U> thenComposeDelayedSync(@Nonnull
                                               Function<? super V,? extends Promise<U>> fn,
                                               long delay,
                                               @Nonnull
                                               TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

delay - the delay

unit - the unit of delay

Returns:

the new promise

thenComposeDelayedAsync

@Nonnull
<U> Promise<U> thenComposeDelayedAsync(@Nonnull
                                                Function<? super V,? extends Promise<U>> fn,
                                                long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

delayTicks - the delay in ticks

Returns:

the new promise

thenComposeDelayedAsync

@Nonnull
<U> Promise<U> thenComposeDelayedAsync(@Nonnull
                                                Function<? super V,? extends Promise<U>> fn,
                                                long delay,
                                                @Nonnull
                                                TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's result as the argument to the given function, after the delay has elapsed.

Type Parameters:

U - the result type

Parameters:

fn - the function to use to compute the value

delay - the delay

unit - the unit of delay

Returns:

the new promise

exceptionally

@Nonnull
default Promise<V> exceptionally(@Nonnull
                                          ThreadContext context,
                                          @Nonnull
                                          Function<Throwable,? extends V> fn)

Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function. Otherwise, if this promise completes normally, then the returned promise also completes normally with the same value.

Parameters:

context - the type of executor to use to supply the promise

fn - the function to use to compute the value of the returned Promise, if this promise completed exceptionally

Returns:

the new promise

exceptionallySync

@Nonnull
Promise<V> exceptionallySync(@Nonnull
                                      Function<Throwable,? extends V> fn)

Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function. Otherwise, if this promise completes normally, then the returned promise also completes normally with the same value.

Parameters:

fn - the function to use to compute the value of the returned Promise, if this promise completed exceptionally

Returns:

the new promise

exceptionallyAsync

@Nonnull
Promise<V> exceptionallyAsync(@Nonnull
                                       Function<Throwable,? extends V> fn)

Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function. Otherwise, if this promise completes normally, then the returned promise also completes normally with the same value.

Parameters:

fn - the function to use to compute the value of the returned Promise, if this promise completed exceptionally

Returns:

the new promise

exceptionallyDelayed

@Nonnull
default Promise<V> exceptionallyDelayed(@Nonnull
                                                 ThreadContext context,
                                                 @Nonnull
                                                 Function<Throwable,? extends V> fn,
                                                 long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed. Otherwise, if this promise completes normally, then the returned promise also completes normally with the same value.

Parameters:

context - the type of executor to use to supply the promise

fn - the function to use to compute the value of the returned Promise, if this promise completed exceptionally

delayTicks - the delay in ticks

Returns:

the new promise

exceptionallyDelayed

@Nonnull
default Promise<V> exceptionallyDelayed(@Nonnull
                                                 ThreadContext context,
                                                 @Nonnull
                                                 Function<Throwable,? extends V> fn,
                                                 long delay,
                                                 @Nonnull
                                                 TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed. Otherwise, if this promise completes normally, then the returned promise also completes normally with the same value.

Parameters:

context - the type of executor to use to supply the promise

fn - the function to use to compute the value of the returned Promise, if this promise completed exceptionally

delay - the delay

unit - the unit of delay

Returns:

the new promise

exceptionallyDelayedSync

@Nonnull
Promise<V> exceptionallyDelayedSync(@Nonnull
                                             Function<Throwable,? extends V> fn,
                                             long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed. Otherwise, if this promise completes normally, then the returned promise also completes normally with the same value.

Parameters:

fn - the function to use to compute the value of the returned Promise, if this promise completed exceptionally

delayTicks - the delay in ticks

Returns:

the new promise

exceptionallyDelayedSync

@Nonnull
Promise<V> exceptionallyDelayedSync(@Nonnull
                                             Function<Throwable,? extends V> fn,
                                             long delay,
                                             @Nonnull
                                             TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed. Otherwise, if this promise completes normally, then the returned promise also completes normally with the same value.

Parameters:

fn - the function to use to compute the value of the returned Promise, if this promise completed exceptionally

delay - the delay

unit - the unit of delay

Returns:

the new promise

exceptionallyDelayedAsync

@Nonnull
Promise<V> exceptionallyDelayedAsync(@Nonnull
                                              Function<Throwable,? extends V> fn,
                                              long delayTicks)

Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed. Otherwise, if this promise completes normally, then the returned promise also completes normally with the same value.

Parameters:

fn - the function to use to compute the value of the returned Promise, if this promise completed exceptionally

delayTicks - the delay in ticks

Returns:

the new promise

exceptionallyDelayedAsync

@Nonnull
Promise<V> exceptionallyDelayedAsync(@Nonnull
                                              Function<Throwable,? extends V> fn,
                                              long delay,
                                              @Nonnull
                                              TimeUnit unit)

Returns a new Promise that, when this promise completes normally, is executed with this promise's exception as the argument to the given function, after the delay has elapsed. Otherwise, if this promise completes normally, then the returned promise also completes normally with the same value.

Parameters:

fn - the function to use to compute the value of the returned Promise, if this promise completed exceptionally

delay - the delay

unit - the unit of delay

Returns:

the new promise

toCompletableFuture

CompletableFuture<V> toCompletableFuture()

Returns a CompletableFuture maintaining the same completion properties as this Promise. A Promise implementation that does not choose to interoperate with CompletableFutures may throw UnsupportedOperationException.

Returns:

the CompletableFuture

Throws:

UnsupportedOperationException - if this implementation does not interoperate with CompletableFuture