FluentFuture

Type Parameters:

T - the type of the future value

All Superinterfaces:

Awaitable, Cancellable, Future<T>, com.google.common.util.concurrent.ListenableFuture<T>

All Known Subinterfaces:

FluentRepeatingFuture<T>, FluentScheduledFuture<T>, RepeatingScheduledTask<V>, RunnableFluentFuture<T>, ScheduledTask<V>

All Known Implementing Classes:

AbstractFluentFuture, CombiningFluentFuture, FluentFutureTask, FluentRepeatingFutureTask, FluentScheduledFutureTask, SettableFluentFuture, SettableRunnableFluentFuture
```
public interface FluentFuture<T>
extends com.google.common.util.concurrent.ListenableFuture<T>, Cancellable, Awaitable
```
The future to end all futures. This provides API improvements over the standard Future in several categories:
1. Callbacks: This allows for real asynchronous processing of futures and is what gives this future its name. You can add listeners that are invoked when the future completes.
2. Blocking: This interface extends Awaitable, giving you more API choices for blocking until the future completes (that do not require catching ExecutionException, CancellationException, or TimeoutException).
3. Inspecting: Numerous new methods are provided for inspecting the result of a completed future, none of which require a try/catch block (isSuccessful(), getResult(), isFailed(), getFailure(), and visit(FutureVisitor)). All of these new methods are non-blocking and are intended to assist with implementing listeners and with writing asynchronous code. Many will throw an IllegalStateException if invoked before the future is done.
4. Monadic: This future includes numerous useful default methods, all built on top of the listener primitive, that allow it to be used like a monad, chaining additional operations and applying numerous kinds of transformations.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`void`	`addListener(FutureListener<? super T> listener, Executor executor)` Adds a listener that will be called when the future completes.
`default void`	`addListener(Runnable r, Executor executor)`
`default CompletionStage<T>`	`asCompletionStage()` Returns a view of this future as a `CompletionStage`.
`static <T> FluentFuture<T>`	`cancelledFuture()` Returns a future that has already been cancelled.
`static <T,U extends T> FluentFuture<T>`	`cast(FluentFuture<U> future)` Casts a future to a super-type.
`default <U> FluentFuture<U>`	`chainTo(Callable<U> task, Executor executor)` Chains the specified task to the completion of this future.
`default <U> FluentFuture<U>`	`chainTo(Function<? super T,? extends U> task, Executor executor)` Chains the specified task to the completion of this future.
`default FluentFuture<Void>`	`chainTo(Runnable task, Executor executor)` Chains the specified task to the completion of this future.
`default <U> FluentFuture<U>`	`chainTo(Runnable task, U result, Executor executor)` Chains the specified task to the completion of this future.
`default <U,V> FluentFuture<V>`	`combineWith(FluentFuture<U> other, BiFunction<? super T,? super U,? extends V> function)` Combines this future with another by applying a function.
`default <U,V,W> FluentFuture<W>`	`combineWith(FluentFuture<U> other1, FluentFuture<V> other2, TriFunction<? super T,? super U,? super V,? extends W> function)` Combines this future with two other futures by applying a function.
`static <T> FluentFuture<T>`	`completedFuture(T value)` Returns a future that has already successfully completed with the specified value.
`static <T> FluentFuture<T>`	`deferredCancelledFuture(long delay, TimeUnit unit)` Returns a future that will be cancelled after the given delay.
`static <T> FluentFuture<T>`	`deferredFailedFuture(Throwable failure, long delay, TimeUnit unit)` Returns a future that will fail with the given cause after the given delay.
`static <T> FluentFuture<T>`	`deferredFuture(T value, long delay, TimeUnit unit)` Returns a future that will complete successfully with the given value after the given delay.
`static <T> FluentFuture<T>`	`dereference(FluentFuture<? extends FluentFuture<? extends T>> future)` Dereferences a future future.
`static <T> FluentFuture<T>`	`failedFuture(Throwable failure)` Returns a future that has already failed due to the specified cause.
`static <T> FluentFuture<T>`	`firstOf(FluentFuture<? extends T>... futures)` Returns a future that represents the first future to complete out of the given futures.
`static <T> FluentFuture<T>`	`firstOf(Iterable<FluentFuture<? extends T>> futures)` Returns a future that represents the first future to complete out of the given collection of futures.
`static <T> FluentFuture<T>`	`firstSuccessfulOf(FluentFuture<? extends T>... futures)` Returns a future that represents the first future to successfully complete out of the given futures.
`static <T> FluentFuture<T>`	`firstSuccessfulOf(Iterable<FluentFuture<? extends T>> futures)` Returns a future that represents the first future to successfully complete out of the given collection of futures.
`default <U> FluentFuture<U>`	`flatMap(Function<? super T,? extends FluentFuture<? extends U>> function)` Transforms the result of this future using the specified function.
`static <T> FluentFuture<T>`	`fromCompletionStage(CompletionStage<T> stage)` Converts the given completion stage into a `FluentFuture`.
`Throwable`	`getFailure()` Gets the cause of failure for a future.
`default T`	`getNow(T valueIfIncomplete)` Gets the value of the future or a given default value if the future is not yet complete.
`T`	`getResult()` Gets the result of a successful future.
`boolean`	`isFailed()` Returns true if the future is done and failed.
`boolean`	`isSuccessful()` Returns true if the future is done and was successful.
`static <T> FluentFuture<List<T>>`	`join(FluentFuture<? extends T>... futures)` Joins multiple futures into one future list.
`static <T> FluentFuture<List<T>>`	`join(Iterable<? extends FluentFuture<? extends T>> futures)` Joins a list of futures into one future list.
`static <T> FluentFuture<T>`	`makeFluent(Future<T> future)` Converts the specified future into a `FluentFuture`.
`static <T> FluentScheduledFuture<T>`	`makeFluent(ScheduledFuture<T> future)` Converts the specified future into a `FluentScheduledFuture`.
`default <U> FluentFuture<U>`	`map(Function<? super T,? extends U> function)` Transforms the result of this future using the specified function.
`default FluentFuture<T>`	`mapException(Function<Throwable,? extends Throwable> function)` Transforms any exception from this future using the specified function.
`default <U> FluentFuture<U>`	`mapFuture(Function<? super FluentFuture<T>,? extends U> function)` Transforms this future using the specified function.
`default FluentFuture<T>`	`recover(Function<Throwable,? extends T> function)` Recovers a future value by applying the specified function to any exception from this future.
`static <T> FluentFuture<T>`	`unfinishableFuture()` Returns a future that will never finish.
`void`	`visit(FutureVisitor<? super T> visitor)` Invokes applicable methods on the specified visitor, depending on the disposition of this future.
`default void`	`visitWhenDone(FutureVisitor<? super T> visitor)` Adds a listener that visits this future using a `SameThreadExecutor` when it completes.

Methods inherited from interface java.util.concurrent.Future
cancel, get, get, isCancelled, isDone

Methods inherited from interface com.bluegosling.concurrent.Cancellable
cancel, fromFuture, fromFutures, fromFutures, group, group

Methods inherited from interface com.bluegosling.concurrent.Awaitable
await, await, awaitUninterruptibly, awaitUninterruptibly, fromCondition, fromFuture, fromIntrinsic, fromLatch, fromTerminatingExecutor, isDone

- Method Detail
 - isSuccessful
```
boolean isSuccessful()
```
 Returns true if the future is done and was successful.
 
 Returns:
 
 true if the future is done and was successful; false otherwise
 - getResult
```
T getResult()
```
 Gets the result of a successful future. This method can only be called when the future is done and was successful.
 
 Returns:
 
 the result
 
 Throws:
 
 IllegalStateException - if the future is not complete or was not successful
 - isFailed
```
boolean isFailed()
```
 Returns true if the future is done and failed.
 
 Returns:
 
 true if the future is done and failed; false otherwise
 - getFailure
```
Throwable getFailure()
```
 Gets the cause of failure for a future. This method can only be called when the future is done and has failed.
 
 Returns:
 
 the cause of failure
 
 Throws:
 
 IllegalArgumentException - if the future is not complete, was successful, or was cancelled
 - addListener
```
void addListener(FutureListener<? super T> listener,
 Executor executor)
```
 Adds a listener that will be called when the future completes. The listener will be invoked using the specified executor. If the future is already complete when the listener is added, the listener will be immediately invoked. If the listener can be called synchronously (e.g. it will complete very quickly and not block) then consider using a SameThreadExecutor.
 
 Parameters:
 
 listener - the listener
 
 executor - the executor used when calling the listener
 - addListener
```
default void addListener(Runnable r,
 Executor executor)
```
 Specified by:
 
 addListener in interface com.google.common.util.concurrent.ListenableFuture<T>
 - visit
```
void visit(FutureVisitor<? super T> visitor)
```
 Invokes applicable methods on the specified visitor, depending on the disposition of this future. The future must be complete in order to be visited.
 
 Parameters:
 
 visitor - the visitor
 
 Throws:
 
 IllegalStateException - if the future is not complete
 - cast
```
static <T,U extends T> FluentFuture<T> cast(FluentFuture future)
```
 Casts a future to a super-type. The compiler enforces on invariance on generic types, but this method allows futures to be treated as covariant. Since the target type is a super-type of the future's original type, all instances returned by the original future are also instances of the target type. This combined with the fact that no methods accept the target type means that the covariance is type-safe.
 
 Parameters:
 
 future - a future
 
 Returns:
 
 the same future, but with its type parameter as a super-type of the original
 - getNow
```
default T getNow(T valueIfIncomplete)
```
 Gets the value of the future or a given default value if the future is not yet complete. If the future is complete but finished with a failure or due to cancellation, this method will throw an exception.
 
 Parameters:
 
 valueIfIncomplete - the value to return if the future is not yet complete
 
 Returns:
 
 the future's value or the given value if the future is not yet complete
 
 Throws:
 
 CancellationException - if the future was cancelled
 
 CompletionException - if the future finished with a failure (the cause of the thrown exception will be the cause of the failure)
 - visitWhenDone
```
default void visitWhenDone(FutureVisitor<? super T> visitor)
```
 Adds a listener that visits this future using a SameThreadExecutor when it completes.
 
 Parameters:
 
 visitor - the visitor that will be called once this future completes
 - chainTo
```
default  FluentFuture chainTo(Callable task,
 Executor executor)
```
 Chains the specified task to the completion of this future. The specified task will be initiated once this future completes successfully. The returned future will complete successfully once both this future and the chained task have completed. The returned future will fail if this future fails (in which case the task is never invoked) or if the task throws an exception.
 If this future is cancelled then the returned future will also be cancelled. But not vice versa, so canceling the returned future will not cause this future to be cancelled.
 
 Parameters:
 
 task - a task that should execute when this future completes
 
 executor - the executor used to run the task
 
 Returns:
 
 a future whose value will be the result of the specified task
 - chainTo
```
default  FluentFuture chainTo(Runnable task,
 U result,
 Executor executor)
```
 Chains the specified task to the completion of this future. The specified task will be initiated once this future completes successfully. The returned future will complete successfully once both this future and the chained task have completed. The returned future will fail if this future fails (in which case the task is never invoked) or if the task throws an exception.
 If this future is cancelled then the returned future will also be cancelled. But not vice versa, so canceling the returned future will not cause this future to be cancelled.
 
 Parameters:
 
 task - a task that should execute when the future completes
 
 result - the result of the task when it completes
 
 executor - the executor used to run the task
 
 Returns:
 
 a future that will complete with the specified result when the specified task completes
 - chainTo
```
default FluentFuture<Void> chainTo(Runnable task,
 Executor executor)
```
 Chains the specified task to the completion of this future. The specified task will be initiated once this future completes successfully. The returned future will complete successfully once both this future and the chained task have completed. The returned future will fail if this future fails (in which case the task is never invoked) or if the task throws an exception.
 If this future is cancelled then the returned future will also be cancelled. But not vice versa, so canceling the returned future will not cause this future to be cancelled.
 
 Parameters:
 
 task - a task that should execute when the future completes
 
 executor - the executor used to run the task
 
 Returns:
 
 a future that will complete with a null value when the specified task completes
 - chainTo
```
default  FluentFuture chainTo(Function<? super T,? extends U> task,
 Executor executor)
```
 Chains the specified task to the completion of this future. The specified task will be initiated once this future completes successfully. The returned future will complete successfully once both this future and the chained task have completed. The returned future will fail if this future fails (in which case the task is never invoked) or if the task throws an exception.
 If this future is cancelled then the returned future will also be cancelled. But not vice versa, so canceling the returned future will not cause this future to be cancelled.
 
 Parameters:
 
 task - a task whose input is the result of the specified future
 
 executor - the executor used to run the task
 
 Returns:
 
 a future whose value will be the result of the specified task
 - map
```
default  FluentFuture map(Function<? super T,? extends U> function)
```
 Transforms the result of this future using the specified function. This is similar to using chainTo(Function, Executor) except that no executor is specified. The function will be executed in the same thread that completes the future, so it should run quickly and be safe to run from any thread. The function cannot be interrupted. The returned future will fail if this future fails (in which case the given function is never invoked) or if the function throws an exception.
 Also unlike using chainTo(...), the returned future's cancellation status is kept in sync with this future. So if the returned future is cancelled, this will also be cancelled (if it is not yet done).
 
 Parameters:
 
 function - a function used to compute the transformed value
 
 Returns:
 
 a future that is the result of applying the function to this future value
 - flatMap
```
default  FluentFuture flatMap(Function<? super T,? extends FluentFuture<? extends U>> function)
```
 Transforms the result of this future using the specified function. This is similar to using chainTo(Function, Executor) except that no executor is specified. The function will be executed in the same thread that completes the future, so it should run quickly and be safe to run from any thread. The function cannot be interrupted. The returned future will fail if this future fails (in which case the given function is never invoked) or if the function throws an exception.
 Also unlike using chainTo(...), the returned future's cancellation status is kept in sync with this future. So if the returned future is cancelled, this will also be cancelled (if it is not yet done).
 
 Parameters:
 
 function - a function used to compute the transformed value
 
 Returns:
 
 a future that is the result of applying the function to this future value
 - mapFuture
```
default  FluentFuture mapFuture(Function<? super FluentFuture<T>,? extends U> function)
```
 Transforms this future using the specified function. The given function is applied, even if this future fails. Since the function takes the future as an input, not just its resulting value, the function can then inspect the future to see whether it completed successfully or not. The function is not invoked until the given future is done, so it is safe for it to call getResult(), getFailure(), or visit(FutureVisitor).
 The returned future's cancellation status is kept in sync with the given future. So if the returned future is cancelled, this future is also cancelled (if it is not yet done). Similarly, if this future gets cancelled then the returned future will also be cancelled. The function will not be invoked if this future is cancelled.
 
 Parameters:
 
 function - a function used to compute the transformed value
 
 Returns:
 
 a future that is the result of applying the function to this future after it completes
 - mapException
```
default FluentFuture<T> mapException(Function<Throwable,? extends Throwable> function)
```
 Transforms any exception from this future using the specified function. This is nearly identical to map(Function), except that the function is applied to this future's exception if it fails, not to the future's value if it succeeds. So if this future completes successfully then the given function is never invoked.
 The returned future's cancellation status is kept in sync with the given future. So if the returned future is cancelled, this future is also cancelled (if it is not yet done). Similarly, if this future gets cancelled then the returned future will also be cancelled. The function will not be invoked if this future is cancelled.
 
 Parameters:
 
 function - a function used to compute a new value from an exception
 
 Returns:
 
 a future that, if it fails, will have an exception that is the result of applying the given function to this future's exception
 - recover
```
default FluentFuture<T> recover(Function<Throwable,? extends T> function)
```
 Recovers a future value by applying the specified function to any exception from this future. This is similar to map(Function), except that the function is applied to the future's exception if it fails, instead of being applied to the future's value if it succeeds. If this future completes successfully then the given function is never invoked and the returned future completes with the same value. If this future fails, the function is invoked to compute a value for the returned future. The returned future only fails if that function throws an exception.
 The returned future's cancellation status is kept in sync with the given future. So if the returned future is cancelled, this future is also cancelled (if it is not yet done). Similarly, if this future gets cancelled then the returned future will also be cancelled. The function will not be invoked if this future is cancelled.
 
 Parameters:
 
 function - a function used to compute the transformed exception
 
 Returns:
 
 a future whose result will be that of this future, or if this future fails then then the result of applying a function to its cause of failure
 - combineWith
```
default <U,V> FluentFuture<V> combineWith(FluentFuture other,
 BiFunction<? super T,? super U,? extends V> function)
```
 Combines this future with another by applying a function. The value of the returned future is the result of applying the specified function to the values of the two futures. The returned future will complete successfully when both input futures complete successfully. The returned future will fail if either of the input futures fails (in which case the function is not invoked) or if the given function throws an exception.
 The returned future's cancellation status will be kept in sync with the both input futures. So if the returned future is cancelled, any unfinished input futures will also be cancelled. If either of the input futures is cancelled, the returned future will also be cancelled.
 
 Parameters:
 
 other - another future
 
 function - a function that combines two input values into one result
 
 Returns:
 
 the future result of applying the function to this future value and the other one
 - combineWith
```
default <U,V,W> FluentFuture<W> combineWith(FluentFuture other1,
 FluentFuture<V> other2,
 TriFunction<? super T,? super U,? super V,? extends W> function)
```
 Combines this future with two other futures by applying a function. The value of the returned future is the result of applying the specified function to the values of the three futures. The returned future will complete successfully when all three input futures complete successfully. The returned future will fail if any of the input futures fails (in which case the function is not invoked) or if the given function throws an exception.
 The returned future's cancellation status will be kept in sync with the three input futures. So if the returned future is cancelled, any unfinished input futures will also be cancelled. If any of the input futures is cancelled, the returned future will also be cancelled.
 
 Parameters:
 
 other1 - another future
 
 other2 - yet another future
 
 function - a function that combines three input values into one result
 
 Returns:
 
 the future result of applying the function to this future value the other two
 - asCompletionStage
```
default CompletionStage<T> asCompletionStage()
```
 Returns a view of this future as a CompletionStage.
 
 Returns:
 
 a view of this future as a completion stage
 - fromCompletionStage
```
static <T> FluentFuture<T> fromCompletionStage(CompletionStage<T> stage)
```
 Converts the given completion stage into a FluentFuture.
 
 Parameters:
 
 stage - a completion stage
 
 Returns:
 
 a view of the stage as a future
 - makeFluent
```
static <T> FluentFuture<T> makeFluent(Future<T> future)
```
 Converts the specified future into a FluentFuture. If the specified future is a FluentFuture, it is returned without any conversion. Note that if the specified future is not yet done and is not a CompletableFuture, conversion requires creating a new thread that simply blocks until the specified future completes, at which time the returned fluent future is also completed (asynchronously).
 The returned future's cancellation status will be kept in sync with the specified future. So if the returned future is cancelled, so too will the underlying future be cancelled, and vice versa.
 
 Parameters:
 
 future - the future
 
 Returns:
 
 a fluent version of the specified future
 - makeFluent
```
static <T> FluentScheduledFuture<T> makeFluent(ScheduledFuture<T> future)
```
 Converts the specified future into a FluentScheduledFuture. If the specified future is a FluentScheduledFuture, it is returned without any conversion. Note that if the specified future is not yet done, conversion requires creating a new thread. The thread simply blocks until the specified future completes, at which time the returned fluent future is also completed (asynchronously).
 The returned future's cancellation status will be kept in sync with the specified future. So if the returned future is cancelled, so too will the underlying future be cancelled, and vice versa.
 
 Parameters:
 
 future - the scheduled future
 
 Returns:
 
 a fluent version of the specified future
 - completedFuture
```
static <T> FluentFuture<T> completedFuture(T value)
```
 Returns a future that has already successfully completed with the specified value.
 
 Parameters:
 
 value - the future result
 
 Returns:
 
 a future that is immediately done
 - failedFuture
```
static <T> FluentFuture<T> failedFuture(Throwable failure)
```
 Returns a future that has already failed due to the specified cause.
 
 Parameters:
 
 failure - the cause of future failure
 
 Returns:
 
 a future that is immediately done
 - cancelledFuture
```
static <T> FluentFuture<T> cancelledFuture()
```
 Returns a future that has already been cancelled.
 
 Returns:
 
 a future that is immediately done
 - deferredFuture
```
static <T> FluentFuture<T> deferredFuture(T value,
 long delay,
 TimeUnit unit)
```
 Returns a future that will complete successfully with the given value after the given delay. This future may not complete successfully if it is cancelled before the delay elapses.
 
 Parameters:
 
 value - the future value
 
 delay - the time after which the future completes
 
 unit - the unit for the given delay
 
 Returns:
 
 a future that will complete successfully with the given value after the given delay
 - deferredFailedFuture
```
static <T> FluentFuture<T> deferredFailedFuture(Throwable failure,
 long delay,
 TimeUnit unit)
```
 Returns a future that will fail with the given cause after the given delay. This future may not fail with the given cause if it is cancelled before the delay elapses.
 
 Parameters:
 
 failure - the cause of future failure
 
 delay - the time after which the future completes
 
 unit - the unit for the given delay
 
 Returns:
 
 a future that will fail with the given cause after the given delay
 - deferredCancelledFuture
```
static <T> FluentFuture<T> deferredCancelledFuture(long delay,
 TimeUnit unit)
```
 Returns a future that will be cancelled after the given delay. This future may complete before the given delay elapses if it is cancelled.
 
 Parameters:
 
 delay - the time after which the future is cancelled
 
 unit - the unit for the given delay
 
 Returns:
 
 a future that will be cancelled after the given delay
 - unfinishableFuture
```
static <T> FluentFuture<T> unfinishableFuture()
```
 Returns a future that will never finish. This can be useful in some circumstances for asynchronous functional idioms, and also for testing.
 The returned future cannot be used with blocking calls, since they would never return or always timeout. So calls to both forms of Future.get() and both forms of Awaitable.await() all throw UnsupportedOperationException.
 Additionally, the future cannot be cancelled (as that would implicitly finish it). So calls to Future.cancel(boolean) always return false but don't actually cause the future to become cancelled.
 
 Returns:
 
 a future that will never finish
 - join
```
@SafeVarargs
static <T> FluentFuture<List<T>> join(FluentFuture<? extends T>... futures)
```
 Joins multiple futures into one future list. The returned future will complete successfully once all constituent futures complete successfully. The returned future will fail if any of the constituent futures fails.
 The returned future's cancellation status will be kept in sync with the constituent futures. So if the returned future is cancelled, any unfinished constituent futures will also be cancelled. If any of the constituent futures is cancelled, the returned future will also be cancelled.
 
 Parameters:
 
 futures - the future values
 
 Returns:
 
 a future list whose elements are the values from the specified futures
 - join
```
static <T> FluentFuture<List<T>> join(Iterable<? extends FluentFuture<? extends T>> futures)
```
 Joins a list of futures into one future list. The returned future will complete successfully once all constituent futures complete successfully. The returned future will fail if any of the constituent futures fails.
 The returned future's cancellation status will be kept in sync with the constituent futures. So if the returned future is cancelled, any unfinished constituent futures will also be cancelled. If any of the constituent futures is cancelled, the returned future will also be cancelled.
 
 Parameters:
 
 futures - the future values
 
 Returns:
 
 a future list whose elements are the values from the specified futures
 - firstOf
```
@SafeVarargs
static <T> FluentFuture<T> firstOf(FluentFuture<? extends T>... futures)
```
 Returns a future that represents the first future to complete out of the given futures. The returned future could be a failed future if the first future to complete fails. When an input future is cancelled, it is ignored unless all of the given futures are cancelled, in which case the returned future will also be cancelled.
 If the returned future is cancelled, it will in turn result in all of the input futures being cancelled.
 Note that this method does not block for completion of any future. It instead returns a new future that is completed upon the first given future completing.
 
 Parameters:
 
 futures - an array of futures
 
 Returns:
 
 a future that represents the first of the given futures to complete
 
 Throws:
 
 IllegalArgumentException - if the given array of futures is empty
 - firstOf
```
static <T> FluentFuture<T> firstOf(Iterable<FluentFuture<? extends T>> futures)
```
 Returns a future that represents the first future to complete out of the given collection of futures. The returned future could be a failed future if the first future to complete fails. When an input future is cancelled, it is ignored unless all of the given futures are cancelled, in which case the returned future will also be cancelled.
 If the returned future is cancelled, it will in turn result in all of the input futures being cancelled.
 Note that this method does not block for completion of any future. It instead returns a new future that is completed upon the first given future completing.
 
 Parameters:
 
 futures - a collection of futures
 
 Returns:
 
 a future that represents the first of the given futures to complete
 
 Throws:
 
 IllegalArgumentException - if the given collection of futures is empty
 - firstSuccessfulOf
```
@SafeVarargs
static <T> FluentFuture<T> firstSuccessfulOf(FluentFuture<? extends T>... futures)
```
 Returns a future that represents the first future to successfully complete out of the given futures. The returned future will only failed if all of the given futures fail. When an input future is cancelled, it is ignored unless all of the given futures are cancelled, in which case the returned future will also be cancelled. If all input futures either fail or are cancelled, then the returned future will either fail or be cancelled depending on the disposition of the last input future to complete.
 If the returned future is cancelled, it will in turn result in all of the input futures being cancelled.
 Note that this method does not block for completion of any future. It instead returns a new future that is completed upon the first given future successfully completing.
 
 Parameters:
 
 futures - an array of futures
 
 Returns:
 
 a future that represents the first of the given futures to complete successfully
 
 Throws:
 
 IllegalArgumentException - if the given array of futures is empty
 - firstSuccessfulOf
```
static <T> FluentFuture<T> firstSuccessfulOf(Iterable<FluentFuture<? extends T>> futures)
```
 Returns a future that represents the first future to successfully complete out of the given collection of futures. The returned future will only failed if all of the given futures fail. When an input future is cancelled, it is ignored unless all of the given futures are cancelled, in which case the returned future will also be cancelled. If all input futures either fail or are cancelled, then the returned future will either fail or be cancelled depending on the disposition of the last input future to complete.
 If the returned future is cancelled, it will in turn result in all of the input futures being cancelled.
 Note that this method does not block for completion of any future. It instead returns a new future that is completed upon the first given future successfully completing.
 
 Parameters:
 
 futures - a collection of futures
 
 Returns:
 
 a future that represents the first of the given futures to complete successfully
 
 Throws:
 
 IllegalArgumentException - if the given collection of futures is empty
 - dereference
```
static <T> FluentFuture<T> dereference(FluentFuture<? extends FluentFuture<? extends T>> future)
```
 Dereferences a future future. The returned future will complete successfully when the specified future and its value complete. The future will fail if either the input future or its value fails.
 The returned future's cancellation status will be kept in sync with the input futures. So if the returned future is cancelled, the input future or its value will also be cancelled. If the input future or its value is cancelled, the returned future will also be cancelled.
 
 Parameters:
 
 future - the future future
 
 Returns:
 
 a future value that represents the value of the future future

Interface FluentFuture<T>

Method Summary

Methods inherited from interface java.util.concurrent.Future

Methods inherited from interface com.bluegosling.concurrent.Cancellable

Methods inherited from interface com.bluegosling.concurrent.Awaitable

Method Detail

isSuccessful

getResult

isFailed

getFailure

addListener

addListener

visit

cast

getNow

visitWhenDone

chainTo

chainTo

chainTo

chainTo

map

flatMap

mapFuture

mapException

recover

combineWith

combineWith

asCompletionStage

fromCompletionStage

makeFluent

makeFluent

completedFuture

failedFuture

cancelledFuture

deferredFuture

deferredFailedFuture

deferredCancelledFuture

unfinishableFuture

join

join

firstOf

firstOf

firstSuccessfulOf

firstSuccessfulOf

dereference