io.vertx.rxjava.core

## Class Future<T>

- java.lang.Object
- - io.vertx.rxjava.core.Future<T>

- Direct Known Subclasses:
    BridgeEvent, CompositeFuture

      public class Future<T>
      extends Object

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

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static TypeArg<Future>` | `__TYPE_ARG`
    `TypeArg<T>` | `__typeArg_0`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Future(Future delegate)`
    `Future(Future delegate, TypeArg<T> typeArg_0)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    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.
    `Handler<AsyncResult<T>>` | `completer()`
    `<U> Future<U>` | `compose(java.util.function.Function<T,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<U> Future<U>` | `compose(Handler<T> handler, Future<U> next)` Compose this future with a provided `next` future.
    `void` | `fail(String failureMessage)` Try to set the failure.
    `void` | `fail(Throwable cause)` 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
    `static <T> Future<T>` | `future(Handler<Future<T>> handler)` Create a future that hasn't completed yet and that is passed to the `handler` before it is returned.
    `Future` | `getDelegate()`
    `boolean` | `isComplete()` Has the future completed?
    `<U> Future<U>` | `map(java.util.function.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`.
    `<V> Future<V>` | `mapEmpty()` Map the result of a future to `null`.
    `static <T> Future` | `newInstance(Future arg)`
    `static <T> Future` | `newInstance(Future arg, TypeArg<T> __typeArg_T)`
    `Future<T>` | `otherwise(java.util.function.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`.
    `Future<T>` | `otherwiseEmpty()` Map the failure of a future to `null`.
    `Future<T>` | `recover(java.util.function.Function<Throwable,Future<T>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `T` | `result()` The result of the operation.
    `rx.Single<T>` | `rxSetHandler()` Set a handler for the result.
    `Future<T>` | `setHandler(Handler<AsyncResult<T>> handler)` Set a handler for the result.
    `rx.Observable<T>` | `setHandlerObservable()` Deprecated. use `rxSetHandler()` instead
    `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.
    `boolean` | `tryComplete()` Try to set the result.
    `boolean` | `tryComplete(T result)` Set the failure.
    `boolean` | `tryFail(String failureMessage)` Try to set the failure.
    `boolean` | `tryFail(Throwable cause)` Try to set the failure.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final TypeArg<Future> __TYPE_ARG

    - #### __typeArg_0

          public final TypeArg<T> __typeArg_0

  - ### Constructor Detail

    - #### Future

          public Future(Future delegate)

    - #### Future

          public Future(Future delegate,
                        TypeArg<T> typeArg_0)

  - ### Method Detail

    - #### getDelegate

          public Future getDelegate()

    - #### future

          public static <T> Future<T> future(Handler<Future<T>> handler)

      Create a future that hasn't completed yet and that is passed to the `handler` before it is returned.
      Parameters:
        `handler` - the handler
      Returns:
        the future.

    - #### future

          public static <T> Future<T> future()

      Create a future that hasn't completed yet
      Returns:
        the future

    - #### succeededFuture

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

      Create a succeeded future with a null result
      Returns:
        the future

    - #### succeededFuture

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

      Created a succeeded future with the specified result.
      Parameters:
        `result` - the result
      Returns:
        the future

    - #### failedFuture

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

      Create a failed future with the specified failure cause.
      Parameters:
        `t` - the failure cause as a Throwable
      Returns:
        the future

    - #### failedFuture

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

      Create a failed future with the specified failure message.
      Parameters:
        `failureMessage` - the failure message
      Returns:
        the future

    - #### isComplete

          public boolean isComplete()

      Has the future completed?

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

      Returns:
        true if completed, false if not

    - #### setHandler

          public 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

    - #### setHandlerObservable

          @Deprecated
          public rx.Observable<T> setHandlerObservable()

      Deprecated. use `rxSetHandler()` instead
      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.

      Returns:

    - #### rxSetHandler

          public rx.Single<T> rxSetHandler()

      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.

      Returns:

    - #### complete

          public 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

    - #### complete

          public void complete()

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

    - #### fail

          public void fail(Throwable cause)

      Set the failure. Any handler will be called, if there is one, and the future will be marked as completed.
      Parameters:
        `cause` - the failure cause

    - #### fail

          public void fail(String failureMessage)

      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.
      Parameters:
        `failureMessage` - the failure message

    - #### tryComplete

          public boolean tryComplete(T result)

      Set the failure. Any handler will be called, if there is one, and the future will be marked as completed.
      Parameters:
        `result` - the result
      Returns:
        false when the future is already completed

    - #### tryComplete

          public boolean tryComplete()

      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.
      Returns:
        false when the future is already completed

    - #### tryFail

          public boolean tryFail(Throwable cause)

      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.
      Parameters:
        `cause` - the failure cause
      Returns:
        false when the future is already completed

    - #### tryFail

          public boolean tryFail(String failureMessage)

      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.
      Parameters:
        `failureMessage` - the failure message
      Returns:
        false when the future is already completed

    - #### result

          public T result()

      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()

      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()

      Did it succeed?
      Returns:
        true if it succeded or false otherwise

    - #### failed

          public boolean failed()

      Did it fail?
      Returns:
        true if it failed or false otherwise

    - #### compose

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

      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.

      Parameters:
        `handler` - the handler
        `next` - the next future
      Returns:
        the next future, used for chaining

    - #### compose

          public <U> Future<U> compose(java.util.function.Function<T,Future<U>> mapper)

      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.

      Parameters:
        `mapper` - the mapper function
      Returns:
        the composed future

    - #### map

          public <U> Future<U> map(java.util.function.Function<T,U> mapper)

      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.

      Parameters:
        `mapper` - the mapper function
      Returns:
        the mapped future

    - #### map

          public <V> Future<V> map(V value)

      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.

      Parameters:
        `value` - the value that eventually completes the mapped future
      Returns:
        the mapped future

    - #### mapEmpty

          public <V> Future<V> mapEmpty()

      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.

      Returns:
        the mapped future

    - #### completer

          public Handler<AsyncResult<T>> completer()

      Returns:
        an handler completing this future

    - #### recover

          public Future<T> recover(java.util.function.Function<Throwable,Future<T>> mapper)

      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.
      Parameters:
        `mapper` - A function which takes the exception of a failure and returns a new future.
      Returns:
        A recovered future

    - #### otherwise

          public Future<T> otherwise(java.util.function.Function<Throwable,T> mapper)

      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.

      Parameters:
        `mapper` - the mapper function
      Returns:
        the mapped future

    - #### otherwise

          public Future<T> otherwise(T value)

      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.

      Parameters:
        `value` - the value that eventually completes the mapped future
      Returns:
        the mapped future

    - #### otherwiseEmpty

          public Future<T> otherwiseEmpty()

      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.

      Returns:
        the mapped future

    - #### newInstance

          public static <T> Future newInstance(Future arg)

    - #### newInstance

          public static <T> Future newInstance(Future arg,
                                               TypeArg<T> __typeArg_T)

Copyright © 2017. All rights reserved.