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.