vertx / io.vertx.reactivex.core / Future

# Future

`open class Future<T : Any>`

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

NOTE: This class has been automatically generated from the io.vertx.core.Future non RX-ified interface using Vert.x codegen.

### Constructors

<init> | `Future(delegate: Future<Any>)` `Future(delegate: Future<Any>, typeArg_0: TypeArg<T>)`

### Properties

__TYPE_ARG | `static val __TYPE_ARG: TypeArg<Future<Any>>`
__typeArg_0 | `val __typeArg_0: TypeArg<T>`

### Functions

cause | `open fun cause(): Throwable` A Throwable describing failure. This will be null if the operation succeeded.
complete | `open fun complete(result: T): Unit` Set the result. Any handler will be called, if there is one, and the future will be marked as completed. `open fun complete(): Unit` Set a null result. Any handler will be called, if there is one, and the future will be marked as completed.
completer | `open fun completer(): Handler<AsyncResult<T>>`
compose | `open fun <U : Any> compose(handler: Handler<T>, next: Future<U>): Future<U>` Compose this future with a provided `next` future. When this (the one on which `compose` is called) future succeeds, the `handler` will be called with the completed value, this handler should complete the next future. If the `handler` throws an exception, the returned future will be failed with this exception. When this future fails, the failure will be propagated to the `next` future and the `handler` will not be called. `open fun <U : Any> compose(mapper: Function<T, Future<U>>): Future<U>` Compose this future with a `mapper` function. When this future (the one on which `compose` is called) succeeds, the `mapper` 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. 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.
equals | `open fun equals(other: Any?): Boolean`
fail | `open fun fail(cause: Throwable): Unit` Set the failure. Any handler will be called, if there is one, and the future will be marked as completed. `open fun fail(failureMessage: String): Unit` Try to set the failure. When it happens, any handler will be called, if there is one, and the future will be marked as completed.
failed | `open fun failed(): Boolean` Did it fail?
failedFuture | `open static fun <T : Any> failedFuture(t: Throwable): Future<T>` Create a failed future with the specified failure cause. `open static fun <T : Any> failedFuture(failureMessage: String): Future<T>` Create a failed future with the specified failure message.
future | `open static fun <T : Any> future(handler: Handler<Future<T>>): Future<T>` Create a future that hasn't completed yet and that is passed to the `handler` before it is returned. `open static fun <T : Any> future(): Future<T>` Create a future that hasn't completed yet
getDelegate | `open fun getDelegate(): Future<Any>`
hashCode | `open fun hashCode(): Int`
isComplete | `open fun isComplete(): Boolean` Has the future completed? It's completed if it's either succeeded or failed.
map | `open fun <U : Any> map(mapper: Function<T, U>): Future<U>` 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. `open fun <V : Any> map(value: V): Future<V>` 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.
mapEmpty | `open fun <V : Any> mapEmpty(): Future<V>` Map the result of a future to `null`. This is a conveniency for `future.map((T) null)` or `future.map((Void) null)`. When this future succeeds, `null` will complete the future returned by this method call. When this future fails, the failure will be propagated to the returned future.
newInstance | `open static fun <T : Any> newInstance(arg: Future<Any>): Future<T>` `open static fun <T : Any> newInstance(arg: Future<Any>, __typeArg_T: TypeArg<T>): Future<T>`
otherwise | `open fun otherwise(mapper: Function<Throwable, T>): Future<T>` 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. `open fun otherwise(value: T): Future<T>` 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.
otherwiseEmpty | `open fun otherwiseEmpty(): Future<T>` Map the failure of a future to `null`. This is a convenience for `future.otherwise((T) null)`. When this future fails, the `null` value will complete the future returned by this method call. When this future succeeds, the result will be propagated to the returned future.
recover | `open fun recover(mapper: Function<Throwable, Future<T>>): Future<T>` Handles a failure of this Future by returning the result of another Future. If the mapper fails, then the returned future will be failed with this failure.
result | `open fun result(): T` The result of the operation. This will be null if the operation failed.
rxSetHandler | `open fun rxSetHandler(): Single<T>` 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.
setHandler | `open fun setHandler(handler: Handler<AsyncResult<T>>): Future<T>` 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.
succeeded | `open fun succeeded(): Boolean` Did it succeed?
succeededFuture | `open static fun <T : Any> succeededFuture(): Future<T>` Create a succeeded future with a null result `open static fun <T : Any> succeededFuture(result: T): Future<T>` Created a succeeded future with the specified result.
toString | `open fun toString(): String`
tryComplete | `open fun tryComplete(result: T): Boolean` Set the failure. Any handler will be called, if there is one, and the future will be marked as completed. `open fun tryComplete(): Boolean` Try to set the result. When it happens, any handler will be called, if there is one, and the future will be marked as completed.
tryFail | `open fun tryFail(cause: Throwable): Boolean` `open fun tryFail(failureMessage: String): Boolean` Try to set the failure. When it happens, any handler will be called, if there is one, and the future will be marked as completed.

### Inheritors

BaseBridgeEvent | `open class BaseBridgeEvent : Future<Boolean>` Represents an event that occurs on the event bus bridge. Please consult the documentation for a full explanation. NOTE: This class has been automatically generated from the io.vertx.ext.bridge.BaseBridgeEvent non RX-ified interface using Vert.x codegen.
CompositeFuture | `open class CompositeFuture : Future<CompositeFuture>` The composite future wraps a list of io.vertx.reactivex.core.Future, it is useful when several futures needs to be coordinated. The handlers set for the coordinated futures are overridden by the handler of the composite future. NOTE: This class has been automatically generated from the io.vertx.core.CompositeFuture non RX-ified interface using Vert.x codegen.