Creates a promise that triggers the provided handlers in case it receives an interrupt. @param handlers the list of handlers to be triggered. @retur

Blocks the current thread until this future is satisfied and gets its result. This method normally only useful for tests, avoid it for production cod

Creates a successful future. @param v the value that satisfies the future. @param <T> the type of the value. @return the successful future.

Completes this promise with value. @param value the result.

Maps the result of this future to another value. @param f the mapping function. @return a future transformed by the mapping function.

Creates a failed future. @param ex the failure. @param <T> the type of the failed future. @return the failed future.

Sets the value of the local. It's similar to update but receives an optional value. @param opt optional value to set.

Becomes another future. This and result become the same: both are completed with the same result and both receive the same interrupt signals. @param

Maps the result of this future to another future and flattens the result. @param f the mapping function that returns another future instance. @retur

This method is similar to collect, but it discards the result of the futures. It's useful to wait for a list of pending future side effects. @param l

Becomes another future only if this promise is undefined. This and result become the same: both are completed with the same result and both receive th

Completes this promise with a failure ex. @param ex the failure.

Runs r when this future completes. @param r the Runnable to be executed. @return a future that completes with the result of this after r is

Transforms a list of futures into a future of a list. @param list the futures to collect from @return a future that is satisfied with the futur

Checks if this future is completed. @return true if completed, false if not completed.

Updates the local with the provided value. @param value value to set

Creates a new local value. @param <T> the type of the local value. @return the local value

Creates a future with the result of the supplier. Note that the supplier is executed by the current thread. Use FuturePool.async to execute the suppli

Maps the result of this future using the provided Transformer. If this future completes successfully, transformer.onValue is called. If this future co

Creates a future that fails with a TimeoutException if this future isn't completed within the timeout. @param timeout how long to wait for the res

Creates an interrupt handle that calls multiple handlers. @param handlers list of handlers to be called. @return the aggregate interrupt ha

Selects the index of the first satisfied future. @param list the list of futures to select from @return a future with the index of the first sa

Delays the result of this future. It method doesn't take in consideration how long this future takes to be completed. It assumes the state of this fut

Finds the first future that completes. @param list futures to select from. @return a future that is satisfied with the result of the first futu

Executes the Responder once this future completes. If this future completes successfully, responder.onValue is called. If this future completes with a

Waits for this and other (running in parallel), maps the result with f, and flattens the result. @param other The other future that becomes the seco

Waits for this and other (running in parallel) and then maps the result with f. @param other The other future that becomes the second parameter of f

Executes the Consumer if this future completes with an exception. @param c the Consumer to be executed. @return a future that completes with the r

Proxies the result of this future, successful or not, to a Promise. @param p the Promise to be updated once this future completes.

If this future completes with an exception, applies the provided rescue function and flattens the result. Note that it's possible to return a Future.

Maps the result of this future using a Transformer that returns another future and flattens the result. If this future completes successfully, transfo

Creates a future that is satisfied with void when this future completes. @return the voided future.

Executes the Consumer if this future completes successfully. @param c the Consumer to be executed. @return a future that completes with the result

toString

Creates a future that will be completed with the interrupt exception if an interrupt is received. @return the interruptible future.

Casts the result of this future. Avoid this method since it's unsafe and can produce a future failed with a ClassCastException. @return the casted

Creates a new future pool. @param executor the executor used to schedule tasks. @return the new future pool.

Isolates the execution of the supplier on this future pool. @param s the supplier. @return a future with the result of the supplier.

Runs the recursive future using the default batch size. @param sup the supplier to be called on each recursion. @return the stack-safe recursive

Creates a new promise using a handler builder that it's based on the promise under creation. This method allows the user to define handlers that use t

Returns a satisfied future with an immutable empty list. @return the empty list future. @param <T> the list type

Method called when the future completes with an exception. @param ex the failure

Method called when the future completes with a value. @param value the value.

Raises an interrupt. @param ex the interrupt exception.

Applies the provided supplier and flattens the result. This method is useful to apply a supplier safely without having to catch possible synchronous e

Flattens a nested future. The usage of this method indicates a code smell: a map may have been used instead of flatMap. There are genuine scenarios wh

Executes the supplier with the provided value and then rolls back to the previous local value. @param value value to be set. @param s supplier

Returns a void future that is satisfied after the specified delay. It's a shortcut for `Future.VOID.delayed(delay, scheduler)` @param delay for

Returns a satisfied future with an empty optional. @return the empty optional future. @param <T> the optional type