## Uses of Interface
io.vertx.core.Future

- Packages that use Future
  Package | Description
  --- | ---
  io.vertx.circuitbreaker |
  io.vertx.config |
  io.vertx.core |
  io.vertx.core.http |
  io.vertx.core.spi |
  io.vertx.ext.healthchecks |
  io.vertx.ext.httpservicefactory |
  io.vertx.ext.shell |
  io.vertx.ext.sync |
  io.vertx.ext.unit |
  io.vertx.ext.web.codec.spi |
  io.vertx.ext.web.handler.sockjs |
  io.vertx.lang.groovy |
  io.vertx.lang.kotlin |
  io.vertx.lang.ruby |
  io.vertx.maven |
  io.vertx.rxjava.core |
  io.vertx.service |
  io.vertx.servicediscovery.consul |
  io.vertx.servicediscovery.docker |
  io.vertx.servicediscovery.kubernetes |
  io.vertx.servicediscovery.spi |

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

    Methods in io.vertx.circuitbreaker that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | CircuitBreaker.`execute(Handler<Future<T>> command)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` 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.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(Future, Handler, Function)` 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.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(Handler, Function)` but using the circuit breaker default fallback.
    `<T> CircuitBreaker` | CircuitBreaker.`executeAndReport(Future<T> resultFuture, Handler<Future<T>> command)` Same as `CircuitBreaker.executeAndReportWithFallback(Future, Handler, Function)` 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.
    `default <T> void` | CircuitBreaker.`executeCommand(Handler<Future<T>> command, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` but using the circuit breaker default fallback.
    `default <T> void` | CircuitBreaker.`executeCommandWithFallback(Handler<Future<T>> command, java.util.function.Function<Throwable,T> fallback, Handler<AsyncResult<T>> handler)` Same as `CircuitBreaker.executeWithFallback(Handler, Function)` 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.

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

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

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

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

    Methods in io.vertx.core that return Future
    Modifier and Type | Method and Description
    --- | ---
    `default <U> Future<U>` | Future.`compose(java.util.function.Function<T,Future<U>> mapper)` Compose this future with a `mapper` function.
    `default <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.
    `default <U> Future<U>` | Future.`map(java.util.function.Function<T,U> mapper)` Apply a `mapper` function on this future.
    `default <V> Future<V>` | Future.`map(V value)` Map the result of a future to a specific `value`.
    `default <V> Future<V>` | Future.`mapEmpty()` Map the result of a future to `null`.
    `default Future<T>` | Future.`otherwise(java.util.function.Function<Throwable,T> mapper)` Apply a `mapper` function on this future.
    `default Future<T>` | Future.`otherwise(T value)` Map the failure of a future to a specific `value`.
    `default Future<T>` | Future.`otherwiseEmpty()` Map the failure of a future to `null`.
    `default 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.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(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.all(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`all(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.all(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.any(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`any(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.any(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` but with 6 futures.
    `default <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(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.join(Future, Future)` but with 3 futures.
    `static <T1,T2,T3> CompositeFuture` | CompositeFuture.`join(Future<T1> f1, Future<T2> f2, Future<T3> f3)` Like `CompositeFuture.join(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` 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(Future, Future)` but with 6 futures.
    `void` | AbstractVerticle.`start(Future<Void> startFuture)` Start the verticle.
    `void` | Verticle.`start(Future<Void> startFuture)` Start the verticle instance.
    `void` | AbstractVerticle.`stop(Future<Void> stopFuture)` Stop the verticle.
    `void` | Verticle.`stop(Future<Void> stopFuture)` Stop the verticle instance.

    Method parameters in io.vertx.core with type arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static CompositeFuture` | CompositeFuture.`all(List<Future> futures)` Like `CompositeFuture.all(Future, Future)` but with a list of futures.
    `static CompositeFuture` | CompositeFuture.`any(List<Future> futures)` Like `CompositeFuture.any(Future, Future)` but with a list of futures.
    `default <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(Handler, boolean, Handler)` with order = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `default <T> void` | WorkerExecutor.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `WorkerExecutor.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `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(Future, Future)` but with a list of futures.
    `default 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.

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

    Methods in io.vertx.core.http that return types with arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `java.util.function.Function<HttpClientResponse,Future<HttpClientRequest>>` | HttpClient.`redirectHandler()`

    Method parameters in io.vertx.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.core.spi

    Methods in io.vertx.core.spi that return Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> Future<T>` | FutureFactory.`failedFuture(Throwable t)`
    `<T> Future<T>` | FutureFactory.`failureFuture(String failureMessage)`
    `<T> Future<T>` | FutureFactory.`future()`
    `<T> Future<T>` | FutureFactory.`succeededFuture()`
    `<T> Future<T>` | FutureFactory.`succeededFuture(T result)`

    Methods in io.vertx.core.spi with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `default void` | VerticleFactory.`resolve(String identifier, DeploymentOptions deploymentOptions, ClassLoader classLoader, Future<String> resolution)` Some verticle factories can "resolve" the identifer to another identifier which is then used to look up the real verticle factory.

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

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

  - ### Uses of Future in io.vertx.ext.httpservicefactory

    Methods in io.vertx.ext.httpservicefactory with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | HttpServiceFactory.`resolve(String identifier, DeploymentOptions deploymentOptions, ClassLoader classLoader, Future<String> resolution)`

  - ### Uses of Future in io.vertx.ext.shell

    Methods in io.vertx.ext.shell with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | ShellVerticle.`start(Future<Void> startFuture)`

  - ### Uses of Future in io.vertx.ext.sync

    Methods in io.vertx.ext.sync with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | SyncVerticle.`start(Future<Void> startFuture)`
    `void` | SyncVerticle.`stop(Future<Void> stopFuture)`

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

    Methods in io.vertx.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.

  - ### Uses of Future in io.vertx.ext.web.codec.spi

    Methods in io.vertx.ext.web.codec.spi that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<T>` | BodyStream.`result()`

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

    Subinterfaces of Future in io.vertx.ext.web.handler.sockjs
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `BridgeEvent` Represents an event that occurs on the event bus bridge.

  - ### Uses of Future in io.vertx.lang.groovy

    Methods in io.vertx.lang.groovy with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | GroovyVerticle.`start(Future<Void> startFuture)` Deprecated. Start the verticle instance.
    `void` | ScriptVerticle.`start(Future<Void> startFuture)` Start the verticle instance.
    `void` | GroovyVerticle.`stop(Future<Void> stopFuture)` Deprecated. Stop the verticle instance.
    `void` | ScriptVerticle.`stop(Future<Void> stopFuture)` Stop the verticle instance.

  - ### Uses of Future in io.vertx.lang.kotlin

    Methods in io.vertx.lang.kotlin with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | ScriptVerticle.`start(Future<Void> startFuture)`
    `void` | ScriptVerticle.`stop(Future<Void> stopFuture)`

  - ### Uses of Future in io.vertx.lang.ruby

    Methods in io.vertx.lang.ruby with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | JRubyVerticle.`start(Future<Void> startFuture)`
    `void` | JRubyVerticle.`stop(Future<Void> stopFuture)`

  - ### Uses of Future in io.vertx.maven

    Methods in io.vertx.maven with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | MavenVerticleFactory.`resolve(String identifier, DeploymentOptions deploymentOptions, ClassLoader classLoader, Future<String> resolution)`

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

    Methods in io.vertx.rxjava.core that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future` | Future.`getDelegate()`

    Methods in io.vertx.rxjava.core with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Future<T>` | Future.`newInstance(Future arg)`
    `static <T> Future<T>` | Future.`newInstance(Future arg, TypeArg<T> __typeArg_T)`

    Constructors in io.vertx.rxjava.core with parameters of type Future
    Constructor and Description
    `Future(Future delegate)`
    `Future(Future delegate, TypeArg<T> typeArg_0)`

  - ### Uses of Future in io.vertx.service

    Methods in io.vertx.service with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServiceVerticleFactory.`resolve(String identifier, DeploymentOptions deploymentOptions, ClassLoader classLoader, Future<String> resolution)`

  - ### Uses of Future in io.vertx.servicediscovery.consul

    Methods in io.vertx.servicediscovery.consul with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `ImportedConsulService` | ImportedConsulService.`register(ServicePublisher publisher, Future<ImportedConsulService> completion)` Registers the service and completes the given future when done.
    `void` | ConsulServiceImporter.`start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Future<Void> completion)`
    `void` | ImportedConsulService.`unregister(ServicePublisher publiher, Future<Void> completion)` Unregisters the service and completes the given future when done, if not `null`

  - ### Uses of Future in io.vertx.servicediscovery.docker

    Methods in io.vertx.servicediscovery.docker with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | DockerLinksServiceImporter.`start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Future<Void> completion)`

  - ### Uses of Future in io.vertx.servicediscovery.kubernetes

    Methods in io.vertx.servicediscovery.kubernetes with parameters of type Future
    Modifier and Type | Method and Description
    --- | ---
    `void` | KubernetesServiceImporter.`start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Future<Void> completion)`

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

    Methods in io.vertx.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 © 2017. All rights reserved.