io.vertx.core

Interface Future<T>

All Superinterfaces:

AsyncResult<T>

All Known Subinterfaces:

CompositeFuture

public interface Future<T>
extends AsyncResult<T>

Represents the result of an action that may, or may not, have occurred yet.

Author:

Tim Fox

Field Summary

Fields

Modifier and Type	Field and Description
static FutureFactory	factory

Method Summary

Modifier and Type	Method and Description
Throwable	cause() A Throwable describing failure.
void	complete() Set a null result.
void	complete(T result) Set the result.
default Handler<AsyncResult<T>>	completer()
default <U> void	compose(Handler<T> handler, Future<U> next) Compose this future with another future.
void	fail(String failureMessage) Set the failure.
void	fail(Throwable throwable) Set the failure.
boolean	failed() Did it fail?
static <T> Future<T>	failedFuture(String failureMessage) Create a failed future with the specified failure message.
static <T> Future<T>	failedFuture(Throwable t) Create a failed future with the specified failure cause.
static <T> Future<T>	future() Create a future that hasn't completed yet
boolean	isComplete() Has the future completed?
T	result() The result of the operation.
Future<T>	setHandler(Handler<AsyncResult<T>> handler) Set a handler for the result.
boolean	succeeded() Did it succeed?
static <T> Future<T>	succeededFuture() Create a succeeded future with a null result
static <T> Future<T>	succeededFuture(T result) Created a succeeded future with the specified result.

Field Detail

factory

static final FutureFactory factory

Method Detail

future

static <T> Future<T> future()

Create a future that hasn't completed yet

Type Parameters:

T - the result type

Returns:

the future

succeededFuture

static <T> Future<T> succeededFuture()

Create a succeeded future with a null result

Type Parameters:

T - the result type

Returns:

the future

succeededFuture

static <T> Future<T> succeededFuture(T result)

Created a succeeded future with the specified result.

Type Parameters:

T - the result type

Parameters:

result - the result

Returns:

the future

failedFuture

static <T> Future<T> failedFuture(Throwable t)

Create a failed future with the specified failure cause.

Type Parameters:

T - the result type

Parameters:

t - the failure cause as a Throwable

Returns:

the future

failedFuture

static <T> Future<T> failedFuture(String failureMessage)

Create a failed future with the specified failure message.

Type Parameters:

T - the result type

Parameters:

failureMessage - the failure message

Returns:

the future

isComplete

boolean isComplete()

Has the future completed?

It's completed if it's either succeeded or failed.

Returns:

true if completed, false if not

setHandler

Future<T> setHandler(Handler<AsyncResult<T>> handler)

Set a handler for the result.

If the future has already been completed it will be called immediately. Otherwise it will be called when the future is completed.

Parameters:

handler - the Handler that will be called with the result

Returns:

a reference to this, so it can be used fluently

complete

void complete(T result)

Set the result. Any handler will be called, if there is one, and the future will be marked as completed.

Parameters:

result - the result

Throws:

IllegalStateException - when the future is already completed

complete

void complete()

Set a null result. Any handler will be called, if there is one, and the future will be marked as completed.

Throws:

IllegalStateException - when the future is already completed

fail

void fail(Throwable throwable)

Set the failure. Any handler will be called, if there is one, and the future will be marked as completed.

Parameters:

throwable - the failure cause

fail

void fail(String failureMessage)

Set the failure. Any handler will be called, if there is one, and the future will be marked as completed.

Parameters:

failureMessage - the failure message

result

T result()

The result of the operation. This will be null if the operation failed.

Specified by:

result in interface AsyncResult<T>

Returns:

the result or null if the operation failed.

cause

Throwable cause()

A Throwable describing failure. This will be null if the operation succeeded.

Specified by:

cause in interface AsyncResult<T>

Returns:

the cause or null if the operation succeeded.

succeeded

boolean succeeded()

Did it succeed?

Specified by:

succeeded in interface AsyncResult<T>

Returns:

true if it succeded or false otherwise

failed

boolean failed()

Did it fail?

Specified by:

failed in interface AsyncResult<T>

Returns:

true if it failed or false otherwise

compose

default <U> void compose(Handler<T> handler,
                         Future<U> next)

Compose this future with another future. When this future succeeds, the handler will be called with the value. When this future fails, the failure will be propagated to the next future.

Parameters:

handler - the handler

next - the next future

completer

default Handler<AsyncResult<T>> completer()

Returns:

an handler completing this future