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

- Packages that use Future
  Package | Description
  --- | ---
  io.vertx.rxjava.circuitbreaker |
  io.vertx.rxjava.core |
  io.vertx.rxjava.ext.unit |
  io.vertx.rxjava.ext.web.handler.sockjs |
  io.vertx.rxjava.servicediscovery.spi |

- - ### 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>> operation)` 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>> operation, 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>> operation)` 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>> operation, 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>> operation)` 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>> operation)` 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>> operation, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.
    `<T> Future<T>` | CircuitBreaker.`executeWithFallback(Handler<Future<T>> operation, java.util.function.Function<Throwable,T> fallback)` Executes the given operation with the circuit breaker control.

  - ### 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.

    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.`future()` Create a future that hasn't completed yet
    `<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`.
    `static <T> Future` | Future.`newInstance(Future arg)`
    `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 completed when all the futures are completed.
    `static <T1,T2> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2)` Return a composite future completed when all the futures are completed.
    `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)` 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> Observable<T>` | Vertx.`executeBlockingObservable(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> Observable<T>` | WorkerExecutor.`executeBlockingObservable(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> Observable<T>` | Context.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `<T> Observable<T>` | Vertx.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `<T> Observable<T>` | WorkerExecutor.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `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.

  - ### 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

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

    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)`
    `<U> Future<U>` | BridgeEvent.`compose(Handler<Boolean> handler, Future<U> next)`
    `<U> Future<U>` | BridgeEvent.`map(java.util.function.Function<Boolean,U> mapper)`
    `Future<Boolean>` | BridgeEvent.`setHandler(Handler<AsyncResult<Boolean>> arg0)`

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

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

  - ### 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.
    `void` | ServiceImporter.`stop(Vertx vertx, ServicePublisher publisher, Future<Void> future)` Stops the importer.

Copyright © 2016. All rights reserved.