SucceededFuture (Vertx Javadocs 4.0.3.GA API)

java.lang.Object
- io.vertx.core.impl.future.SucceededFuture<T>

All Implemented Interfaces:

AsyncResult<T>, Future<T>, FutureInternal<T>
```
public final class SucceededFuture<T>
extends Object
```
Succeeded future implementation.

Author:

Julien Viet

Field Summary

Fields
Modifier and Type Field and Description

protected ContextInternal context

static SucceededFuture EMPTY
Stateless instance of empty results that can be shared safely.

Fields
Modifier and Type	Field and Description
`protected ContextInternal`	`context`
`static SucceededFuture`	`EMPTY` Stateless instance of empty results that can be shared safely.

Constructor Summary

Constructors
Constructor and Description
`SucceededFuture(ContextInternal context, T result)` Create a future that has already succeeded
`SucceededFuture(T result)` Create a future that has already succeeded

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addListener(Listener<T> listener)` Add a listener to the future result.
`Throwable`	`cause()` A Throwable describing failure.
`<U> Future<U>`	`compose(Function<T,Future<U>> successMapper, Function<Throwable,Future<U>> failureMapper)` Compose this future with a `successMapper` and `failureMapper` functions.
`ContextInternal`	`context()`
`protected <U> void`	`emit(U value, Handler<U> handler)`
`protected void`	`emitFailure(Throwable cause, Listener<T> listener)`
`protected void`	`emitSuccess(T value, Listener<T> listener)`
`<U> Future<T>`	`eventually(Function<Void,Future<U>> mapper)` Compose this future with a `mapper` that will be always be called.
`boolean`	`failed()` Did it fail?
`boolean`	`isComplete()` Has the future completed?
`<U> Future<U>`	`map(Function<T,U> mapper)` Apply a `mapper` function on this future.
`<V> Future<V>`	`map(V value)` Map the result of a future to a specific `value`.
`Future<T>`	`onComplete(Handler<AsyncResult<T>> handler)` Add a handler to be notified of the result.
`Future<T>`	`onFailure(Handler<Throwable> handler)` Add a handler to be notified of the failed result.
`Future<T>`	`onSuccess(Handler<T> handler)` Add a handler to be notified of the succeeded result.
`Future<T>`	`otherwise(Function<Throwable,T> mapper)` Apply a `mapper` function on this future.
`Future<T>`	`otherwise(T value)` Map the failure of a future to a specific `value`.
`T`	`result()` The result of the operation.
`boolean`	`succeeded()` Did it succeed?
`String`	`toString()`
`<U> Future<U>`	`transform(Function<AsyncResult<T>,Future<U>> mapper)` Transform this future with a `mapper` functions.

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

Methods inherited from interface io.vertx.core.Future
compose, failedFuture, failedFuture, flatMap, fromCompletionStage, fromCompletionStage, future, mapEmpty, otherwiseEmpty, recover, succeededFuture, succeededFuture, toCompletionStage

- Field Detail
 - EMPTY
```
public static final SucceededFuture EMPTY
```
 Stateless instance of empty results that can be shared safely.
 - context
```
protected final ContextInternal context
```
- Constructor Detail
 - SucceededFuture
```
public SucceededFuture(T result)
```
 Create a future that has already succeeded
 
 Parameters:
 
 result - the result
 - SucceededFuture
```
public SucceededFuture(ContextInternal context,
 T result)
```
 Create a future that has already succeeded
 
 Parameters:
 
 context - the context
 
 result - the result
- Method Detail
 - isComplete
```
public boolean isComplete()
```
 Description copied from interface: Future
 
 Has the future completed?
 It's completed if it's either succeeded or failed.
 
 Returns:
 
 true if completed, false if not
 - onSuccess
```
public Future<T> onSuccess(Handler<T> handler)
```
 Description copied from interface: Future
 
 Add a handler to be notified of the succeeded result.
 
 Parameters:
 
 handler - the handler that will be called with the succeeded result
 
 Returns:
 
 a reference to this, so it can be used fluently
 - onFailure
```
public Future<T> onFailure(Handler<Throwable> handler)
```
 Description copied from interface: Future
 
 Add a handler to be notified of the failed result.
 
 Parameters:
 
 handler - the handler that will be called with the failed result
 
 Returns:
 
 a reference to this, so it can be used fluently
 - onComplete
```
public Future<T> onComplete(Handler<AsyncResult<T>> handler)
```
 Description copied from interface: Future
 
 Add a handler to be notified of the result.
 
 Parameters:
 
 handler - the handler that will be called with the result
 
 Returns:
 
 a reference to this, so it can be used fluently
 - addListener
```
public void addListener(Listener<T> listener)
```
 Description copied from interface: FutureInternal
 
 Add a listener to the future result.
 
 Parameters:
 
 listener - the listener
 - result
```
public T result()
```
 Description copied from interface: AsyncResult
 
 The result of the operation. This will be null if the operation failed.
 
 Returns:
 
 the result or null if the operation failed.
 - cause
```
public Throwable cause()
```
 Description copied from interface: AsyncResult
 
 A Throwable describing failure. This will be null if the operation succeeded.
 
 Returns:
 
 the cause or null if the operation succeeded.
 - succeeded
```
public boolean succeeded()
```
 Description copied from interface: AsyncResult
 
 Did it succeed?
 
 Returns:
 
 true if it succeded or false otherwise
 - failed
```
public boolean failed()
```
 Description copied from interface: AsyncResult
 
 Did it fail?
 
 Returns:
 
 true if it failed or false otherwise
 - map
```
public <V> Future<V> map(V value)
```
 Description copied from interface: Future
 
 Map the result of a future to a specific value.
 When this future succeeds, this value will complete the future returned by this method call.
 When this future fails, the failure will be propagated to the returned future.
 
 Specified by:
 
 map in interface AsyncResult<T>
 
 Specified by:
 
 map in interface Future<T>
 
 Parameters:
 
 value - the value that eventually completes the mapped future
 
 Returns:
 
 the mapped future
 - otherwise
```
public Future<T> otherwise(Function<Throwable,T> mapper)
```
 Description copied from interface: Future
 
 Apply a mapper function on this future.
 When this future fails, the mapper will be called with the completed value and this mapper returns a value. This value will complete the future returned by this method call.
 If the mapper throws an exception, the returned future will be failed with this exception.
 When this future succeeds, the result will be propagated to the returned future and the mapper will not be called.
 
 Specified by:
 
 otherwise in interface AsyncResult<T>
 
 Specified by:
 
 otherwise in interface Future<T>
 
 Parameters:
 
 mapper - the mapper function
 
 Returns:
 
 the mapped future
 - otherwise
```
public Future<T> otherwise(T value)
```
 Description copied from interface: Future
 
 Map the failure of a future to a specific value.
 When this future fails, this value will complete the future returned by this method call.
 When this future succeeds, the result will be propagated to the returned future.
 
 Specified by:
 
 otherwise in interface AsyncResult<T>
 
 Specified by:
 
 otherwise in interface Future<T>
 
 Parameters:
 
 value - the value that eventually completes the mapped future
 
 Returns:
 
 the mapped future
 - toString
```
public String toString()
```
 Overrides:
 
 toString in class Object
 - context
```
public final ContextInternal context()
```
 Specified by:
 
 context in interface FutureInternal<T>
 
 Returns:
 
 the context associated with this promise or null when there is none
 - emitSuccess
```
protected final void emitSuccess(T value,
 Listener<T> listener)
```
 - emitFailure
```
protected final void emitFailure(Throwable cause,
 Listener<T> listener)
```
 - emit
```
protected final  void emit(U value,
 Handler handler)
```
 - compose
```
public  Future compose(Function<T,Future> successMapper,
 Function<Throwable,Future> failureMapper)
```
 Description copied from interface: Future
 
 Compose this future with a successMapper and failureMapper functions.
 When this future (the one on which compose is called) succeeds, the successMapper will be called with the completed value and this mapper returns another future object. This returned future completion will complete the future returned by this method call.
 When this future (the one on which compose is called) fails, the failureMapper will be called with the failure and this mapper returns another future object. This returned future completion will complete the future returned by this method call.
 If any mapper function throws an exception, the returned future will be failed with this exception.
 
 Specified by:
 
 compose in interface Future<T>
 
 Parameters:
 
 successMapper - the function mapping the success
 
 failureMapper - the function mapping the failure
 
 Returns:
 
 the composed future
 - transform
```
public  Future transform(Function<AsyncResult<T>,Future> mapper)
```
 Description copied from interface: Future
 
 Transform this future with a mapper functions.
 When this future (the one on which transform is called) completes, the mapper will be called with the async result and this mapper returns another future object. This returned future completion will complete the future returned by this method call.
 If any mapper function throws an exception, the returned future will be failed with this exception.
 
 Specified by:
 
 transform in interface Future<T>
 
 Parameters:
 
 mapper - the function mapping the future
 
 Returns:
 
 the transformed future
 - eventually
```
public  Future<T> eventually(Function<Void,Future> mapper)
```
 Description copied from interface: Future
 
 Compose this future with a mapper that will be always be called.
 When this future (the one on which eventually is called) completes, the mapper will be called and this mapper returns another future object. This returned future completion will complete the future returned by this method call with the original result of the future.
 The outcome of the future returned by the mapper will not influence the the nature of the returned future.
 
 Specified by:
 
 eventually in interface Future<T>
 
 Parameters:
 
 mapper - the function returning the future.
 
 Returns:
 
 the composed future
 - map
```
public  Future map(Function<T,U> mapper)
```
 Description copied from interface: Future
 
 Apply a mapper function on this future.
 When this future succeeds, the mapper will be called with the completed value and this mapper returns a value. This value will complete the future returned by this method call.
 If the mapper throws an exception, the returned future will be failed with this exception.
 When this future fails, the failure will be propagated to the returned future and the mapper will not be called.
 
 Specified by:
 
 map in interface AsyncResult<T>
 
 Specified by:
 
 map in interface Future<T>
 
 Parameters:
 
 mapper - the mapper function
 
 Returns:
 
 the mapped future

Class SucceededFuture<T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.vertx.core.Future

Field Detail

EMPTY

context

Constructor Detail

SucceededFuture

SucceededFuture

Method Detail

isComplete

onSuccess

onFailure

onComplete

addListener

result

cause

succeeded

failed

map

otherwise

otherwise

toString

context

emitSuccess

emitFailure

emit

compose

transform

eventually

map