## Uses of Class
io.vertx.rxjava.core.Future

- Packages that use Future
  Package | Description
  --- | ---
  io.vertx.ext.rxjava.eventbus.bridge.tcp |
  io.vertx.rxjava.circuitbreaker |
  io.vertx.rxjava.config |
  io.vertx.rxjava.core |
  io.vertx.rxjava.core.http |
  io.vertx.rxjava.ext.bridge |
  io.vertx.rxjava.ext.healthchecks |
  io.vertx.rxjava.ext.unit |
  io.vertx.rxjava.ext.web.handler.sockjs |
  io.vertx.rxjava.servicediscovery.spi |

- - ### Uses of Future in io.vertx.ext.rxjava.eventbus.bridge.tcp

    Subclasses of Future in io.vertx.ext.rxjava.eventbus.bridge.tcp
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BridgeEvent` Represents an event that occurs on the event bus bridge.

    Methods in io.vertx.ext.rxjava.eventbus.bridge.tcp that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<U> Future<U>` | BridgeEvent.`compose(java.util.function.Function<Boolean,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<U> Future<U>` | BridgeEvent.`compose(Handler<Boolean> handler, Future<U> next)` Compose this future with a provided `next` future.
    `<U> Future<U>` | BridgeEvent.`map(java.util.function.Function<Boolean,U> mapper)` Apply a `mapper` function on this future.
    `Future<Boolean>` | BridgeEvent.`otherwise(Boolean value)` Map the failure of a future to a specific `value`.
    `Future<Boolean>` | BridgeEvent.`otherwise(java.util.function.Function<Throwable,Boolean> mapper)` Apply a `mapper` function on this future.
    `Future<Boolean>` | BridgeEvent.`otherwiseEmpty()` Map the failure of a future to `null`.
    `Future<Boolean>` | BridgeEvent.`recover(java.util.function.Function<Throwable,Future<Boolean>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `Future<Boolean>` | BridgeEvent.`setHandler(Handler<AsyncResult<Boolean>> handler)` Set a handler for the result.

    Methods in io.vertx.ext.rxjava.eventbus.bridge.tcp with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<U> Future<U>` | BridgeEvent.`compose(Handler<Boolean> handler, Future<U> next)` Compose this future with a provided `next` future.

    Method parameters in io.vertx.ext.rxjava.eventbus.bridge.tcp with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<U> Future<U>` | BridgeEvent.`compose(java.util.function.Function<Boolean,Future<U>> mapper)` Compose this future with a `mapper` function.
    `Future<Boolean>` | BridgeEvent.`recover(java.util.function.Function<Throwable,Future<Boolean>> mapper)` Handles a failure of this Future by returning the result of another Future.

  - ### Uses of Future in io.vertx.rxjava.circuitbreaker

    Methods in io.vertx.rxjava.circuitbreaker that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | CircuitBreaker.`execute(Handler<Future<T>> command)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback(Handler<Future<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.

    Methods in io.vertx.rxjava.circuitbreaker with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Future<T> resultFuture, Handler<Future<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(io.vertx.rxjava.core.Future<T>, io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Future<T> resultFuture, Handler<Future<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.

    Method parameters in io.vertx.rxjava.circuitbreaker with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | CircuitBreaker.`execute(Handler<Future<T>> command)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Future<T> resultFuture, Handler<Future<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(io.vertx.rxjava.core.Future<T>, io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReportWithFallback(Future<T> resultFuture, Handler<Future<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `<T> void` | CircuitBreaker.`executeCommand(Handler<Future<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> void` | CircuitBreaker.`executeCommandWithFallback(Handler<Future<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using a callback.
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback(Handler<Future<T>> command, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `<T> Single<T>` | CircuitBreaker.`rxExecuteCommand(Handler<Future<T>> command)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker default fallback.
    `<T> Single<T>` | CircuitBreaker.`rxExecuteCommandWithFallback(Handler<Future<T>> command, java.util.function.Function<Throwable,T> fallback)` Same as `CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using a callback.

  - ### Uses of Future in io.vertx.rxjava.config

    Methods in io.vertx.rxjava.config that return Future
    Modifier and Type | Method and Description
    --- | ---
    `static Future<JsonObject>` | ConfigRetriever.`getConfigAsFuture(ConfigRetriever retriever)` Same as `ConfigRetriever.getConfig(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.core.json.JsonObject>>)`, but returning a object.

  - ### Uses of Future in io.vertx.rxjava.core

    Subclasses of Future in io.vertx.rxjava.core
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CompositeFuture` The composite future wraps a list of `futures`, it is useful when several futures needs to be coordinated.

    Fields in io.vertx.rxjava.core with type parameters of type Future
    Modifier and Type | Field and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<Future>` | Future.`__TYPE_ARG`

    Methods in io.vertx.rxjava.core that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<U> Future<U>` | CompositeFuture.`compose(java.util.function.Function<CompositeFuture,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<U> Future<U>` | Future.`compose(java.util.function.Function<T,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<U> Future<U>` | CompositeFuture.`compose(Handler<CompositeFuture> handler, Future<U> next)` Compose this future with a provided `next` future.
    `<U> Future<U>` | Future.`compose(Handler<T> handler, Future<U> next)` Compose this future with a provided `next` future.
    `static <T> Future<T>` | Future.`failedFuture(String failureMessage)` Create a failed future with the specified failure message.
    `static <T> Future<T>` | Future.`failedFuture(Throwable t)` Create a failed future with the specified failure cause.
    `static <T> Future<T>` | Future.`future()` Create a future that hasn't completed yet
    `static <T> Future<T>` | Future.`future(Handler<Future<T>> handler)` Create a future that hasn't completed yet and that is passed to the `handler` before it is returned.
    `<U> Future<U>` | CompositeFuture.`map(java.util.function.Function<CompositeFuture,U> mapper)` Apply a `mapper` function on this future.
    `<U> Future<U>` | Future.`map(java.util.function.Function<T,U> mapper)` Apply a `mapper` function on this future.
    `<V> Future<V>` | Future.`map(V value)` Map the result of a future to a specific `value`.
    `<V> Future<V>` | Future.`mapEmpty()` Map the result of a future to `null`.
    `static <T> Future<T>` | Future.`newInstance(Future arg)`
    `static <T> Future<T>` | Future.`newInstance(Future arg, io.vertx.lang.rx.TypeArg<T> __typeArg_T)`
    `Future<CompositeFuture>` | CompositeFuture.`otherwise(CompositeFuture value)` Map the failure of a future to a specific `value`.
    `Future<CompositeFuture>` | CompositeFuture.`otherwise(java.util.function.Function<Throwable,CompositeFuture> mapper)` Apply a `mapper` function on this future.
    `Future<T>` | Future.`otherwise(java.util.function.Function<Throwable,T> mapper)` Apply a `mapper` function on this future.
    `Future<T>` | Future.`otherwise(T value)` Map the failure of a future to a specific `value`.
    `Future<T>` | Future.`otherwiseEmpty()` Map the failure of a future to `null`.
    `Future<CompositeFuture>` | CompositeFuture.`otherwiseEmpty()` Map the failure of a future to `null`.
    `Future<CompositeFuture>` | CompositeFuture.`recover(java.util.function.Function<Throwable,Future<CompositeFuture>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `Future<T>` | Future.`recover(java.util.function.Function<Throwable,Future<T>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `Future<T>` | Future.`setHandler(Handler<AsyncResult<T>> handler)` Set a handler for the result.
    `static <T> Future<T>` | Future.`succeededFuture()` Create a succeeded future with a null result
    `static <T> Future<T>` | Future.`succeededFuture(T result)` Created a succeeded future with the specified result.

    Methods in io.vertx.rxjava.core with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static <T1,T2> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
    `static <T1,T2> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when any futures is succeeded, failed when all futures are failed.
    `static <T1,T2> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when any futures is succeeded, failed when all futures are failed.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `<U> Future<U>` | CompositeFuture.`compose(Handler<CompositeFuture> handler, Future<U> next)` Compose this future with a provided `next` future.
    `<U> Future<U>` | Future.`compose(Handler<T> handler, Future<U> next)` Compose this future with a provided `next` future.
    `static <T1,T2> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
    `static <T1,T2> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2)` Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 3 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 4 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 5 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.
    `static <T1,T2,T3,T4,T5,T6> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3, Future<T4> f4, Future<T5> f5, Future<T6> f6)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with 6 futures.

    Method parameters in io.vertx.rxjava.core with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static CompositeFuture` | CompositeFuture.`all(List<Future> futures)` Like `CompositeFuture.all(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with a list of futures.
    `static CompositeFuture` | CompositeFuture.`any(List<Future> futures)` Like `CompositeFuture.any(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with a list of futures.
    `<U> Future<U>` | CompositeFuture.`compose(java.util.function.Function<CompositeFuture,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<U> Future<U>` | Future.`compose(java.util.function.Function<T,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<T> void` | Context.`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` with order = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> void` | WorkerExecutor.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> Observable<T>` | Context.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)` Deprecated. use `Context.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean)` instead
    `<T> Observable<T>` | Vertx.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)` Deprecated. use `Vertx.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean)` instead
    `<T> Observable<T>` | WorkerExecutor.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)` Deprecated. use `WorkerExecutor.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean)` instead
    `<T> Observable<T>` | Context.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Deprecated. use `Context.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean)` instead
    `<T> Observable<T>` | Vertx.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Deprecated. use `Vertx.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean)` instead
    `<T> Observable<T>` | WorkerExecutor.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Deprecated. use `WorkerExecutor.rxExecuteBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean)` instead
    `static <T> Future<T>` | Future.`future(Handler<Future<T>> handler)` Create a future that hasn't completed yet and that is passed to the `handler` before it is returned.
    `static CompositeFuture` | CompositeFuture.`join(List<Future> futures)` Like `CompositeFuture.join(io.vertx.rxjava.core.Future<T1>, io.vertx.rxjava.core.Future<T2>)` but with a list of futures.
    `Future<CompositeFuture>` | CompositeFuture.`recover(java.util.function.Function<Throwable,Future<CompositeFuture>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `Future<T>` | Future.`recover(java.util.function.Function<Throwable,Future<T>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `<T> Single<T>` | Context.`rxExecuteBlocking(Handler<Future<T>> blockingCodeHandler)` Invoke `Context.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` with order = true.
    `<T> Single<T>` | Vertx.`rxExecuteBlocking(Handler<Future<T>> blockingCodeHandler)` Like `Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> Single<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Future<T>> blockingCodeHandler)` Like `WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> Single<T>` | Context.`rxExecuteBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `<T> Single<T>` | Vertx.`rxExecuteBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `<T> Single<T>` | WorkerExecutor.`rxExecuteBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.

  - ### Uses of Future in io.vertx.rxjava.core.http

    Method parameters in io.vertx.rxjava.core.http with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HttpClient` | HttpClient.`redirectHandler(java.util.function.Function<HttpClientResponse,Future<HttpClientRequest>> handler)` Set a redirect handler for the http client.

  - ### Uses of Future in io.vertx.rxjava.ext.bridge

    Subclasses of Future in io.vertx.rxjava.ext.bridge
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BaseBridgeEvent` Represents an event that occurs on the event bus bridge.

    Methods in io.vertx.rxjava.ext.bridge that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<U> Future<U>` | BaseBridgeEvent.`compose(java.util.function.Function<Boolean,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<U> Future<U>` | BaseBridgeEvent.`compose(Handler<Boolean> handler, Future<U> next)` Compose this future with a provided `next` future.
    `<U> Future<U>` | BaseBridgeEvent.`map(java.util.function.Function<Boolean,U> mapper)` Apply a `mapper` function on this future.
    `Future<Boolean>` | BaseBridgeEvent.`otherwise(Boolean value)` Map the failure of a future to a specific `value`.
    `Future<Boolean>` | BaseBridgeEvent.`otherwise(java.util.function.Function<Throwable,Boolean> mapper)` Apply a `mapper` function on this future.
    `Future<Boolean>` | BaseBridgeEvent.`otherwiseEmpty()` Map the failure of a future to `null`.
    `Future<Boolean>` | BaseBridgeEvent.`recover(java.util.function.Function<Throwable,Future<Boolean>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `Future<Boolean>` | BaseBridgeEvent.`setHandler(Handler<AsyncResult<Boolean>> handler)` Set a handler for the result.

    Methods in io.vertx.rxjava.ext.bridge with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<U> Future<U>` | BaseBridgeEvent.`compose(Handler<Boolean> handler, Future<U> next)` Compose this future with a provided `next` future.

    Method parameters in io.vertx.rxjava.ext.bridge with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<U> Future<U>` | BaseBridgeEvent.`compose(java.util.function.Function<Boolean,Future<U>> mapper)` Compose this future with a `mapper` function.
    `Future<Boolean>` | BaseBridgeEvent.`recover(java.util.function.Function<Throwable,Future<Boolean>> mapper)` Handles a failure of this Future by returning the result of another Future.

  - ### Uses of Future in io.vertx.rxjava.ext.healthchecks

    Method parameters in io.vertx.rxjava.ext.healthchecks with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `HealthChecks` | HealthChecks.`register(String name, Handler<Future<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, Handler<Future<Status>> procedure)` Registers a health check procedure.
    `HealthChecks` | HealthChecks.`register(String name, long timeout, Handler<Future<Status>> procedure)` Registers a health check procedure.
    `HealthCheckHandler` | HealthCheckHandler.`register(String name, long timeout, Handler<Future<Status>> procedure)` Registers a health check procedure.

  - ### Uses of Future in io.vertx.rxjava.ext.unit

    Methods in io.vertx.rxjava.ext.unit with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | Completion.`resolve(Future<T> future)` Completes the future upon completion, otherwise fails it.
    `void` | Async.`resolve(Future<Void> future)` Completes the future upon completion, otherwise fails it.
    `void` | TestCompletion.`resolve(Future<Void> future)` Completes the future upon completion, otherwise fails it.

  - ### Uses of Future in io.vertx.rxjava.ext.web.handler.sockjs

    Methods in io.vertx.rxjava.ext.web.handler.sockjs that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<U> Future<U>` | BridgeEvent.`compose(java.util.function.Function<Boolean,Future<U>> mapper)` Compose this future with a `mapper` function.
    `<U> Future<U>` | BridgeEvent.`compose(Handler<Boolean> handler, Future<U> next)` Compose this future with a provided `next` future.
    `<U> Future<U>` | BridgeEvent.`map(java.util.function.Function<Boolean,U> mapper)` Apply a `mapper` function on this future.
    `Future<Boolean>` | BridgeEvent.`otherwise(Boolean value)` Map the failure of a future to a specific `value`.
    `Future<Boolean>` | BridgeEvent.`otherwise(java.util.function.Function<Throwable,Boolean> mapper)` Apply a `mapper` function on this future.
    `Future<Boolean>` | BridgeEvent.`otherwiseEmpty()` Map the failure of a future to `null`.
    `Future<Boolean>` | BridgeEvent.`recover(java.util.function.Function<Throwable,Future<Boolean>> mapper)` Handles a failure of this Future by returning the result of another Future.
    `Future<Boolean>` | BridgeEvent.`setHandler(Handler<AsyncResult<Boolean>> handler)` Set a handler for the result.

    Methods in io.vertx.rxjava.ext.web.handler.sockjs with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<U> Future<U>` | BridgeEvent.`compose(Handler<Boolean> handler, Future<U> next)` Compose this future with a provided `next` future.

    Method parameters in io.vertx.rxjava.ext.web.handler.sockjs with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<U> Future<U>` | BridgeEvent.`compose(java.util.function.Function<Boolean,Future<U>> mapper)` Compose this future with a `mapper` function.
    `Future<Boolean>` | BridgeEvent.`recover(java.util.function.Function<Throwable,Future<Boolean>> mapper)` Handles a failure of this Future by returning the result of another Future.

  - ### Uses of Future in io.vertx.rxjava.servicediscovery.spi

    Methods in io.vertx.rxjava.servicediscovery.spi with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceExporter.`init(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Future<Void> future)` Starts the exporter.
    `void` | ServiceImporter.`start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Future<Void> future)` Starts the importer.

Copyright © 2018 Eclipse. All rights reserved.