Uses of Interface
io.vertx.core.Future

Packages that use Future

Package	Description
io.vertx.amqp
io.vertx.camel
io.vertx.cassandra
io.vertx.circuitbreaker
io.vertx.config
io.vertx.config.consul
io.vertx.config.git
io.vertx.config.hocon
io.vertx.config.kubernetes
io.vertx.config.redis
io.vertx.config.spi
io.vertx.config.vault
io.vertx.config.vault.client
io.vertx.config.yaml
io.vertx.config.zookeeper
io.vertx.core
io.vertx.core.datagram
io.vertx.core.dns
io.vertx.core.eventbus
io.vertx.core.file
io.vertx.core.http
io.vertx.core.net
io.vertx.core.net.endpoint
io.vertx.core.shareddata
io.vertx.core.spi.dns
io.vertx.core.spi.endpoint
io.vertx.core.streams
io.vertx.db2client
io.vertx.db2client.spi
io.vertx.ext.auth.authentication
io.vertx.ext.auth.authorization
io.vertx.ext.auth.mongo
io.vertx.ext.auth.oauth2
io.vertx.ext.auth.oauth2.providers
io.vertx.ext.auth.otp.hotp
io.vertx.ext.auth.otp.totp
io.vertx.ext.auth.sqlclient
io.vertx.ext.auth.webauthn4j
io.vertx.ext.consul
io.vertx.ext.eventbus.bridge.tcp
io.vertx.ext.healthchecks
io.vertx.ext.mail
io.vertx.ext.mongo
io.vertx.ext.reactivestreams
io.vertx.ext.shell
io.vertx.ext.shell.command
io.vertx.ext.shell.term
io.vertx.ext.stomp
io.vertx.ext.unit.junit
io.vertx.ext.web
io.vertx.ext.web.client
io.vertx.ext.web.client.spi
io.vertx.ext.web.codec.spi
io.vertx.ext.web.common.template
io.vertx.ext.web.handler
io.vertx.ext.web.handler.sockjs
io.vertx.ext.web.healthchecks
io.vertx.ext.web.openapi.router
io.vertx.ext.web.sstore
io.vertx.grpc.client
io.vertx.grpc.common
io.vertx.grpc.event.v1alpha
io.vertx.grpc.server
io.vertx.grpc.stub
io.vertx.grpcio.client
io.vertx.httpproxy
io.vertx.httpproxy.spi.cache
io.vertx.jdbcclient
io.vertx.junit5
io.vertx.kafka.admin
io.vertx.kafka.client.consumer
io.vertx.kafka.client.producer
io.vertx.mqtt
io.vertx.mssqlclient
io.vertx.mysqlclient
io.vertx.mysqlclient.spi
io.vertx.openapi.contract
io.vertx.openapi.validation
io.vertx.oracleclient
io.vertx.pgclient
io.vertx.pgclient.pubsub
io.vertx.pgclient.spi
io.vertx.rabbitmq
io.vertx.reactivex
io.vertx.reactivex.amqp
io.vertx.reactivex.cassandra
io.vertx.reactivex.circuitbreaker
io.vertx.reactivex.config
io.vertx.reactivex.core
io.vertx.reactivex.core.datagram
io.vertx.reactivex.core.dns
io.vertx.reactivex.core.eventbus
io.vertx.reactivex.core.file
io.vertx.reactivex.core.http
io.vertx.reactivex.core.net
io.vertx.reactivex.core.net.endpoint
io.vertx.reactivex.core.parsetools
io.vertx.reactivex.core.shareddata
io.vertx.reactivex.core.streams
io.vertx.reactivex.db2client
io.vertx.reactivex.eventbus.bridge.grpc
io.vertx.reactivex.ext.auth.abac
io.vertx.reactivex.ext.auth.authentication
io.vertx.reactivex.ext.auth.authorization
io.vertx.reactivex.ext.auth.jwt.authorization
io.vertx.reactivex.ext.auth.oauth2
io.vertx.reactivex.ext.auth.oauth2.authorization
io.vertx.reactivex.ext.auth.oauth2.providers
io.vertx.reactivex.ext.auth.otp.hotp
io.vertx.reactivex.ext.auth.otp.totp
io.vertx.reactivex.ext.auth.properties
io.vertx.reactivex.ext.auth.sqlclient
io.vertx.reactivex.ext.auth.webauthn4j
io.vertx.reactivex.ext.bridge
io.vertx.reactivex.ext.consul
io.vertx.reactivex.ext.eventbus.bridge.tcp
io.vertx.reactivex.ext.healthchecks
io.vertx.reactivex.ext.mail
io.vertx.reactivex.ext.mongo
io.vertx.reactivex.ext.stomp
io.vertx.reactivex.ext.unit.report
io.vertx.reactivex.ext.web
io.vertx.reactivex.ext.web.client
io.vertx.reactivex.ext.web.common.template
io.vertx.reactivex.ext.web.handler
io.vertx.reactivex.ext.web.handler.graphql.ws
io.vertx.reactivex.ext.web.handler.sockjs
io.vertx.reactivex.ext.web.healthchecks
io.vertx.reactivex.ext.web.openapi.router
io.vertx.reactivex.ext.web.sstore
io.vertx.reactivex.grpc.client
io.vertx.reactivex.grpc.common
io.vertx.reactivex.grpc.server
io.vertx.reactivex.jdbcclient
io.vertx.reactivex.kafka.admin
io.vertx.reactivex.kafka.client.consumer
io.vertx.reactivex.kafka.client.producer
io.vertx.reactivex.mqtt
io.vertx.reactivex.mssqlclient
io.vertx.reactivex.mysqlclient
io.vertx.reactivex.openapi.contract
io.vertx.reactivex.openapi.validation
io.vertx.reactivex.oracleclient
io.vertx.reactivex.pgclient
io.vertx.reactivex.pgclient.pubsub
io.vertx.reactivex.rabbitmq
io.vertx.reactivex.redis.client
io.vertx.reactivex.servicediscovery
io.vertx.reactivex.servicediscovery.spi
io.vertx.reactivex.servicediscovery.types
io.vertx.reactivex.sqlclient
io.vertx.reactivex.sqlclient.templates
io.vertx.redis.client
io.vertx.rxjava3
io.vertx.servicediscovery
io.vertx.servicediscovery.spi
io.vertx.servicediscovery.types
io.vertx.serviceproxy
io.vertx.serviceresolver
io.vertx.sqlclient
io.vertx.sqlclient.spi
io.vertx.sqlclient.spi.connection
io.vertx.sqlclient.spi.protocol
io.vertx.sqlclient.templates

Uses of Future in io.vertx.amqp

Methods in io.vertx.amqp that return Future

Modifier and Type	Method	Description
Future<Void>	AmqpClient.close()	Closes the client.
Future<Void>	AmqpConnection.close()	Closes the AMQP connection, i.e. allows the Close frame to be emitted.
Future<Void>	AmqpReceiver.close()	Closes the receiver.
Future<Void>	AmqpSender.close()	Closes the sender.
Future<Void>	AmqpConnection.closeFuture()
Future<AmqpConnection>	AmqpClient.connect()	Connects to the AMQP broker or router.
Future<AmqpSender>	AmqpConnection.createAnonymousSender()	Creates an anonymous sender.
Future<AmqpReceiver>	AmqpConnection.createDynamicReceiver()	Creates a dynamic receiver.
Future<AmqpReceiver>	AmqpClient.createReceiver(String address)	Creates a receiver used to consume messages from the given address.
Future<AmqpReceiver>	AmqpClient.createReceiver(String address, AmqpReceiverOptions receiverOptions)	Creates a receiver used to consumer messages from the given address.
Future<AmqpReceiver>	AmqpConnection.createReceiver(String address)	Creates a receiver used to consume messages from the given address.
Future<AmqpReceiver>	AmqpConnection.createReceiver(String address, AmqpReceiverOptions receiverOptions)	Creates a receiver used to consumer messages from the given address.
Future<AmqpSender>	AmqpClient.createSender(String address)	Creates a sender used to send messages to the given address.
Future<AmqpSender>	AmqpClient.createSender(String address, AmqpSenderOptions options)	Creates a sender used to send messages to the given address.
Future<AmqpSender>	AmqpConnection.createSender(String address)	Creates a sender used to send messages to the given address.
Future<AmqpSender>	AmqpConnection.createSender(String address, AmqpSenderOptions options)	Creates a sender used to send messages to the given address.
Future<Void>	AmqpSender.sendWithAck(AmqpMessage message)	Sends an AMQP message and waits for an acknowledgement.

Uses of Future in io.vertx.camel

Methods in io.vertx.camel that return Future

Modifier and Type	Method	Description
Future<Void>	CamelBridge.start()	Starts the bridge.
Future<Void>	CamelBridge.stop()	Stops the bridge.

Uses of Future in io.vertx.cassandra

Methods in io.vertx.cassandra that return Future

Modifier and Type	Method	Description
Future<List<com.datastax.oss.driver.api.core.cql.Row>>	ResultSet.all()	The method should not be used concurrently with others like ResultSet.fetchNextPage() or ResultSet.one().
Future<Void>	CassandraClient.close()	Closes this client.
Future<ResultSet>	CassandraClient.execute(com.datastax.oss.driver.api.core.cql.Statement statement)	Execute the statement and provide a handler for consuming results.
<R> Future<R>	CassandraClient.execute(com.datastax.oss.driver.api.core.cql.Statement statement, Collector<com.datastax.oss.driver.api.core.cql.Row, ?, R> collector)	Execute a statement and produce a result by applying a collector to result set rows.
Future<ResultSet>	CassandraClient.execute(String query)	Execute the query and provide a handler for consuming results.
<R> Future<R>	CassandraClient.execute(String query, Collector<com.datastax.oss.driver.api.core.cql.Row, ?, R> collector)	Execute a query and produce a result by applying a collector to result set rows.
Future<List<com.datastax.oss.driver.api.core.cql.Row>>	CassandraClient.executeWithFullFetch(com.datastax.oss.driver.api.core.cql.Statement statement)	Execute the query and provide a handler for consuming results.
Future<List<com.datastax.oss.driver.api.core.cql.Row>>	CassandraClient.executeWithFullFetch(String query)	Execute the query and provide a handler for consuming results.
Future<ResultSet>	ResultSet.fetchNextPage()
Future<com.datastax.oss.driver.api.core.metadata.Metadata>	CassandraClient.metadata()	Get Metadata for the session.
default Future<Void>	CassandraRowStream.pipeTo(WriteStream<com.datastax.oss.driver.api.core.cql.Row> dst)
Future<com.datastax.oss.driver.api.core.cql.PreparedStatement>	CassandraClient.prepare(com.datastax.oss.driver.api.core.cql.SimpleStatement statement)	Prepares the provided a SimpleStatement.
Future<com.datastax.oss.driver.api.core.cql.PreparedStatement>	CassandraClient.prepare(String query)	Prepares the provided query string.
Future<CassandraRowStream>	CassandraClient.queryStream(com.datastax.oss.driver.api.core.cql.Statement statement)	Executes the given SQL statement which returns the results of the query as a read stream.
Future<CassandraRowStream>	CassandraClient.queryStream(String sql)	Executes the given SQL SELECT statement which returns the results of the query as a read stream.

Uses of Future in io.vertx.circuitbreaker

Subinterfaces with type arguments of type Future in io.vertx.circuitbreaker

Modifier and Type	Interface	Description
interface	FailurePolicy<T>	A failure policy for the CircuitBreaker.

Methods in io.vertx.circuitbreaker that return Future

Modifier and Type	Method	Description
<T> Future<T>	CircuitBreaker.execute(Handler<Promise<T>> command)	Same as CircuitBreaker.executeWithFallback(Handler, Function) but using the circuit breaker default fallback.
<T> Future<T>	CircuitBreaker.execute(Supplier<Future<T>> command)	Same as CircuitBreaker.executeWithFallback(Supplier, Function) but using the circuit breaker default fallback.
<T> Future<T>	CircuitBreaker.executeWithFallback(Handler<Promise<T>> command, Function<Throwable, T> fallback)	Executes the given operation with the circuit breaker control.
<T> Future<T>	CircuitBreaker.executeWithFallback(Supplier<Future<T>> command, 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	Description
boolean	FailurePolicy.test(Future<T> future)	Invoked by the CircuitBreaker when an operation completes.

Method parameters in io.vertx.circuitbreaker with type arguments of type Future

Modifier and Type	Method	Description
<T> Future<T>	CircuitBreaker.execute(Supplier<Future<T>> command)	Same as CircuitBreaker.executeWithFallback(Supplier, Function) but using the circuit breaker default fallback.
<T> Future<T>	CircuitBreaker.executeWithFallback(Supplier<Future<T>> command, 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	Description
Future<Void>	ConfigRetriever.close()	Closes the retriever.
Future<JsonObject>	ConfigRetriever.getConfig()	Reads the configuration from the different ConfigStore and computes the final configuration.

Uses of Future in io.vertx.config.consul

Methods in io.vertx.config.consul that return Future

Modifier and Type	Method	Description
Future<Void>	ConsulConfigStore.close()
Future<Buffer>	ConsulConfigStore.get()

Uses of Future in io.vertx.config.git

Methods in io.vertx.config.git that return Future

Modifier and Type	Method	Description
Future<Void>	GitConfigStore.close()
Future<Buffer>	GitConfigStore.get()

Uses of Future in io.vertx.config.hocon

Methods in io.vertx.config.hocon that return Future

Modifier and Type	Method	Description
Future<JsonObject>	HoconProcessor.process(Vertx vertx, JsonObject configuration, Buffer input)

Uses of Future in io.vertx.config.kubernetes

Methods in io.vertx.config.kubernetes that return Future

Modifier and Type	Method	Description
Future<Void>	ConfigMapStore.close()
Future<Buffer>	ConfigMapStore.get()

Uses of Future in io.vertx.config.redis

Methods in io.vertx.config.redis that return Future

Modifier and Type	Method	Description
Future<Void>	RedisConfigStore.close()
Future<Buffer>	RedisConfigStore.get()

Uses of Future in io.vertx.config.spi

Methods in io.vertx.config.spi that return Future

Modifier and Type	Method	Description
Future<Void>	ConfigStore.close()	Closes the configuration store.
Future<Buffer>	ConfigStore.get()	Retrieves the configuration store in this store.
Future<JsonObject>	ConfigProcessor.process(Vertx vertx, JsonObject configuration, Buffer input)	Transforms the given input into a JsonObject.

Uses of Future in io.vertx.config.vault

Methods in io.vertx.config.vault that return Future

Modifier and Type	Method	Description
Future<Void>	VaultConfigStore.close()
Future<Buffer>	VaultConfigStore.get()

Uses of Future in io.vertx.config.vault.client

Methods in io.vertx.config.vault.client that return Future

Modifier and Type	Method	Description
Future<Auth>	SlimVaultClient.createToken(TokenRequest tokenRequest)
Future<Void>	SlimVaultClient.delete(String path)
Future<List<String>>	SlimVaultClient.list(String path)
Future<Auth>	SlimVaultClient.loginWithAppRole(String roleId, String secretId)
Future<Auth>	SlimVaultClient.loginWithCert()
Future<Auth>	SlimVaultClient.loginWithUserCredentials(String username, String password)
Future<Lookup>	SlimVaultClient.lookupSelf()
Future<Secret>	SlimVaultClient.read(String path)
Future<Auth>	SlimVaultClient.renewSelf(long leaseDurationInSecond)
Future<Secret>	SlimVaultClient.write(String path, JsonObject secrets)

Uses of Future in io.vertx.config.yaml

Methods in io.vertx.config.yaml that return Future

Modifier and Type	Method	Description
Future<JsonObject>	YamlProcessor.process(Vertx vertx, JsonObject configuration, Buffer input)

Uses of Future in io.vertx.config.zookeeper

Methods in io.vertx.config.zookeeper that return Future

Modifier and Type	Method	Description
Future<Void>	ZookeeperConfigStore.close()
Future<Buffer>	ZookeeperConfigStore.get()

Uses of Future in io.vertx.core

Subinterfaces of Future in io.vertx.core

Modifier and Type	Interface	Description
interface	CompositeFuture	The composite future wraps a list of futures, it is useful when several futures needs to be coordinated.
interface	Timer	A timer task that can be used as a future.

Methods in io.vertx.core that return Future

Modifier and Type	Method	Description
default Future<T>	Future.andThen(Completable<? super T> handler)	Invokes the given handler upon completion.
default Future<T>	Future.andThen(Handler<AsyncResult<T>> handler)	Invokes the given handler upon completion.
Future<Vertx>	VertxBuilder.buildClustered()	Creates a clustered instance.
Future<Void>	Vertx.close()	Stop the Vertx instance and release any resources held by it.
Future<Void>	WorkerExecutor.close()	Close the executor.
static Future<Vertx>	Vertx.clusteredVertx(VertxOptions options)	Creates a clustered instance using the specified options.
default <U> Future<U>	Future.compose(Function<? super T, Future<U>> mapper)	Compose this future with a mapper function.
<U> Future<U>	Future.compose(Function<? super T, Future<U>> successMapper, Function<Throwable, Future<U>> failureMapper)	Compose this future with a successMapper and failureMapper functions.
final Future<?>	AbstractVerticle.deploy(Context context)
Future<?>	Deployable.deploy(Context context)	Start the deployable.
final Future<?>	VerticleBase.deploy(Context context)
default Future<String>	Vertx.deployVerticle(Deployable verticle)	Deploy a verticle instance that you have created yourself.
default Future<String>	Vertx.deployVerticle(Deployable verticle, DeploymentOptions options)	Like Vertx.deployVerticle(Deployable) but DeploymentOptions are provided to configure the deployment.
Future<String>	Vertx.deployVerticle(Class<? extends Deployable> verticleClass, DeploymentOptions options)	Like Vertx.deployVerticle(Deployable, DeploymentOptions) but Deployable instance is created by invoking the default constructor of verticleClass.
default Future<String>	Vertx.deployVerticle(String name)	Deploy a verticle instance given a name.
Future<String>	Vertx.deployVerticle(String name, DeploymentOptions options)	Like Vertx.deployVerticle(Deployable) but DeploymentOptions are provided to configure the deployment.
Future<String>	Vertx.deployVerticle(Supplier<? extends Deployable> supplier, DeploymentOptions options)	Like Vertx.deployVerticle(Deployable, DeploymentOptions) but Deployable instance is created by invoking the verticleSupplier.
<U> Future<T>	Future.eventually(Supplier<Future<U>> mapper)	Compose this future with a mapper that will be always be called.
default <T> Future<T>	Context.executeBlocking(Callable<T> blockingCodeHandler)	Invoke Context.executeBlocking(Callable, boolean) with order = true.
<T> Future<T>	Context.executeBlocking(Callable<T> blockingCodeHandler, boolean ordered)	Safely execute some blocking code.
default <T> Future<T>	Vertx.executeBlocking(Callable<T> blockingCodeHandler)	Like Vertx.executeBlocking(Callable, boolean) called with ordered = true.
default <T> Future<T>	Vertx.executeBlocking(Callable<T> blockingCodeHandler, boolean ordered)	Safely execute some blocking code.
default <T> Future<T>	WorkerExecutor.executeBlocking(Callable<T> blockingCodeHandler)	Like WorkerExecutor.executeBlocking(Callable, boolean) called with ordered = true.
<T> Future<T>	WorkerExecutor.executeBlocking(Callable<T> blockingCodeHandler, boolean ordered)	Safely execute some blocking code.
Future<T>	Future.expecting(Expectation<? super T> expectation)	Guard the control flow of this future with an expectation.
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.
default <U> Future<U>	Future.flatMap(Function<? super T, Future<U>> mapper)	Alias for Future.compose(Function).
static <T> Future<T>	Future.fromCompletionStage(CompletionStage<T> completionStage)	Bridges a CompletionStage object to a Vert.x future instance.
static <T> Future<T>	Future.fromCompletionStage(CompletionStage<T> completionStage, Context context)	Bridges a CompletionStage object to a Vert.x future instance.
static <T> Future<T>	Future.future(Handler<Promise<T>> handler)	Create a promise and pass it to the handler, and then returns this future's promise.
Future<T>	Promise.future()
<U> Future<U>	Future.map(Function<? super 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.
default <V> Future<V>	Future.mapEmpty()	Map the result of a future to null.
Future<T>	Future.onComplete(Completable<? super T> handler)	Add handlers to be notified on succeeded result and failed result.
default Future<T>	Future.onComplete(Handler<? super T> successHandler, Handler<? super Throwable> failureHandler)	Add handlers to be notified on succeeded result and failed result.
default Future<T>	Future.onComplete(Handler<AsyncResult<T>> handler)	Add a handler to be notified of the result.
default Future<T>	Future.onFailure(Handler<? super Throwable> handler)	Add a handler to be notified of the failed result.
default Future<T>	Future.onSuccess(Handler<? super T> handler)	Add a handler to be notified of the succeeded result.
Future<T>	Future.otherwise(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.
default Future<T>	Future.otherwiseEmpty()	Map the failure of a future to null.
default Future<T>	Future.recover(Function<Throwable, Future<T>> mapper)	Handles a failure of this Future by returning the result of another Future.
Future<?>	VerticleBase.start()	Start the verticle.
Future<?>	VerticleBase.stop()	Stop the verticle.
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.
Future<T>	Future.timeout(long delay, TimeUnit unit)	Returns a future succeeded or failed with the outcome of this future when it happens before the timeout fires.
default <U> Future<U>	Future.transform(BiFunction<? super T, ? super Throwable, Future<U>> mapper)	Transform this future with a mapper function.
<U> Future<U>	Future.transform(Function<AsyncResult<T>, Future<U>> mapper)	Transform this future with a mapper function.
final Future<?>	AbstractVerticle.undeploy(Context context)
default Future<?>	Deployable.undeploy(Context context)	Stop the deployable.
final Future<?>	VerticleBase.undeploy(Context context)
Future<Void>	Vertx.undeploy(String deploymentID)	Undeploy a verticle deployment.

Methods in io.vertx.core with parameters of type Future

Modifier and Type	Method	Description
static CompositeFuture	Future.all(Future<?>... futures)	Like Future.all(Future, Future) but with a variable number of futures.
static CompositeFuture	Future.all(Future<?> f1, Future<?> f2)	Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
static CompositeFuture	Future.all(Future<?> f1, Future<?> f2, Future<?> f3)	Like Future.all(Future, Future) but with 3 futures.
static CompositeFuture	Future.all(Future<?> f1, Future<?> f2, Future<?> f3, Future<?> f4)	Like Future.all(Future, Future) but with 4 futures.
static CompositeFuture	Future.all(Future<?> f1, Future<?> f2, Future<?> f3, Future<?> f4, Future<?> f5)	Like Future.all(Future, Future) but with 5 futures.
static CompositeFuture	Future.all(Future<?> f1, Future<?> f2, Future<?> f3, Future<?> f4, Future<?> f5, Future<?> f6)	Like Future.all(Future, Future) but with 6 futures.
static CompositeFuture	Future.any(Future<?>... futures)	Like Future.any(Future, Future) but with a variable number of futures.
static CompositeFuture	Future.any(Future<?> f1, Future<?> f2)	Return a composite future, succeeded when any futures is succeeded, failed when all futures are failed.
static CompositeFuture	Future.any(Future<?> f1, Future<?> f2, Future<?> f3)	Like Future.any(Future, Future) but with 3 futures.
static CompositeFuture	Future.any(Future<?> f1, Future<?> f2, Future<?> f3, Future<?> f4)	Like Future.any(Future, Future) but with 4 futures.
static CompositeFuture	Future.any(Future<?> f1, Future<?> f2, Future<?> f3, Future<?> f4, Future<?> f5)	Like Future.any(Future, Future) but with 5 futures.
static CompositeFuture	Future.any(Future<?> f1, Future<?> f2, Future<?> f3, Future<?> f4, Future<?> f5, Future<?> f6)	Like Future.any(Future, Future) but with 6 futures.
static <T> T	Future.await(Future<T> future)	Calls Future.await() on future.
static CompositeFuture	Future.join(Future<?>... futures)	Like Future.join(Future, Future) but with a variable number of futures.
static CompositeFuture	Future.join(Future<?> f1, Future<?> f2)	Return a composite future, succeeded when all futures are succeeded, failed when any future is failed.
static CompositeFuture	Future.join(Future<?> f1, Future<?> f2, Future<?> f3)	Like Future.join(Future, Future) but with 3 futures.
static CompositeFuture	Future.join(Future<?> f1, Future<?> f2, Future<?> f3, Future<?> f4)	Like Future.join(Future, Future) but with 4 futures.
static CompositeFuture	Future.join(Future<?> f1, Future<?> f2, Future<?> f3, Future<?> f4, Future<?> f5)	Like Future.join(Future, Future) but with 5 futures.
static CompositeFuture	Future.join(Future<?> f1, Future<?> f2, Future<?> f3, Future<?> f4, Future<?> f5, Future<?> f6)	Like Future.join(Future, Future) but with 6 futures.

Method parameters in io.vertx.core with type arguments of type Future

Modifier and Type	Method	Description
static CompositeFuture	Future.all(List<? extends Future<?>> futures)	Like Future.all(Future, Future) but with a list of futures.
static CompositeFuture	Future.any(List<? extends Future<?>> futures)	Like Future.any(Future, Future) but with a list of futures.
default <U> Future<U>	Future.compose(Function<? super T, Future<U>> mapper)	Compose this future with a mapper function.
<U> Future<U>	Future.compose(Function<? super T, Future<U>> successMapper, Function<Throwable, Future<U>> failureMapper)	Compose this future with a successMapper and failureMapper functions.
<U> Future<T>	Future.eventually(Supplier<Future<U>> mapper)	Compose this future with a mapper that will be always be called.
default <U> Future<U>	Future.flatMap(Function<? super T, Future<U>> mapper)	Alias for Future.compose(Function).
static CompositeFuture	Future.join(List<? extends Future<?>> futures)	Like Future.join(Future, Future) but with a list of futures.
default Future<T>	Future.recover(Function<Throwable, Future<T>> mapper)	Handles a failure of this Future by returning the result of another Future.
default <U> Future<U>	Future.transform(BiFunction<? super T, ? super Throwable, Future<U>> mapper)	Transform this future with a mapper function.
<U> Future<U>	Future.transform(Function<AsyncResult<T>, Future<U>> mapper)	Transform this future with a mapper function.

Uses of Future in io.vertx.core.datagram

Methods in io.vertx.core.datagram that return Future

Modifier and Type	Method	Description
Future<Void>	DatagramSocket.blockMulticastGroup(String multicastAddress, String sourceToBlock)	Block the given address for the given multicast address and notifies the Handler once the operation completes.
Future<Void>	DatagramSocket.blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock)	Block the given address for the given multicast address on the given network interface and notifies the Handler once the operation completes.
Future<Void>	DatagramSocket.close()	Closes the DatagramSocket implementation asynchronous and notifies the handler once done.
Future<DatagramSocket>	DatagramSocket.listen(int port, String host)	Start listening on the given port and host.
Future<Void>	DatagramSocket.listenMulticastGroup(String multicastAddress)	Joins a multicast group and listens for packets send to it.
Future<Void>	DatagramSocket.listenMulticastGroup(String multicastAddress, String networkInterface, String source)	Joins a multicast group and listens for packets send to it on the given network interface.
Future<Void>	DatagramSocket.send(Buffer packet, int port, String host)	Write the given Buffer to the SocketAddress.
Future<Void>	DatagramSocket.send(String str, int port, String host)	Write the given String to the SocketAddress using UTF8 encoding.
Future<Void>	DatagramSocket.send(String str, String enc, int port, String host)	Write the given String to the SocketAddress using the given encoding.
Future<Void>	DatagramSocket.unlistenMulticastGroup(String multicastAddress)	Leaves a multicast group and stops listening for packets send to it.
Future<Void>	DatagramSocket.unlistenMulticastGroup(String multicastAddress, String networkInterface, String source)	Leaves a multicast group and stops listening for packets send to it on the given network interface.

Uses of Future in io.vertx.core.dns

Methods in io.vertx.core.dns that return Future

Modifier and Type	Method	Description
Future<Void>	DnsClient.close()	Close the client.
Future<String>	DnsClient.lookup(String name)	Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
Future<String>	DnsClient.lookup4(String name)	Try to lookup the A (ipv4) record for the given name.
Future<String>	DnsClient.lookup6(String name)	Try to lookup the AAAA (ipv6) record for the given name.
Future<List<String>>	DnsClient.resolveA(String name)	Try to resolve all A (ipv4) records for the given name.
Future<List<String>>	DnsClient.resolveAAAA(String name)	Try to resolve all AAAA (ipv6) records for the given name.
Future<List<String>>	DnsClient.resolveCNAME(String name)	Try to resolve the CNAME record for the given name.
Future<List<MxRecord>>	DnsClient.resolveMX(String name)	Try to resolve the MX records for the given name.
Future<List<String>>	DnsClient.resolveNS(String name)	Try to resolve the NS records for the given name.
Future<String>	DnsClient.resolvePTR(String name)	Try to resolve the PTR record for the given name.
Future<List<SrvRecord>>	DnsClient.resolveSRV(String name)	Try to resolve the SRV records for the given name.
Future<List<String>>	DnsClient.resolveTXT(String name)	Try to resolve the TXT records for the given name.
default Future<String>	DnsClient.reverseLookup(String ipaddress)	Try to do a reverse lookup of an IP address.

Uses of Future in io.vertx.core.eventbus

Methods in io.vertx.core.eventbus that return Future

Modifier and Type	Method	Description
Future<Void>	MessageProducer.close()	Closes the producer, this method should be called when the message producer is not used anymore.
Future<Void>	MessageConsumer.completion()
default <R> Future<Message<R>>	Message.replyAndRequest(Object message)	Reply to this message, specifying a replyHandler for the reply - i.e. to receive the reply to the reply.
<R> Future<Message<R>>	Message.replyAndRequest(Object message, DeliveryOptions options)	Like Message.replyAndRequest(Object) but specifying options that can be used to configure the delivery.
default <T> Future<Message<T>>	EventBus.request(String address, Object message)	Sends a message and specify a replyHandler that will be called if the recipient subsequently replies to the message.
<T> Future<Message<T>>	EventBus.request(String address, Object message, DeliveryOptions options)	Like EventBus.request(String, Object) but specifying options that can be used to configure the delivery.
Future<Void>	MessageConsumer.unregister()	Unregisters the handler which created this registration
Future<Void>	MessageProducer.write(T body)	Write a message to the event-bus, either sending or publishing.

Uses of Future in io.vertx.core.file

Methods in io.vertx.core.file that return Future

Modifier and Type	Method	Description
Future<Void>	FileSystem.chmod(String path, String perms)	Change the permissions on the file represented by path to perms, asynchronously.
Future<Void>	FileSystem.chmodRecursive(String path, String perms, String dirPerms)	Change the permissions on the file represented by path to perms, asynchronously.
Future<Void>	FileSystem.chown(String path, String user, String group)	Change the ownership on the file represented by path to user and {code group}, asynchronously.
Future<Void>	AsyncFile.close()	Close the file.
Future<Void>	FileSystem.copy(String from, String to)	Copy a file from the path from to path to, asynchronously.
Future<Void>	FileSystem.copy(String from, String to, CopyOptions options)	Copy a file from the path from to path to, asynchronously.
Future<Void>	FileSystem.copyRecursive(String from, String to, boolean recursive)	Copy a file from the path from to path to, asynchronously.
Future<Void>	FileSystem.createFile(String path)	Creates an empty file with the specified path, asynchronously.
Future<Void>	FileSystem.createFile(String path, String perms)	Creates an empty file with the specified path and permissions perms, asynchronously.
Future<String>	FileSystem.createTempDirectory(String prefix)	Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
Future<String>	FileSystem.createTempDirectory(String prefix, String perms)	Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
Future<String>	FileSystem.createTempDirectory(String dir, String prefix, String perms)	Creates a new directory in the directory provided by the path path, using the given prefix to generate its name, asynchronously.
Future<String>	FileSystem.createTempFile(String prefix, String suffix)	Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
Future<String>	FileSystem.createTempFile(String prefix, String suffix, String perms)	Creates a new file in the directory provided by the path dir, using the given prefix and suffix to generate its name, asynchronously.
Future<String>	FileSystem.createTempFile(String dir, String prefix, String suffix, String perms)	Creates a new file in the directory provided by the path dir, using the given prefix and suffix to generate its name, asynchronously.
Future<Void>	FileSystem.delete(String path)	Deletes the file represented by the specified path, asynchronously.
Future<Void>	FileSystem.deleteRecursive(String path)	Deletes the file represented by the specified path, asynchronously.
Future<Boolean>	FileSystem.exists(String path)	Determines whether the file as specified by the path path exists, asynchronously.
Future<Void>	AsyncFile.flush()	Flush any writes made to this file to underlying persistent storage.
Future<FileSystemProps>	FileSystem.fsProps(String path)	Returns properties of the file-system being used by the specified path, asynchronously.
Future<Boolean>	AsyncFileLock.isValid()	A lock remains valid until it is released or the file corresponding AsyncFile is closed.
Future<Void>	FileSystem.link(String link, String existing)	Create a hard link on the file system from link to existing, asynchronously.
default Future<AsyncFileLock>	AsyncFile.lock()	Acquire a non-shared lock on the entire file.
Future<AsyncFileLock>	AsyncFile.lock(long position, long size, boolean shared)	Acquire a lock on a portion of this file.
Future<FileProps>	FileSystem.lprops(String path)	Obtain properties for the link represented by path, asynchronously.
Future<Void>	FileSystem.mkdir(String path)	Create the directory represented by path, asynchronously.
Future<Void>	FileSystem.mkdir(String path, String perms)	Create the directory represented by path, asynchronously.
Future<Void>	FileSystem.mkdirs(String path)	Create the directory represented by path and any non existent parents, asynchronously.
Future<Void>	FileSystem.mkdirs(String path, String perms)	Create the directory represented by path and any non existent parents, asynchronously.
Future<Void>	FileSystem.move(String from, String to)	Move a file from the path from to path to, asynchronously.
Future<Void>	FileSystem.move(String from, String to, CopyOptions options)	Move a file from the path from to path to, asynchronously.
Future<AsyncFile>	FileSystem.open(String path, OpenOptions options)	Open the file represented by path, asynchronously.
Future<FileProps>	FileSystem.props(String path)	Obtain properties for the file represented by path, asynchronously.
Future<Buffer>	AsyncFile.read(Buffer buffer, int offset, long position, int length)	Reads length bytes of data from the file at position position in the file, asynchronously.
Future<List<String>>	FileSystem.readDir(String path)	Read the contents of the directory specified by path, asynchronously.
Future<List<String>>	FileSystem.readDir(String path, String filter)	Read the contents of the directory specified by path, asynchronously.
Future<Buffer>	FileSystem.readFile(String path)	Reads the entire file as represented by the path path as a Buffer, asynchronously.
Future<String>	FileSystem.readSymlink(String link)	Returns the path representing the file that the symbolic link specified by link points to, asynchronously.
Future<Void>	AsyncFileLock.release()	Releases this lock;
Future<Long>	AsyncFile.size()
Future<Void>	FileSystem.symlink(String link, String existing)	Create a symbolic link on the file system from link to existing, asynchronously.
Future<Void>	FileSystem.truncate(String path, long len)	Truncate the file represented by path to length len in bytes, asynchronously.
Future<Void>	FileSystem.unlink(String link)	Unlinks the link on the file system represented by the path link, asynchronously.
default <T> Future<T>	AsyncFile.withLock(long position, long size, boolean shared, Supplier<Future<T>> block)	Acquire a lock on a portion of this file.
default <T> Future<T>	AsyncFile.withLock(Supplier<Future<T>> block)	Acquire a non-shared lock on the entire file.
Future<Void>	AsyncFile.write(Buffer buffer, long position)	Write a Buffer to the file at position position in the file, asynchronously.
Future<Void>	FileSystem.writeFile(String path, Buffer data)	Creates the file, and writes the specified Buffer data to the file represented by the path path, asynchronously.

Method parameters in io.vertx.core.file with type arguments of type Future

Modifier and Type	Method	Description
default <T> Future<T>	AsyncFile.withLock(long position, long size, boolean shared, Supplier<Future<T>> block)	Acquire a lock on a portion of this file.
default <T> Future<T>	AsyncFile.withLock(Supplier<Future<T>> block)	Acquire a non-shared lock on the entire file.

Uses of Future in io.vertx.core.http

Fields in io.vertx.core.http with type parameters of type Future

Modifier and Type	Field	Description
static final Function<HttpClientResponse, Future<RequestOptions>>	HttpClientAgent.DEFAULT_REDIRECT_HANDLER	Constant containing the default redirect handler of used by the client.

Methods in io.vertx.core.http that return Future

Modifier and Type	Method	Description
Future<ServerWebSocket>	ServerWebSocketHandshake.accept()	Accept the WebSocket and terminate the WebSocket handshake.
Future<Buffer>	HttpClientResponse.body()	Convenience method for receiving the entire request body in one piece.
Future<Buffer>	HttpServerRequest.body()	Convenience method for receiving the entire request body in one piece.
Future<Boolean>	HttpClientRequest.cancel()	Attempt to cancel the request according to the semantics of the underlying HTTP implementation.
Future<Boolean>	HttpServerResponse.cancel()	Attempt to cancel the request according to the semantics of the underlying HTTP implementation.
default Future<Void>	HttpClient.close()	Close immediately (shutdown(0, TimeUnit.SECONDS).
default Future<Void>	HttpClientConnection.close()
default Future<Void>	HttpConnection.close()	Close immediately (shutdown(0, TimeUnit.SECONDS).
default Future<Void>	HttpServer.close()	Close the server.
default Future<Void>	ServerWebSocket.close()	Close the WebSocket sending the default close frame.
default Future<Void>	WebSocketBase.close()	Close the WebSocket sending the default close frame.
default Future<Void>	WebSocketBase.close(short statusCode)	Close the WebSocket sending a close frame with specified status code.
default Future<Void>	WebSocketBase.close(short statusCode, String reason)	Close sending a close frame with specified status code and reason.
default Future<Void>	WebSocketClient.close()	Close immediately (shutdown(0, TimeUnit.SECONDS).
default Future<WebSocket>	ClientWebSocket.connect(int port, String host, String requestURI)	Connect this WebSocket to the specified port, host and relative request URI.
Future<WebSocket>	ClientWebSocket.connect(WebSocketConnectOptions options)	Connect this WebSocket with the specified options.
default Future<WebSocket>	ClientWebSocket.connect(String requestURI)	Connect this WebSocket at the relative request URI using the default host and port.
default Future<WebSocket>	ClientWebSocket.connect(String host, String requestURI)	Connect this WebSocket to the host and relative request URI and default port.
Future<HttpClientConnection>	HttpClientAgent.connect(HttpConnectOptions options)	Connect to a remote HTTP server with the specific options, the connection is un-pooled and the management of the connection is left to the user.
Future<HttpClientResponse>	HttpClientRequest.connect()	Create an HTTP tunnel to the server.
default Future<WebSocket>	WebSocketClient.connect(int port, String host, String requestURI)	Connect a WebSocket to the specified port, host and relative request URI.
Future<WebSocket>	WebSocketClient.connect(WebSocketConnectOptions options)	Connect a WebSocket with the specified options.
default Future<WebSocket>	WebSocketClient.connect(String requestURI)	Connect a WebSocket to the default client port, default client host and specified, relative request URI.
default Future<WebSocket>	WebSocketClient.connect(String host, String requestURI)	Connect a WebSocket to the default client port and specified host and relative request URI.
Future<Void>	HttpClientRequest.end()	Ends the request.
Future<Void>	HttpClientRequest.end(Buffer chunk)	Same as HttpClientRequest.end() but writes some data to the request body before ending.
Future<Void>	HttpClientRequest.end(String chunk)	Same as HttpClientRequest.end(Buffer) but writes a String in UTF-8 encoding
Future<Void>	HttpClientRequest.end(String chunk, String enc)	Same as HttpClientRequest.end(Buffer) but writes a String with the specified encoding
Future<Void>	HttpClientResponse.end()	Returns a future signaling when the response has been fully received successfully or failed.
Future<Void>	HttpServerRequest.end()	Returns a future signaling when the request has been fully received successfully or failed.
Future<Void>	HttpServerResponse.end()	Ends the response.
Future<Void>	HttpServerResponse.end(Buffer chunk)	Same as HttpServerResponse.end() but writes some data to the response body before ending.
Future<Void>	HttpServerResponse.end(String chunk)	Same as HttpServerResponse.end(Buffer) but writes a String in UTF-8 encoding before ending the response.
Future<Void>	HttpServerResponse.end(String chunk, String enc)	Same as HttpServerResponse.end(Buffer) but writes a String with the specified encoding before ending the response.
Future<Void>	WebSocketBase.end()	Ends the stream.
Future<HttpServer>	HttpServer.listen()	Tell the server to start listening.
default Future<HttpServer>	HttpServer.listen(int port)	Like HttpServer.listen(int, String) but the server will listen on host "0.0.0.0" and port specified here ignoring any value in the HttpServerOptions that was used when creating the server.
default Future<HttpServer>	HttpServer.listen(int port, String host)	Tell the server to start listening.
Future<HttpServer>	HttpServer.listen(SocketAddress address)	Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
Future<Buffer>	HttpConnection.ping(Buffer data)	Send a PING frame to the remote endpoint.
default Future<HttpServerResponse>	HttpServerResponse.push(HttpMethod method, HostAndPort authority, String path)	Like HttpServerResponse.push(HttpMethod, HostAndPort, String, MultiMap) with no headers.
Future<HttpServerResponse>	HttpServerResponse.push(HttpMethod method, HostAndPort authority, String path, MultiMap headers)	Push a response to the client.
default Future<HttpServerResponse>	HttpServerResponse.push(HttpMethod method, String path)	Like HttpServerResponse.push(HttpMethod, HostAndPort, String, MultiMap) with the host copied from the current request.
default Future<HttpServerResponse>	HttpServerResponse.push(HttpMethod method, String path, MultiMap headers)	Like HttpServerResponse.push(HttpMethod, HostAndPort, String, MultiMap) with the host copied from the current request.
default Future<Void>	ServerWebSocketHandshake.reject()	Reject the WebSocket.
Future<Void>	ServerWebSocketHandshake.reject(int status)	Like ServerWebSocketHandshake.reject() but with a status.
default Future<HttpClientRequest>	HttpClient.request()	Create an HTTP request to send to the server with the default host and port of the client.
default Future<HttpClientRequest>	HttpClient.request(HttpMethod method, int port, String host, String requestURI)	Create an HTTP request to send to the server at the host and port.
default Future<HttpClientRequest>	HttpClient.request(HttpMethod method, String requestURI)	Create an HTTP request to send to the server at the default host and port.
default Future<HttpClientRequest>	HttpClient.request(HttpMethod method, String host, String requestURI)	Create an HTTP request to send to the server at the host and default port.
Future<HttpClientRequest>	HttpClient.request(RequestOptions options)	Create an HTTP request to send to the server.
default Future<Void>	HttpClientRequest.reset()	Reset this stream with the error code 0.
Future<Void>	HttpClientRequest.reset(long code)	Reset this request:
Future<Void>	HttpClientRequest.reset(long code, Throwable cause)	Reset this request:
default Future<Void>	HttpServerResponse.reset()	Equivalent to calling HttpServerResponse.reset(long) with 0.
Future<Void>	HttpServerResponse.reset(long code)	Reset this response:
Future<HttpClientResponse>	HttpClientRequest.response()
default Future<HttpClientResponse>	HttpClientRequest.send()	Send the request with an empty body.
default Future<HttpClientResponse>	HttpClientRequest.send(Buffer body)	Send the request with a buffer body.
Future<HttpClientResponse>	HttpClientRequest.send(ClientForm form)	Like HttpClientRequest.send() but with a form.
default Future<HttpClientResponse>	HttpClientRequest.send(ReadStream<Buffer> body)	Send the request with a stream body.
default Future<HttpClientResponse>	HttpClientRequest.send(String body)	Send the request with a string body.
default Future<Void>	HttpServerResponse.send()	Send the request with an empty body.
default Future<Void>	HttpServerResponse.send(Buffer body)	Send the request with a buffer body.
default Future<Void>	HttpServerResponse.send(ReadStream<Buffer> body)	Send the request with a stream body.
default Future<Void>	HttpServerResponse.send(String body)	Send the request with a string body.
default Future<Void>	HttpServerResponse.sendFile(RandomAccessFile file)	Same as HttpServerResponse.sendFile(FileChannel) with RandomAccessFile
default Future<Void>	HttpServerResponse.sendFile(RandomAccessFile file, long offset)	Same as HttpServerResponse.sendFile(FileChannel, long) with RandomAccessFile
Future<Void>	HttpServerResponse.sendFile(RandomAccessFile file, long offset, long length)	Same as HttpServerResponse.sendFile(FileChannel, long, long) with RandomAccessFile
default Future<Void>	HttpServerResponse.sendFile(String filename)	Send the request with a stream body.
default Future<Void>	HttpServerResponse.sendFile(String filename, long offset)	Same as HttpServerResponse.sendFile(String, long, long) using length @code{Long.MAX_VALUE} which means until the end of the file.
Future<Void>	HttpServerResponse.sendFile(String filename, long offset, long length)	Ask the OS to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
default Future<Void>	HttpServerResponse.sendFile(FileChannel channel)	Same as HttpServerResponse.sendFile(FileChannel, long) using length @code{Long.MAX_VALUE} which means until the end of the file.
default Future<Void>	HttpServerResponse.sendFile(FileChannel channel, long offset)	Same as HttpServerResponse.sendFile(FileChannel, long, long) using length @code{Long.MAX_VALUE} which means until the end of the file.
Future<Void>	HttpServerResponse.sendFile(FileChannel channel, long offset, long length)	Ask the OS to stream a file as specified by channel directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system).
Future<Void>	HttpClientRequest.sendHead()	Deprecated, for removal: This API element is subject to removal in a future version. instead use HttpClientRequest.writeHead(), this is scheduled for removal in Vert.x 6
default Future<Void>	HttpClient.shutdown()	Shutdown with a 30 seconds timeout (shutdown(30, TimeUnit.SECONDS)).
default Future<Void>	HttpClient.shutdown(long timeout, TimeUnit unit)	Calls HttpClient.shutdown(Duration).
Future<Void>	HttpClient.shutdown(Duration timeout)	Initiate the client shutdown sequence.
default Future<Void>	HttpClientConnection.shutdown()
default Future<Void>	HttpClientConnection.shutdown(long timeout, TimeUnit unit)
default Future<Void>	HttpConnection.shutdown()	Shutdown with a 30 seconds timeout (shutdown(30, TimeUnit.SECONDS)).
default Future<Void>	HttpConnection.shutdown(long timeout, TimeUnit unit)	Calls HttpConnection.shutdown(Duration)
Future<Void>	HttpConnection.shutdown(Duration timeout)	Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight requests are processed, otherwise after a timeout the connection will be closed.
default Future<Void>	HttpServer.shutdown()	Shutdown with a 30 seconds timeout (shutdown(Duration.ofSeconds(30))).
default Future<Void>	HttpServer.shutdown(long timeout, TimeUnit unit)	Calls HttpServer.shutdown(Duration).
Future<Void>	HttpServer.shutdown(Duration timeout)	Initiate the server shutdown sequence.
default Future<Void>	WebSocketBase.shutdown()	Like WebSocketBase.shutdown(long, TimeUnit, short, String) with a 30 seconds timeout, the status code 1000 a null reason.
default Future<Void>	WebSocketBase.shutdown(long timeout, TimeUnit unit)	Calls WebSocketBase.shutdown(long, TimeUnit, short, String) with the status code 1000 and a null reason.
default Future<Void>	WebSocketBase.shutdown(long timeout, TimeUnit unit, short statusCode)	Calls WebSocketBase.shutdown(long, TimeUnit, short, String) with a null reason.
default Future<Void>	WebSocketBase.shutdown(long timeout, TimeUnit unit, short statusCode, String reason)	Calls WebSocketBase.shutdown(Duration, short, String)
default Future<Void>	WebSocketBase.shutdown(short statusCode)	Like WebSocketBase.shutdown(long, TimeUnit, short, String) with a 30 seconds timeout and a null reason.
default Future<Void>	WebSocketBase.shutdown(short statusCode, String reason)	Like WebSocketBase.shutdown(long, TimeUnit, short, String) with a 30 seconds timeout.
default Future<Void>	WebSocketBase.shutdown(Duration timeout)	Calls WebSocketBase.shutdown(Duration, short, String) with the status code 1000 and a null reason.
default Future<Void>	WebSocketBase.shutdown(Duration timeout, short statusCode)	Calls WebSocketBase.shutdown(Duration, short, String) with a null reason.
Future<Void>	WebSocketBase.shutdown(Duration timeout, short statusCode, String reason)	Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a timeout the WebSocket will be closed.
default Future<Void>	WebSocketClient.shutdown()	Shutdown with a 30 seconds timeout (shutdown(30, TimeUnit.SECONDS)).
default Future<Void>	WebSocketClient.shutdown(long timeout, TimeUnit unit)	Calls WebSocketClient.shutdown(Duration).
Future<Void>	WebSocketClient.shutdown(Duration timeout)	Initiate the client shutdown sequence.
Future<Void>	HttpServerFileUpload.streamToFileSystem(String filename)	Stream the content of this upload to the given file on storage.
Future<NetSocket>	HttpServerRequest.toNetSocket()	Establish a TCP tunnel with the client.
Future<ServerWebSocket>	HttpServerRequest.toWebSocket()	Upgrade the connection of the current request to a WebSocket.
Future<Void>	HttpConnection.updateSettings(HttpSettings settings)	Send to the remote endpoint an update of this endpoint settings
default Future<Boolean>	HttpClientAgent.updateSSLOptions(ClientSSLOptions options)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	HttpClientAgent.updateSSLOptions(ClientSSLOptions options, boolean force)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
default Future<Boolean>	HttpServer.updateSSLOptions(ServerSSLOptions options)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	HttpServer.updateSSLOptions(ServerSSLOptions options, boolean force)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
default Future<Boolean>	WebSocketClient.updateSSLOptions(ClientSSLOptions options)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	WebSocketClient.updateSSLOptions(ClientSSLOptions options, boolean force)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	HttpServer.updateTrafficShapingOptions(TrafficShapingOptions options)	Update the server with new traffic options, the update happens if the options object is valid and different from the existing options object.
Future<Void>	HttpClientRequest.write(String chunk)	Write a String to the request body, encoded as UTF-8.
Future<Void>	HttpClientRequest.write(String chunk, String enc)	Write a String to the request body, encoded using the encoding enc.
Future<Void>	HttpServerResponse.write(String chunk)	Write a String to the response body, encoded in UTF-8.
Future<Void>	HttpServerResponse.write(String chunk, String enc)	Write a String to the response body, encoded using the encoding enc.
Future<Void>	HttpServerResponse.writeAltSvc(String advertisement)	Write an invalid input: '<'a href="https://datatracker.ietf.org/doc/html/rfc7838"HTTP Alternative Services advertisement for the given request and its authority, according to the underlying protocol.
Future<Void>	WebSocketBase.writeBinaryMessage(Buffer data)	Writes a (potentially large) piece of binary data to the connection.
Future<Void>	HttpServerResponse.writeContinue()	Used to write an interim 100 Continue response to signify that the client should send the rest of the request.
Future<Void>	HttpClientRequest.writeCustomFrame(int type, int flags, Buffer payload)	Write an HTTP/2 frame to the request, allowing to extend the HTTP/2 protocol.
default Future<Void>	HttpClientRequest.writeCustomFrame(HttpFrame frame)	Like HttpClientRequest.writeCustomFrame(int, int, Buffer) but with an HttpFrame.
Future<Void>	HttpServerResponse.writeCustomFrame(int type, int flags, Buffer payload)	Write an HTTP/2 frame to the response, allowing to extend the HTTP/2 protocol.
default Future<Void>	HttpServerResponse.writeCustomFrame(HttpFrame frame)	Like HttpServerResponse.writeCustomFrame(int, int, Buffer) but with an HttpFrame.
Future<Void>	HttpServerResponse.writeEarlyHints(MultiMap headers)	Used to write an interim 103 Early Hints response to return some HTTP headers before the final HTTP message.
Future<Void>	WebSocketBase.writeFinalBinaryFrame(Buffer data)	Write a final WebSocket binary frame to the connection
Future<Void>	WebSocketBase.writeFinalTextFrame(String text)	Write a final WebSocket text frame to the connection
Future<Void>	WebSocketBase.writeFrame(WebSocketFrame frame)	Write a WebSocket frame to the connection
default Future<Void>	HttpClientRequest.writeHead()	Write the head of the request.
Future<Void>	HttpServerResponse.writeHead()	Send the response headers.
Future<Void>	WebSocketBase.writePing(Buffer data)	Writes a ping frame to the connection.
Future<Void>	WebSocketBase.writePong(Buffer data)	Writes a pong frame to the connection.
Future<Void>	WebSocketBase.writeTextMessage(String text)	Writes a (potentially large) piece of text data to the connection.

Method parameters in io.vertx.core.http with type arguments of type Future

Modifier and Type	Method	Description
HttpClientRequest	HttpClientRequest.redirectHandler(Function<HttpClientResponse, Future<HttpClientRequest>> handler)
HttpClientBuilder	HttpClientBuilder.withRedirectHandler(Function<HttpClientResponse, Future<RequestOptions>> handler)	Set a redirect handler for the http client.

Uses of Future in io.vertx.core.net

Methods in io.vertx.core.net that return Future

Modifier and Type	Method	Description
Future<Void>	QuicStream.abort(int error)	Instruct the remote peer that this part of the stream is no longer interested in received data and wants it to cease transmission, a STOP_SENDING frame is sent to the remote peer.
Future<SocketAddress>	QuicEndpoint.bind(SocketAddress address)	Binds a UDP socket at the given address.
default Future<Void>	NetClient.close()	Close immediately (shutdown(0, TimeUnit.SECONDS).
default Future<Void>	NetServer.close()	Close the server.
Future<Void>	NetSocket.close()	Close the socket
default Future<Void>	QuicConnection.close()	Close the connection, all associated streams will be closed before.
default Future<Void>	QuicConnection.close(QuicConnectionClose payload)	Close the connection, all associated streams will be closed before.
default Future<Void>	QuicEndpoint.close()	Close the endpoint and release all associated resources.
Future<Void>	StreamChannel.close()	Close the channel
Future<NetSocket>	NetClient.connect(int port, String host)	Open a connection to a server at the specific port and host.
Future<NetSocket>	NetClient.connect(int port, String host, String serverName)	Open a connection to a server at the specific port and host.
Future<NetSocket>	NetClient.connect(ConnectOptions connectOptions)	Open a connection to a server at the specific connectOptions.
Future<NetSocket>	NetClient.connect(SocketAddress remoteAddress)	Open a connection to a server at the specific remoteAddress.
Future<NetSocket>	NetClient.connect(SocketAddress remoteAddress, String serverName)	Open a connection to a server at the specific remoteAddress.
default Future<QuicConnection>	QuicClient.connect(int port, String host)	Connect to a Quic server at the specific port and host.
default Future<QuicConnection>	QuicClient.connect(int port, String host, QuicConnectOptions options)	Connect to a Quic server at the specific port and host, with specific options.
default Future<QuicConnection>	QuicClient.connect(SocketAddress address)	Connect to a Quic server.
Future<QuicConnection>	QuicClient.connect(SocketAddress address, QuicConnectOptions options)	Connect to a Quic server with specific options.
Future<Void>	NetSocket.end()	Calls NetSocket.close()
Future<Void>	StreamChannel.end()	Calls StreamChannel.close()
Future<NetServer>	NetServer.listen()	Start listening on the port and host as configured in the NetServerOptions used when creating the server.
default Future<NetServer>	NetServer.listen(int port)	Start listening on the specified port and host "0.0.0.0", ignoring port and host configured in the NetServerOptions used when creating the server.
default Future<NetServer>	NetServer.listen(int port, String host)	Start listening on the specified port and host, ignoring port and host configured in the NetServerOptions used when creating the server.
Future<NetServer>	NetServer.listen(SocketAddress localAddress)	Start listening on the specified local address, ignoring port and host configured in the NetServerOptions used when creating the server.
Future<SocketAddress>	QuicServer.listen()	Start listening on the port and host as configured in the QuicServerConfig used when creating the server.
default Future<SocketAddress>	QuicServer.listen(int port)	Start listening on the specified port and host "0.0.0.0".
default Future<SocketAddress>	QuicServer.listen(int port, String host)	Start listening on the specified port and host.
default Future<SocketAddress>	QuicServer.listen(SocketAddress localAddress)	Start listening on the specified local address.
default Future<QuicStream>	QuicConnection.openStream()	Open a bidirectional stream to the remote endpoint.
Future<QuicStream>	QuicConnection.openStream(boolean bidirectional)	Open a stream to the remote endpoint with bidirectional parameter specifying its directionality.
Future<Void>	QuicStream.reset(int error)	Abruptly terminate the sending part of the stream with the specified application protocol error code argument, a RESET frame is sent to the remote peer.
default Future<Void>	NetSocket.sendFile(String filename)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
default Future<Void>	NetSocket.sendFile(String filename, long offset)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	NetSocket.sendFile(String filename, long offset, long length)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
default Future<Void>	StreamChannel.sendFile(String filename)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
default Future<Void>	StreamChannel.sendFile(String filename, long offset)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	StreamChannel.sendFile(String filename, long offset, long length)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
default Future<Void>	NetClient.shutdown()	Shutdown with a 30 seconds timeout (shutdown(30, TimeUnit.SECONDS)).
default Future<Void>	NetClient.shutdown(long timeout, TimeUnit unit)	Calls NetClient.shutdown(Duration).
Future<Void>	NetClient.shutdown(Duration timeout)	Initiate the client shutdown sequence.
default Future<Void>	NetServer.shutdown()	Shutdown with a 30 seconds timeout (shutdown(30, TimeUnit.SECONDS)).
default Future<Void>	NetServer.shutdown(long timeout, TimeUnit unit)	Calls NetServer.shutdown(Duration).
Future<Void>	NetServer.shutdown(Duration timeout)	Initiate the server shutdown sequence.
default Future<Void>	QuicConnection.shutdown()	Shutdown with a 30 seconds timeout.
default Future<Void>	QuicConnection.shutdown(Duration timeout)	Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight streams are processed, otherwise after a timeout the connection will be closed.
Future<Void>	QuicConnection.shutdown(Duration timeout, QuicConnectionClose payload)	Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight streams are processed, otherwise after a timeout the connection will be closed.
default Future<Void>	QuicEndpoint.shutdown()	Shutdown the endpoint with a 30 seconds grace period (shutdown(30, TimeUnit.SECONDS)).
Future<Void>	QuicEndpoint.shutdown(Duration timeout)	Initiate the endpoint shutdown sequence.
default Future<Boolean>	NetClient.updateSSLOptions(ClientSSLOptions options)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	NetClient.updateSSLOptions(ClientSSLOptions options, boolean force)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
default Future<Boolean>	NetServer.updateSSLOptions(ServerSSLOptions options)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	NetServer.updateSSLOptions(ServerSSLOptions options, boolean force)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
default Future<Boolean>	QuicServer.updateSSLOptions(ServerSSLOptions options)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	QuicServer.updateSSLOptions(ServerSSLOptions options, boolean force)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	NetServer.updateTrafficShapingOptions(TrafficShapingOptions options)	Update the server with new traffic options, the update happens if the options object is valid and different from the existing options object.
default Future<Void>	NetSocket.upgradeToSsl()	Like NetSocket.upgradeToSsl(SSLOptions, String, Buffer) with the default SSL options, without indicating a server name, without an upgrade message.
default Future<Void>	NetSocket.upgradeToSsl(Buffer msg)	Like NetSocket.upgradeToSsl(SSLOptions, String, Buffer) with the default SSL options and without indicating a server name.
default Future<Void>	NetSocket.upgradeToSsl(SSLOptions sslOptions)	Upgrade channel to use SSL/TLS.
default Future<Void>	NetSocket.upgradeToSsl(SSLOptions sslOptions, Buffer msg)	Like NetSocket.upgradeToSsl(SSLOptions, String, Buffer) without indicating a server name
default Future<Void>	NetSocket.upgradeToSsl(SSLOptions sslOptions, String serverName)	Like NetSocket.upgradeToSsl(SSLOptions, String, Buffer) without an upgrade message.
Future<Void>	NetSocket.upgradeToSsl(SSLOptions sslOptions, String serverName, Buffer upgrade)	Upgrade the channel to use SSL/TLS, in other words proceeds to the TLS handshake.
default Future<Void>	NetSocket.upgradeToSsl(String serverName)	Like NetSocket.upgradeToSsl(SSLOptions, String, Buffer) with the default SSL options and without an update message.
default Future<Void>	NetSocket.upgradeToSsl(String serverName, Buffer msg)	Like NetSocket.upgradeToSsl(SSLOptions, String, Buffer) with the default SSL options.
Future<Void>	NetSocket.write(String str)	Write a String to the connection, encoded in UTF-8.
Future<Void>	NetSocket.write(String str, String enc)	Write a String to the connection, encoded using the encoding enc.
Future<Void>	StreamChannel.write(String str)	Write a String to the connection, encoded in UTF-8.
Future<Void>	StreamChannel.write(String str, String enc)	Write a String to the connection, encoded using the encoding enc.
Future<Void>	QuicConnection.writeDatagram(Buffer buffer)	Send a datagram.

Uses of Future in io.vertx.core.net.endpoint

Methods in io.vertx.core.net.endpoint that return Future

Modifier and Type	Method	Description
Future<Endpoint>	EndpointResolver.resolveEndpoint(Address address)	Resolver an endpoint for the specified address

Uses of Future in io.vertx.core.shareddata

Methods in io.vertx.core.shareddata that return Future

Modifier and Type	Method	Description
Future<Long>	Counter.addAndGet(long value)	Add the value to the counter atomically and return the new count
Future<Void>	AsyncMap.clear()	Clear all entries in the map
Future<Boolean>	Counter.compareAndSet(long expected, long value)	Set the counter to the specified value only if the current value is the expectec value.
Future<Long>	Counter.decrementAndGet()	Decrement the counter atomically and return the new count
Future<Map<K,V>>	AsyncMap.entries()	Get the entries of the map, asynchronously.
Future<V>	AsyncMap.get(K k)	Get a value from the map, asynchronously.
Future<Long>	Counter.get()	Get the current value of the counter
Future<Long>	Counter.getAndAdd(long value)	Add the value to the counter atomically and return the value before the add
Future<Long>	Counter.getAndIncrement()	Increment the counter atomically and return the value before the increment.
<K,V> Future<AsyncMap<K,V>>	SharedData.getAsyncMap(String name)	Get the AsyncMap with the specified name.
<K,V> Future<AsyncMap<K,V>>	SharedData.getClusterWideMap(String name)	Get the cluster wide map with the specified name.
Future<Counter>	SharedData.getCounter(String name)	Get an asynchronous counter.
<K,V> Future<AsyncMap<K,V>>	SharedData.getLocalAsyncMap(String name)	Get the AsyncMap with the specified name.
Future<Counter>	SharedData.getLocalCounter(String name)	Get an asynchronous local counter.
Future<Lock>	SharedData.getLocalLock(String name)	Get an asynchronous local lock with the specified name.
Future<Lock>	SharedData.getLocalLockWithTimeout(String name, long timeout)	Like SharedData.getLocalLock(String) but specifying a timeout.
Future<Lock>	SharedData.getLock(String name)	Get an asynchronous lock with the specified name.
Future<Lock>	SharedData.getLockWithTimeout(String name, long timeout)	Like SharedData.getLock(String) but specifying a timeout.
Future<Long>	Counter.incrementAndGet()	Increment the counter atomically and return the new count
Future<Set<K>>	AsyncMap.keys()	Get the keys of the map, asynchronously.
Future<Void>	AsyncMap.put(K k, V v)	Put a value in the map, asynchronously.
Future<Void>	AsyncMap.put(K k, V v, long ttl)	Like AsyncMap.put(K, V) but specifying a time to live for the entry.
Future<V>	AsyncMap.putIfAbsent(K k, V v)	Put the entry only if there is no entry with the key already present.
Future<V>	AsyncMap.putIfAbsent(K k, V v, long ttl)	Link AsyncMap.putIfAbsent(K, V) but specifying a time to live for the entry.
Future<V>	AsyncMap.remove(K k)	Remove a value from the map, asynchronously.
Future<Boolean>	AsyncMap.removeIfPresent(K k, V v)	Remove a value from the map, only if entry already exists with same value.
Future<V>	AsyncMap.replace(K k, V v)	Replace the entry only if it is currently mapped to some value
default Future<V>	AsyncMap.replace(K k, V v, long ttl)	Replace the entry only if it is currently mapped to some value
Future<Boolean>	AsyncMap.replaceIfPresent(K k, V oldValue, V newValue)	Replace the entry only if it is currently mapped to a specific value
default Future<Boolean>	AsyncMap.replaceIfPresent(K k, V oldValue, V newValue, long ttl)	Replace the entry only if it is currently mapped to a specific value
Future<Integer>	AsyncMap.size()	Provide the number of entries in the map
Future<List<V>>	AsyncMap.values()	Get the values of the map, asynchronously.
default <T> Future<T>	SharedData.withLocalLock(String name, long timeout, Supplier<Future<T>> block)	Like SharedData.withLocalLock(String, Supplier) but specifying a timeout.
default <T> Future<T>	SharedData.withLocalLock(String name, Supplier<Future<T>> block)	Get an asynchronous local lock with the specified name.
default <T> Future<T>	SharedData.withLock(String name, long timeout, Supplier<Future<T>> block)	Like SharedData.withLock(String, Supplier) but specifying a timeout.
default <T> Future<T>	SharedData.withLock(String name, Supplier<Future<T>> block)	Get an asynchronous lock with the specified name.

Method parameters in io.vertx.core.shareddata with type arguments of type Future

Modifier and Type	Method	Description
default <T> Future<T>	SharedData.withLocalLock(String name, long timeout, Supplier<Future<T>> block)	Like SharedData.withLocalLock(String, Supplier) but specifying a timeout.
default <T> Future<T>	SharedData.withLocalLock(String name, Supplier<Future<T>> block)	Get an asynchronous local lock with the specified name.
default <T> Future<T>	SharedData.withLock(String name, long timeout, Supplier<Future<T>> block)	Like SharedData.withLock(String, Supplier) but specifying a timeout.
default <T> Future<T>	SharedData.withLock(String name, Supplier<Future<T>> block)	Get an asynchronous lock with the specified name.

Uses of Future in io.vertx.core.spi.dns

Methods in io.vertx.core.spi.dns that return Future

Modifier and Type	Method	Description
Future<Void>	AddressResolverProvider.close()

Uses of Future in io.vertx.core.spi.endpoint

Methods in io.vertx.core.spi.endpoint that return Future

Modifier and Type	Method	Description
default Future<D>	EndpointResolver.refresh(A address, D state)
Future<D>	EndpointResolver.resolve(A address, EndpointBuilder<E,S> builder)	Resolve an address to the resolver state for this name.

Uses of Future in io.vertx.core.streams

Methods in io.vertx.core.streams that return Future

Modifier and Type	Method	Description
default <R,A> Future<R>	ReadStream.collect(Collector<T,A,R> collector)	Apply a collector to this stream, the obtained result is returned as a future.
Future<Void>	WriteStream.end()	Ends the stream.
default Future<Void>	WriteStream.end(T data)	Same as WriteStream.end() but writes some data to the stream before ending.
default Future<Void>	ReadStream.pipeTo(WriteStream<T> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	Pipe.to(WriteStream<T> dst)	Start to pipe the elements to the destination WriteStream.
Future<Void>	WriteStream.write(T data)	Write some data to the stream.

Uses of Future in io.vertx.db2client

Methods in io.vertx.db2client that return Future

Modifier and Type	Method	Description
static Future<DB2Connection>	DB2Connection.connect(Vertx vertx, DB2ConnectOptions connectOptions)	Create a connection to DB2 server with the given connectOptions.
static Future<DB2Connection>	DB2Connection.connect(Vertx vertx, String connectionUri)	Like DB2Connection.connect(Vertx, DB2ConnectOptions) with options build from connectionUri.
Future<Void>	DB2Connection.debug()	Send a DEBUG command to dump debug information to the server's stdout.
Future<Void>	DB2Connection.ping()	Send a PING command to check if the server is alive.

Uses of Future in io.vertx.db2client.spi

Method parameters in io.vertx.db2client.spi with type arguments of type Future

Modifier and Type	Method	Description
protected Pool	DB2Driver.newPool(io.vertx.core.internal.VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<DB2ConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, io.vertx.core.internal.CloseFuture closeFuture)

Uses of Future in io.vertx.ext.auth.authentication

Methods in io.vertx.ext.auth.authentication that return Future

Modifier and Type	Method	Description
Future<User>	AuthenticationProvider.authenticate(Credentials credentials)	Authenticate a user.

Uses of Future in io.vertx.ext.auth.authorization

Methods in io.vertx.ext.auth.authorization that return Future

Modifier and Type	Method	Description
Future<Void>	AuthorizationProvider.getAuthorizations(User user)	Updates the user with the set of authorizations.

Uses of Future in io.vertx.ext.auth.mongo

Methods in io.vertx.ext.auth.mongo that return Future

Modifier and Type	Method	Description
Future<String>	MongoUserUtil.createHashedUser(String username, String hash)	Insert a user into a database.
Future<String>	MongoUserUtil.createUser(String username, String password)	Insert a user into a database.
Future<String>	MongoUserUtil.createUserRolesAndPermissions(String user, List<String> roles, List<String> permissions)	Insert a user role into a database.

Uses of Future in io.vertx.ext.auth.oauth2

Methods in io.vertx.ext.auth.oauth2 that return Future

Modifier and Type	Method	Description
Future<Void>	OAuth2Auth.jWKSet()	Retrieve the public server JSON Web Key (JWK) required to verify the authenticity of issued ID and access tokens.
Future<User>	OAuth2Auth.refresh(User user)	Refresh the current User (access token).
default Future<Void>	OAuth2Auth.revoke(User user)	Revoke an obtained access token.
Future<Void>	OAuth2Auth.revoke(User user, String tokenType)	Revoke an obtained access or refresh token.
Future<JsonObject>	OAuth2Auth.userInfo(User user)	Retrieve profile information and other attributes for a logged-in end-user.

Uses of Future in io.vertx.ext.auth.oauth2.providers

Methods in io.vertx.ext.auth.oauth2.providers that return Future

Modifier and Type	Method	Description
static Future<OAuth2Auth>	AmazonCognitoAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	AppleIdAuth.discover(Vertx vertx, PubSecKeyOptions privateKey, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	AzureADAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	GoogleAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	IBMCloudAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	KeycloakAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	OpenIDConnectAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	SalesforceAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	ZohoAuth.discover(Vertx vertx, String soid, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	ZohoAuth.discover(Vertx vertx, String dc, String soid, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.

Uses of Future in io.vertx.ext.auth.otp.hotp

Methods in io.vertx.ext.auth.otp.hotp that return Future

Modifier and Type	Method	Description
Future<Authenticator>	HotpAuth.createAuthenticator(String id, OtpKey otpKey)	Creating authenticator from user id and key.

Method parameters in io.vertx.ext.auth.otp.hotp with type arguments of type Future

Modifier and Type	Method	Description
HotpAuth	HotpAuth.authenticatorFetcher(Function<String, Future<Authenticator>> fetcher)	Provide a Function that can fetch Authenticators from a backend given an identifier argument.
HotpAuth	HotpAuth.authenticatorUpdater(Function<Authenticator, Future<Void>> updater)	Provide a Function that can update or insert a Authenticator.

Uses of Future in io.vertx.ext.auth.otp.totp

Methods in io.vertx.ext.auth.otp.totp that return Future

Modifier and Type	Method	Description
Future<Authenticator>	TotpAuth.createAuthenticator(String id, OtpKey otpKey)	Creating authenticator from user id and key.

Method parameters in io.vertx.ext.auth.otp.totp with type arguments of type Future

Modifier and Type	Method	Description
TotpAuth	TotpAuth.authenticatorFetcher(Function<String, Future<Authenticator>> fetcher)	Provide a Function that can fetch Authenticators from a backend given an identifier argument.
TotpAuth	TotpAuth.authenticatorUpdater(Function<Authenticator, Future<Void>> updater)	Provide a Function that can update or insert a Authenticator.

Uses of Future in io.vertx.ext.auth.sqlclient

Methods in io.vertx.ext.auth.sqlclient that return Future

Modifier and Type	Method	Description
Future<Void>	SqlUserUtil.createHashedUser(String username, String hash)	Insert a user into a database.
Future<Void>	SqlUserUtil.createRolePermission(String role, String permission)	Insert a role permission into a database.
Future<Void>	SqlUserUtil.createUser(String username, String password)	Insert a user into a database.
Future<Void>	SqlUserUtil.createUserRole(String username, String role)	Insert a user role into a database.

Uses of Future in io.vertx.ext.auth.webauthn4j

Methods in io.vertx.ext.auth.webauthn4j that return Future

Modifier and Type	Method	Description
Future<JsonObject>	WebAuthn4J.createCredentialsOptions(JsonObject user)	Gets a challenge and any other parameters for the navigator.credentials.create() call.
Future<List<Authenticator>>	CredentialStorage.find(String userName, String credentialId)	Finds an existing list of credentials for a given user name and credential ID.
Future<JsonObject>	WebAuthn4J.getCredentialsOptions(String username)	Creates an assertion challenge and any other parameters for the navigator.credentials.get() call.
Future<Void>	CredentialStorage.storeCredential(Authenticator authenticator)	Persists a new credential, bound by its user name (may be null) and credential ID (cannot be null, must be unique).
Future<Void>	CredentialStorage.updateCounter(Authenticator authenticator)	Updates a previously stored credential counter, as identified by its user name (may be null) and credential ID (cannot be null, must be unique).

Uses of Future in io.vertx.ext.consul

Methods in io.vertx.ext.consul that return Future

Modifier and Type	Method	Description
Future<JsonObject>	ConsulClient.agentInfo()	Returns the configuration and member information of the local agent
Future<List<String>>	ConsulClient.catalogDatacenters()	Return all the datacenters that are known by the Consul server
Future<NodeList>	ConsulClient.catalogNodes()	Returns the nodes registered in a datacenter
Future<ServiceList>	ConsulClient.catalogNodeServices(String node)	Returns the node's registered services
Future<ServiceList>	ConsulClient.catalogNodeServicesWithOptions(String node, BlockingQueryOptions options)	Returns the node's registered services This is blocking query unlike ConsulClient.catalogNodeServices(String)
Future<NodeList>	ConsulClient.catalogNodesWithOptions(NodeQueryOptions options)	Returns the nodes registered in a datacenter
Future<ServiceList>	ConsulClient.catalogServiceNodes(String service)	Returns the nodes providing a service
Future<ServiceList>	ConsulClient.catalogServiceNodesWithOptions(String service, ServiceQueryOptions options)	Returns the nodes providing a service
Future<ServiceList>	ConsulClient.catalogServices()	Returns the services registered in a datacenter
Future<ServiceList>	ConsulClient.catalogServicesWithOptions(BlockingQueryOptions options)	Returns the services registered in a datacenter This is blocking query unlike ConsulClient.catalogServices()
Future<AclToken>	ConsulClient.cloneAclToken(String accessorId, CloneAclTokenOptions cloneAclTokenOptions)	Clones an existing ACL token
Future<List<DcCoordinates>>	ConsulClient.coordinateDatacenters()	Returns the WAN network coordinates for all Consul servers, organized by DCs
Future<CoordinateList>	ConsulClient.coordinateNodes()	Returns the LAN network coordinates for all nodes in a given DC
Future<CoordinateList>	ConsulClient.coordinateNodesWithOptions(BlockingQueryOptions options)	Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike ConsulClient.coordinateNodes()
Future<String>	ConsulClient.createAclPolicy(AclPolicy policy)	Creates a new ACL policy
Future<AclToken>	ConsulClient.createAclToken(AclToken token)	Create an Acl token
Future<String>	ConsulClient.createPreparedQuery(PreparedQueryDefinition definition)
Future<String>	ConsulClient.createSession()	Initialize a new session
Future<String>	ConsulClient.createSessionWithOptions(SessionOptions options)	Initialize a new session
Future<Boolean>	ConsulClient.deleteAclToken(String accessorId)	Deletes an ACL token
Future<Boolean>	ConsulClient.deletePolicy(String id)	This endpoint deletes an ACL policy
Future<Void>	ConsulClient.deletePreparedQuery(String id)	Deletes an existing prepared query
Future<Void>	ConsulClient.deleteValue(String key)	Remove the key/value pair that corresponding to the specified key
Future<Void>	ConsulClient.deleteValues(String keyPrefix)	Removes all the key/value pair that corresponding to the specified key prefix
Future<Void>	ConsulClient.deregisterCatalogService(String nodeId, String serviceId)	Deregister entities from the node or deregister the node itself.
Future<Void>	ConsulClient.deregisterCheck(String checkId)	Remove a check from the local agent.
Future<Void>	ConsulClient.deregisterService(String id)	Remove a service from the local agent.
Future<Void>	ConsulClient.destroySession(String id)	Destroys the given session
Future<PreparedQueryExecuteResponse>	ConsulClient.executePreparedQuery(String query)	Executes an existing prepared query.
Future<PreparedQueryExecuteResponse>	ConsulClient.executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options)	Executes an existing prepared query.
Future<Void>	ConsulClient.failCheck(String checkId)	Set status of the check to "critical".
Future<Void>	ConsulClient.failCheckWithNote(String checkId, String note)	Set status of the check to "critical".
Future<Event>	ConsulClient.fireEvent(String name)	Fires a new user event
Future<Event>	ConsulClient.fireEventWithOptions(String name, EventOptions options)	Fires a new user event
Future<List<AclPolicy>>	ConsulClient.getAclPolicies()	This endpoint lists all the ACL policies.
Future<List<AclToken>>	ConsulClient.getAclTokens()	Get list of Acl token
Future<List<PreparedQueryDefinition>>	ConsulClient.getAllPreparedQueries()	Returns a list of all prepared queries.
Future<List<String>>	ConsulClient.getKeys(String keyPrefix)	Returns the list of keys that corresponding to the specified key prefix.
Future<List<String>>	ConsulClient.getKeysWithOptions(String keyPrefix, BlockingQueryOptions options)	Returns the list of keys that corresponding to the specified key prefix.
Future<PreparedQueryDefinition>	ConsulClient.getPreparedQuery(String id)	Returns an existing prepared query
Future<KeyValue>	ConsulClient.getValue(String key)	Returns key/value pair that corresponding to the specified key.
Future<KeyValueList>	ConsulClient.getValues(String keyPrefix)	Returns the list of key/value pairs that corresponding to the specified key prefix.
Future<KeyValueList>	ConsulClient.getValuesWithOptions(String keyPrefix, BlockingQueryOptions options)	Returns the list of key/value pairs that corresponding to the specified key prefix.
Future<KeyValue>	ConsulClient.getValueWithOptions(String key, BlockingQueryOptions options)	Returns key/value pair that corresponding to the specified key.
Future<CheckList>	ConsulClient.healthChecks(String service)	Returns the checks associated with the service
Future<CheckList>	ConsulClient.healthChecksWithOptions(String service, CheckQueryOptions options)	Returns the checks associated with the service
Future<CheckList>	ConsulClient.healthNodesWithOptions(String node, CheckQueryOptions options)	Returns the checks specific to the node provided on the path.
Future<ServiceEntryList>	ConsulClient.healthServiceNodes(String service, boolean passing)	Returns the nodes providing the service.
Future<ServiceEntryList>	ConsulClient.healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options)	Returns the nodes providing the service.
Future<CheckList>	ConsulClient.healthState(HealthState healthState)	Returns the checks in the specified status
Future<CheckList>	ConsulClient.healthStateWithOptions(HealthState healthState, CheckQueryOptions options)	Returns the checks in the specified status
Future<Session>	ConsulClient.infoSession(String id)	Returns the requested session information
Future<Session>	ConsulClient.infoSessionWithOptions(String id, BlockingQueryOptions options)	Returns the requested session information This is blocking query unlike ConsulClient.infoSession(String)
Future<String>	ConsulClient.leaderStatus()	Get the Raft leader for the datacenter in which the agent is running.
Future<EventList>	ConsulClient.listEvents()	Returns the most recent events known by the agent
Future<EventList>	ConsulClient.listEventsWithOptions(EventListOptions options)	Returns the most recent events known by the agent.
Future<SessionList>	ConsulClient.listNodeSessions(String nodeId)	Returns the active sessions for a given node
Future<SessionList>	ConsulClient.listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options)	Returns the active sessions for a given node This is blocking query unlike ConsulClient.listNodeSessions(String)
Future<SessionList>	ConsulClient.listSessions()	Returns the active sessions
Future<SessionList>	ConsulClient.listSessionsWithOptions(BlockingQueryOptions options)	Returns the active sessions This is blocking query unlike ConsulClient.listSessions()
Future<List<Check>>	ConsulClient.localChecks()	Return all the checks that are registered with the local agent.
Future<List<Service>>	ConsulClient.localServices()	Returns list of services registered with the local agent.
Future<Void>	ConsulClient.maintenanceService(MaintenanceOptions maintenanceOptions)	Places a given service into "maintenance mode"
Future<Void>	ConsulClient.passCheck(String checkId)	Set status of the check to "passing".
Future<Void>	ConsulClient.passCheckWithNote(String checkId, String note)	Set status of the check to "passing".
Future<List<String>>	ConsulClient.peersStatus()	Retrieves the Raft peers for the datacenter in which the the agent is running.
Future<Boolean>	ConsulClient.putValue(String key, String value)	Adds specified key/value pair
Future<Boolean>	ConsulClient.putValueWithOptions(String key, String value, KeyValueOptions options)
Future<AclToken>	ConsulClient.readAclToken(String accessorId)	Reads an ACL token with the given Accessor ID
Future<AclPolicy>	ConsulClient.readPolicy(String id)	This endpoint reads an ACL policy with the given ID
Future<AclPolicy>	ConsulClient.readPolicyByName(String name)	This endpoint reads an ACL policy with the given name
Future<Void>	ConsulClient.registerCatalogService(Node nodeOptions, ServiceOptions serviceOptions)	Register node with external service
Future<Void>	ConsulClient.registerCheck(CheckOptions checkOptions)	Add a new check to the local agent.
Future<Void>	ConsulClient.registerService(ServiceOptions serviceOptions)	Adds a new service, with an optional health check, to the local agent.
Future<Session>	ConsulClient.renewSession(String id)	Renews the given session.
Future<TxnResponse>	ConsulClient.transaction(TxnRequest request)	Manages multiple operations inside a single, atomic transaction.
Future<AclToken>	ConsulClient.updateAclToken(String accessorId, AclToken token)	Update an existing Acl token
Future<Void>	ConsulClient.updateCheck(String checkId, CheckStatus status)	Set status of the check to given status.
Future<Void>	ConsulClient.updateCheckWithNote(String checkId, CheckStatus status, String note)	Set status of the check to given status.
Future<AclPolicy>	ConsulClient.updatePolicy(String id, AclPolicy policy)	This endpoint updates an existing ACL policy
Future<Void>	ConsulClient.updatePreparedQuery(PreparedQueryDefinition definition)
Future<Void>	ConsulClient.warnCheck(String checkId)	Set status of the check to "warning".
Future<Void>	ConsulClient.warnCheckWithNote(String checkId, String note)	Set status of the check to "warning".

Uses of Future in io.vertx.ext.eventbus.bridge.tcp

Methods in io.vertx.ext.eventbus.bridge.tcp that return Future

Modifier and Type	Method	Description
Future<Void>	TcpEventBusBridge.close()	Close the current socket.
Future<TcpEventBusBridge>	TcpEventBusBridge.listen()	Start listening on the port and host as configured in the NetServerOptions used when creating the server.
Future<TcpEventBusBridge>	TcpEventBusBridge.listen(int port)	Start listening on the specified port and host "0.0.0.0", ignoring port and host configured in the NetServerOptions used when creating the server.
Future<TcpEventBusBridge>	TcpEventBusBridge.listen(int port, String address)	Start listening on the specified port and host, ignoring port and host configured in the NetServerOptions used when creating the server.
default Future<TcpEventBusBridge>	TcpEventBusBridge.listen(SocketAddress localAddress)	Start listening on the specified local address, ignoring port and host configured in the NetServerOptions used when creating the server.

Uses of Future in io.vertx.ext.healthchecks

Methods in io.vertx.ext.healthchecks that return Future

Modifier and Type	Method	Description
Future<CheckResult>	HealthChecks.checkStatus()	Invokes the registered procedures.
Future<CheckResult>	HealthChecks.checkStatus(String name)	Invokes the registered procedure with the given name and sub-procedures.
Future<JsonObject>	HealthChecks.invoke(String name)	Invokes the registered procedure with the given name and sub-procedures.

Methods in io.vertx.ext.healthchecks with parameters of type Future

Modifier and Type	Method	Description
static boolean	CheckResult.isUp(Future<CheckResult> json)

Uses of Future in io.vertx.ext.mail

Methods in io.vertx.ext.mail that return Future

Modifier and Type	Method	Description
Future<Void>	MailClient.close()	Close the MailClient
Future<MailResult>	MailClient.sendMail(MailMessage email)	send a single mail via MailClient

Method parameters in io.vertx.ext.mail with type arguments of type Future

Modifier and Type	Method	Description
MailClientBuilder	MailClientBuilder.withCredentialsSupplier(Supplier<Future<UsernamePasswordCredentials>> credentialsSupplier)	Set a credentials supplier for the mail client.

Uses of Future in io.vertx.ext.mongo

Methods in io.vertx.ext.mongo that return Future

Modifier and Type	Method	Description
Future<MongoClientBulkWriteResult>	MongoClient.bulkWrite(String collection, List<BulkOperation> operations)	Execute a bulk operation.
Future<MongoClientBulkWriteResult>	MongoClient.bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions)	Execute a bulk operation with the specified write options.
Future<Void>	MongoClient.close()	Close the client and release its resources
Future<Long>	MongoClient.count(String collection, JsonObject query)	Count matching documents in a collection.
Future<Long>	MongoClient.countWithOptions(String collection, JsonObject query, CountOptions countOptions)	Count matching documents in a collection.
Future<Void>	MongoClient.createCollection(String collectionName)	Create a new collection
Future<Void>	MongoClient.createCollectionWithOptions(String collectionName, CreateCollectionOptions collectionOptions)	Create a new collection with options
Future<MongoGridFsClient>	MongoClient.createDefaultGridFsBucketService()	Creates a MongoGridFsClient used to interact with Mongo GridFS.
Future<MongoGridFsClient>	MongoClient.createGridFsBucketService(String bucketName)	Creates a MongoGridFsClient used to interact with Mongo GridFS.
Future<Void>	MongoClient.createIndex(String collection, JsonObject key)	Creates an index.
Future<Void>	MongoClient.createIndexes(String collection, List<IndexModel> indexes)	creates an indexes
Future<Void>	MongoClient.createIndexWithOptions(String collection, JsonObject key, IndexOptions options)	Creates an index.
Future<Void>	MongoGridFsClient.delete(String id)	Deletes a file by it's ID
Future<JsonArray>	MongoClient.distinct(String collection, String fieldName, String resultClassname)	Gets the distinct values of the specified field name.
Future<JsonArray>	MongoClient.distinct(String collection, String fieldName, String resultClassname, DistinctOptions distinctOptions)	Gets the distinct values of the specified field name.
Future<JsonArray>	MongoClient.distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query)	Gets the distinct values of the specified field name filtered by specified query.
Future<JsonArray>	MongoClient.distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, DistinctOptions distinctOptions)	Gets the distinct values of the specified field name filtered by specified query.
Future<Long>	MongoGridFsClient.downloadByFileName(WriteStream<Buffer> stream, String fileName)
Future<Long>	MongoGridFsClient.downloadByFileNameWithOptions(WriteStream<Buffer> stream, String fileName, GridFsDownloadOptions options)
Future<Long>	MongoGridFsClient.downloadById(WriteStream<Buffer> stream, String id)
Future<Long>	MongoGridFsClient.downloadFile(String fileName)	Downloads a file.
Future<Long>	MongoGridFsClient.downloadFileAs(String fileName, String newFileName)	Downloads a file and gives it a new name.
Future<Long>	MongoGridFsClient.downloadFileByID(String id, String fileName)	Downloads a file using the ID generated by GridFs.
Future<Void>	MongoGridFsClient.drop()	Drops the entire file bucket with all of its contents
Future<Void>	MongoClient.dropCollection(String collection)	Drop a collection
Future<Void>	MongoClient.dropIndex(String collection, JsonObject key)	Drops the index given the keys used to create it.
Future<Void>	MongoClient.dropIndex(String collection, String indexName)	Drops the index given its name.
Future<List<JsonObject>>	MongoClient.find(String collection, JsonObject query)	Find matching documents in the specified collection
Future<List<String>>	MongoGridFsClient.findAllIds()	Finds all file ids in the bucket
Future<List<String>>	MongoGridFsClient.findIds(JsonObject query)	Finds all file ids that match a query.
Future<JsonObject>	MongoClient.findOne(String collection, JsonObject query, JsonObject fields)	Find a single matching document in the specified collection
Future<JsonObject>	MongoClient.findOneAndDelete(String collection, JsonObject query)	Find a single matching document in the specified collection and delete it.
Future<JsonObject>	MongoClient.findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions)	Find a single matching document in the specified collection and delete it.
Future<JsonObject>	MongoClient.findOneAndReplace(String collection, JsonObject query, JsonObject replace)	Find a single matching document in the specified collection and replace it.
Future<JsonObject>	MongoClient.findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions)	Find a single matching document in the specified collection and replace it.
Future<JsonObject>	MongoClient.findOneAndUpdate(String collection, JsonObject query, JsonObject update)	Find a single matching document in the specified collection and update it.
Future<JsonObject>	MongoClient.findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions)	Find a single matching document in the specified collection and update it.
Future<List<JsonObject>>	MongoClient.findWithOptions(String collection, JsonObject query, FindOptions options)	Find matching documents in the specified collection, specifying options
Future<List<String>>	MongoClient.getCollections()	Get a list of all collections in the database.
Future<String>	MongoClient.insert(String collection, JsonObject document)	Insert a document in the specified collection
Future<String>	MongoClient.insertWithOptions(String collection, JsonObject document, WriteOption writeOption)	Insert a document in the specified collection with the specified write option
Future<JsonArray>	MongoClient.listIndexes(String collection)	Get all the indexes in this collection.
Future<MongoClientDeleteResult>	MongoClient.removeDocument(String collection, JsonObject query)	Remove a single matching document from a collection and return the handler with MongoClientDeleteResult result
Future<MongoClientDeleteResult>	MongoClient.removeDocuments(String collection, JsonObject query)	Remove matching documents from a collection and return the handler with MongoClientDeleteResult result
Future<MongoClientDeleteResult>	MongoClient.removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption)	Remove matching documents from a collection with the specified write option and return the handler with MongoClientDeleteResult result
Future<MongoClientDeleteResult>	MongoClient.removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption)	Remove a single matching document from a collection with the specified write option and return the handler with MongoClientDeleteResult result
Future<Void>	MongoClient.renameCollection(String oldCollectionName, String newCollectionName)	Rename a collection
Future<Void>	MongoClient.renameCollectionWithOptions(String oldCollectionName, String newCollectionName, RenameCollectionOptions collectionOptions)	Rename a collection
Future<MongoClientUpdateResult>	MongoClient.replaceDocuments(String collection, JsonObject query, JsonObject replace)	Replace matching documents in the specified collection and return the handler with MongoClientUpdateResult result
Future<MongoClientUpdateResult>	MongoClient.replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options)	Replace matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
Future<JsonObject>	MongoClient.runCommand(String commandName, JsonObject command)	Run an arbitrary MongoDB command.
Future<String>	MongoClient.save(String collection, JsonObject document)	Save a document in the specified collection
Future<String>	MongoClient.saveWithOptions(String collection, JsonObject document, WriteOption writeOption)	Save a document in the specified collection with the specified write option
Future<MongoClientUpdateResult>	MongoClient.updateCollection(String collection, JsonObject query, JsonArray update)	Use an aggregation pipeline to update documents in the specified collection and return the handler with MongoClientUpdateResult result
Future<MongoClientUpdateResult>	MongoClient.updateCollection(String collection, JsonObject query, JsonObject update)	Update matching documents in the specified collection and return the handler with MongoClientUpdateResult result
Future<MongoClientUpdateResult>	MongoClient.updateCollectionWithOptions(String collection, JsonObject query, JsonArray update, UpdateOptions options)	Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
Future<MongoClientUpdateResult>	MongoClient.updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options)	Update matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
Future<String>	MongoGridFsClient.uploadByFileName(ReadStream<Buffer> stream, String fileName)
Future<String>	MongoGridFsClient.uploadByFileNameWithOptions(ReadStream<Buffer> stream, String fileName, GridFsUploadOptions options)
Future<String>	MongoGridFsClient.uploadFile(String fileName)	Upload a file to gridfs
Future<String>	MongoGridFsClient.uploadFileWithOptions(String fileName, GridFsUploadOptions options)	Upload a file to gridfs with options

Uses of Future in io.vertx.ext.reactivestreams

Methods in io.vertx.ext.reactivestreams that return Future

Modifier and Type	Method	Description
Future<Void>	ReactiveWriteStream.write(T data)

Uses of Future in io.vertx.ext.shell

Methods in io.vertx.ext.shell that return Future

Modifier and Type	Method	Description
Future<Void>	ShellServer.close()	Close the shell server, this is an asynchronous close.
Future<Void>	ShellServer.listen()	Start the shell service, this is an asynchronous start.
Future<Void>	ShellService.start()	Start the shell service, this is an asynchronous start.
Future<Void>	ShellService.stop()	Stop the shell service, this is an asynchronous stop.

Uses of Future in io.vertx.ext.shell.command

Methods in io.vertx.ext.shell.command that return Future

Modifier and Type	Method	Description
Future<Command>	CommandRegistry.registerCommand(Command command)	Register a command
Future<Command>	CommandRegistry.registerCommand(Class<? extends AnnotatedCommand> command)	Register a single command.
Future<List<Command>>	CommandRegistry.registerCommands(List<Command> commands)	Register a list of commands.
Future<Void>	CommandRegistry.unregisterCommand(String commandName)	Unregister a command.

Uses of Future in io.vertx.ext.shell.term

Methods in io.vertx.ext.shell.term that return Future

Modifier and Type	Method	Description
Future<Void>	TermServer.close()	Close the server.
Future<Void>	TermServer.listen()	Bind the term server, the TermServer.termHandler(Handler) must be set before.

Uses of Future in io.vertx.ext.stomp

Methods in io.vertx.ext.stomp that return Future

Modifier and Type	Method	Description
Future<Frame>	StompClientConnection.abort(String id)	Aborts a transaction.
Future<Frame>	StompClientConnection.abort(String id, Map<String,String> headers)	Aborts a transaction.
Future<Frame>	StompClientConnection.ack(String id)	Sends an acknowledgement for a specific message.
Future<Frame>	StompClientConnection.ack(String id, String txId)	Sends an acknowledgement for the given frame.
Future<Frame>	StompClientConnection.beginTX(String id)	Begins a transaction.
Future<Frame>	StompClientConnection.beginTX(String id, Map<String,String> headers)	Begins a transaction.
Future<Void>	StompClient.close()	Closes the client.
Future<Void>	StompServer.close()	Closes the server.
Future<Frame>	StompClientConnection.commit(String id)	Commits a transaction.
Future<Frame>	StompClientConnection.commit(String id, Map<String,String> headers)	Commits a transaction.
Future<StompClientConnection>	StompClient.connect()	Connects to the server using the host and port configured in the client's options.
Future<StompClientConnection>	StompClient.connect(int port, String host)	Connects to the server.
Future<Frame>	StompClientConnection.disconnect()	Disconnects the client.
Future<Frame>	StompClientConnection.disconnect(Frame frame)	Disconnects the client.
Future<StompServer>	StompServer.listen()	Connects the STOMP server default port (61613) and network interface (0.0.0.0).
Future<StompServer>	StompServer.listen(int port)	Connects the STOMP server to the given port.
Future<StompServer>	StompServer.listen(int port, String host)	Connects the STOMP server to the given port / interface.
Future<Frame>	StompClientConnection.nack(String id)	Sends a non-acknowledgement for the given message.
Future<Frame>	StompClientConnection.nack(String id, String txId)	Sends a non-acknowledgement for the given frame.
Future<Boolean>	StompServerHandler.onAuthenticationRequest(StompServerConnection connection, String login, String passcode)	Called when the client connects to a server requiring authentication.
Future<Frame>	StompClientConnection.send(Frame frame)	Sends the given frame to the server.
Future<Frame>	StompClientConnection.send(String destination, Buffer body)	Sends a SEND frame to the server to the given destination.
Future<Frame>	StompClientConnection.send(String destination, Map<String,String> headers, Buffer body)	Sends a SEND frame to the server to the given destination.
Future<Frame>	StompClientConnection.send(Map<String,String> headers, Buffer body)	Sends a SEND frame to the server.
Future<String>	StompClientConnection.subscribe(String destination, Handler<Frame> handler)	Subscribes to the given destination.
Future<String>	StompClientConnection.subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)	Subscribes to the given destination.
Future<Frame>	StompClientConnection.unsubscribe(String destination)	Un-subscribes from the given destination.
Future<Frame>	StompClientConnection.unsubscribe(String destination, Map<String,String> headers)	Un-subscribes from the given destination.

Uses of Future in io.vertx.ext.unit.junit

Constructors in io.vertx.ext.unit.junit with parameters of type Future

Modifier	Constructor	Description
	RunTestOnContext(Future<Vertx> createVertx)	Create a new rule with an asynchronous supplier for creating a Vert.x instance.
	RunTestOnContext(Future<Vertx> createVertx, BiConsumer<Vertx, Consumer<Void>> closeVertx)	Create a new rule with an asynchronous supplier and consumer for creating and closing a Vert.x instance.

Uses of Future in io.vertx.ext.web

Methods in io.vertx.ext.web that return Future

Modifier and Type	Method	Description
Future<Void>	FileUpload.delete()	Delete the uploaded file on the disk.
default Future<Void>	RoutingContext.end()	Shortcut to the response end.
default Future<Void>	RoutingContext.end(Buffer buffer)	Shortcut to the response end.
default Future<Void>	RoutingContext.end(String chunk)	Shortcut to the response end.
Future<Void>	UserContext.impersonate()	Impersonates a second identity.
Future<Void>	UserContext.impersonate(String redirectUri)	Impersonates a second identity.
default Future<Void>	RoutingContext.json(Object json)	Encode an Object to JSON and end the request.
Future<Void>	UserContext.logout()	Logout can be called from any route handler which needs to terminate a login session.
Future<Void>	UserContext.logout(String redirectUri)	Logout can be called from any route handler which needs to terminate a login session.
default Future<Void>	RoutingContext.redirect(String url)	Perform a 302 redirect to url.
Future<Void>	UserContext.refresh()	Forces the current user to re-authenticate.
Future<Void>	UserContext.refresh(String redirectUri)	Forces the current user to re-authenticate.
Future<Void>	UserContext.restore()	Undo a previous call to a impersonation.
Future<Void>	UserContext.restore(String redirectUri)	Undo a previous call to an impersonation.

Method parameters in io.vertx.ext.web with type arguments of type Future

Modifier and Type	Method	Description
default <T> Route	Route.respond(Function<RoutingContext, Future<T>> function)	Append a function request handler to the route handlers list.

Uses of Future in io.vertx.ext.web.client

Methods in io.vertx.ext.web.client that return Future

Modifier and Type	Method	Description
Future<HttpResponse<T>>	HttpRequest.send()	Send a request, the handler will receive the response as an HttpResponse.
Future<HttpResponse<T>>	HttpRequest.sendBuffer(Buffer body)	Like HttpRequest.send() but with an HTTP request body buffer.
Future<HttpResponse<T>>	HttpRequest.sendForm(MultiMap body)	Like HttpRequest.send() but with an HTTP request body multimap encoded as form and the content type set to application/x-www-form-urlencoded.
Future<HttpResponse<T>>	HttpRequest.sendForm(MultiMap body, String charset)	Like HttpRequest.send() but with an HTTP request body multimap encoded as form and the content type set to application/x-www-form-urlencoded.
Future<HttpResponse<T>>	HttpRequest.sendJson(Object body)	Like HttpRequest.send() but with an HTTP request body object encoded as json and the content type set to application/json.
Future<HttpResponse<T>>	HttpRequest.sendJsonObject(JsonObject body)	Like HttpRequest.send() but with an HTTP request body object encoded as json and the content type set to application/json.
Future<HttpResponse<T>>	HttpRequest.sendMultipartForm(MultipartForm body)	Like HttpRequest.send() but with an HTTP request body multimap encoded as form and the content type set to multipart/form-data.
Future<HttpResponse<T>>	HttpRequest.sendStream(ReadStream<Buffer> body)	Like HttpRequest.send() but with an HTTP request body stream.
default Future<Boolean>	WebClient.updateSSLOptions(ClientSSLOptions options)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	WebClient.updateSSLOptions(ClientSSLOptions options, boolean force)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.

Uses of Future in io.vertx.ext.web.client.spi

Methods in io.vertx.ext.web.client.spi that return Future

Modifier and Type	Method	Description
Future<Void>	CacheStore.delete(io.vertx.ext.web.client.impl.cache.CacheKey key)	Delete a key from the cache.
Future<Void>	CacheStore.flush()	Delete all entries from the cache.
Future<io.vertx.ext.web.client.impl.cache.CachedHttpResponse>	CacheStore.get(io.vertx.ext.web.client.impl.cache.CacheKey key)	Retrieve a cached response.
Future<io.vertx.ext.web.client.impl.cache.CachedHttpResponse>	CacheStore.set(io.vertx.ext.web.client.impl.cache.CacheKey key, io.vertx.ext.web.client.impl.cache.CachedHttpResponse response)	Add a response in the cache with the given key.

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	Description
Future<T>	BodyStream.result()

Uses of Future in io.vertx.ext.web.common.template

Methods in io.vertx.ext.web.common.template that return Future

Modifier and Type	Method	Description
default Future<Buffer>	TemplateEngine.render(JsonObject context, String templateFileName)	Render the template.
Future<Buffer>	TemplateEngine.render(Map<String,Object> context, String templateFileName)	Render the template.

Uses of Future in io.vertx.ext.web.handler

Methods in io.vertx.ext.web.handler that return Future

Modifier and Type	Method	Description
default Future<Void>	SessionHandler.flush(RoutingContext ctx)	Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
Future<Void>	SessionHandler.flush(RoutingContext ctx, boolean ignoreStatus)	Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
Future<Void>	SessionHandler.setUser(RoutingContext context, User user)	Set the user for the session

Method parameters in io.vertx.ext.web.handler with type arguments of type Future

Modifier and Type	Method	Description
SimpleAuthenticationHandler	SimpleAuthenticationHandler.authenticate(Function<RoutingContext, Future<User>> authenticationFunction)	This function will allow you to perform authentication the way you intended to.
APIKeyHandler	APIKeyHandler.tokenExtractor(Function<String, Future<String>> tokenExtractor)	Transform from user's token format to the AuthenticationHandler's format.

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

Methods in io.vertx.ext.web.handler.sockjs that return Future

Modifier and Type	Method	Description
Future<Void>	SockJSSocket.end()	Call SockJSSocket.close().
Future<Void>	SockJSSocket.write(Buffer data)
default Future<Void>	SockJSSocket.write(String data)	Write a String to the socket, encoded in UTF-8.

Uses of Future in io.vertx.ext.web.healthchecks

Method parameters in io.vertx.ext.web.healthchecks with type arguments of type Future

Modifier and Type	Method	Description
HealthCheckHandler	HealthCheckHandler.resultMapper(Function<CheckResult, Future<CheckResult>> resultMapper)	Sets a function which will be invoked before the CheckResult gets written to clients.

Uses of Future in io.vertx.ext.web.openapi.router

Methods in io.vertx.ext.web.openapi.router that return Future

Modifier and Type	Method	Description
Future<ValidatableRequest>	RequestExtractor.extractValidatableRequest(RoutingContext routingContext, Operation operation)	Extracts and transforms the parameters and the body of an incoming request into a format that can be validated by the RequestValidator.
Future<RouterBuilder>	Security.openIdConnectHandler(String callback, Function<String, Future<OAuth2AuthHandler>> factory)	Configure the OAuth2AuthHandler to be used when creating the router.
default Future<RouterBuilder>	Security.openIdConnectHandler(Function<String, Future<OAuth2AuthHandler>> factory)	Configure the OAuth2AuthHandler to be used when creating the router.

Method parameters in io.vertx.ext.web.openapi.router with type arguments of type Future

Modifier and Type	Method	Description
Future<RouterBuilder>	Security.openIdConnectHandler(String callback, Function<String, Future<OAuth2AuthHandler>> factory)	Configure the OAuth2AuthHandler to be used when creating the router.
default Future<RouterBuilder>	Security.openIdConnectHandler(Function<String, Future<OAuth2AuthHandler>> factory)	Configure the OAuth2AuthHandler to be used when creating the router.

Uses of Future in io.vertx.ext.web.sstore

Methods in io.vertx.ext.web.sstore that return Future

Modifier and Type	Method	Description
Future<Void>	SessionStore.clear()	Remove all sessions from the store.
Future<Void>	SessionStore.delete(String id)	Delete the session with the specified ID.
Future<Session>	SessionStore.get(String cookieValue)	Get the session with the specified ID.
Future<Void>	SessionStore.put(Session session)	Add a session with the specified ID.
Future<Integer>	SessionStore.size()	Get the number of sessions in the store.

Uses of Future in io.vertx.grpc.client

Methods in io.vertx.grpc.client that return Future

Modifier and Type	Method	Description
Future<Void>	GrpcClient.close()	Close this client.
<Req,Resp> Future<GrpcClientRequest<Req,Resp>>	ServiceInvoker.invoker(ServiceMethod<Resp,Req> method)	Create a request for the given service method.
Future<GrpcClientRequest<Buffer,Buffer>>	GrpcClient.request()	Like GrpcClient.request(Address) with the default remote server.
Future<GrpcClientRequest<Buffer,Buffer>>	GrpcClient.request(Address server)	Connect to the remote server and create a request for any hosted gRPC service.
<Req,Resp> Future<GrpcClientRequest<Req,Resp>>	GrpcClient.request(Address server, ServiceMethod<Resp,Req> method)	Connect to the remote server and create a request for any hosted gRPC service.
<Req,Resp> Future<GrpcClientRequest<Req,Resp>>	GrpcClient.request(ServiceMethod<Resp,Req> method)	Like GrpcClient.request(Address, ServiceMethod) with the default remote server.
Future<GrpcClientResponse<Req,Resp>>	GrpcClientRequest.response()
default Future<GrpcClientResponse<Req,Resp>>	GrpcClientRequest.send(ReadStream<Req> body)
default Future<GrpcClientResponse<Req,Resp>>	GrpcClientRequest.send(Req item)

Uses of Future in io.vertx.grpc.common

Methods in io.vertx.grpc.common that return Future

Modifier and Type	Method	Description
Future<Void>	GrpcReadStream.end()
Future<Void>	GrpcWriteStream.endMessage(GrpcMessage message)	End the stream with an encoded gRPC message.
Future<T>	GrpcReadStream.last()
Future<Void>	GrpcWriteStream.writeMessage(GrpcMessage message)	Write an encoded gRPC message.

Uses of Future in io.vertx.grpc.event.v1alpha

Methods in io.vertx.grpc.event.v1alpha that return Future

Modifier and Type	Method	Description
Future<com.google.protobuf.Empty>	EventBusBridge.ping(com.google.protobuf.Empty request)
Future<com.google.protobuf.Empty>	EventBusBridgeClient.ping(com.google.protobuf.Empty request)	Calls the Ping RPC service method.
Future<com.google.protobuf.Empty>	EventBusBridgeService.ping(com.google.protobuf.Empty request)	Override this method to implement the Ping RPC.
Future<com.google.protobuf.Empty>	EventBusBridge.publish(PublishOp request)
Future<com.google.protobuf.Empty>	EventBusBridgeClient.publish(PublishOp request)	Calls the Publish RPC service method.
Future<com.google.protobuf.Empty>	EventBusBridgeService.publish(PublishOp request)	Override this method to implement the Publish RPC.
Future<EventBusMessage>	EventBusBridge.request(RequestOp request)
Future<EventBusMessage>	EventBusBridgeClient.request(RequestOp request)	Calls the Request RPC service method.
Future<EventBusMessage>	EventBusBridgeService.request(RequestOp request)	Override this method to implement the Request RPC.
Future<com.google.protobuf.Empty>	EventBusBridge.send(SendOp request)
Future<com.google.protobuf.Empty>	EventBusBridgeClient.send(SendOp request)	Calls the Send RPC service method.
Future<com.google.protobuf.Empty>	EventBusBridgeService.send(SendOp request)	Override this method to implement the Send RPC.
Future<ReadStream<EventBusMessage>>	EventBusBridge.subscribe(SubscribeOp request)
Future<ReadStream<EventBusMessage>>	EventBusBridgeClient.subscribe(SubscribeOp request)	Calls the Subscribe RPC service method.
Future<ReadStream<EventBusMessage>>	EventBusBridgeService.subscribe(SubscribeOp request)	Override this method to implement the Subscribe RPC.
Future<com.google.protobuf.Empty>	EventBusBridge.unsubscribe(UnsubscribeOp request)
Future<com.google.protobuf.Empty>	EventBusBridgeClient.unsubscribe(UnsubscribeOp request)	Calls the Unsubscribe RPC service method.
Future<com.google.protobuf.Empty>	EventBusBridgeService.unsubscribe(UnsubscribeOp request)	Override this method to implement the Unsubscribe RPC.

Uses of Future in io.vertx.grpc.server

Methods in io.vertx.grpc.server that return Future

Modifier and Type	Method	Description
default Future<Void>	Service.close()	Close the service.
default Future<Void>	GrpcServerResponse.send(ReadStream<Resp> body)
default Future<Void>	GrpcServerResponse.send(Resp item)
Future<Void>	GrpcServerResponse.writeHead()	Send the response headers.

Uses of Future in io.vertx.grpc.stub

Methods in io.vertx.grpc.stub that return Future

Modifier and Type	Method	Description
Future<Void>	GrpcWriteStream.end()	Deprecated.
static <I,O> Future<O>	ClientCalls.manyToOne(io.vertx.core.internal.ContextInternal ctx, Handler<WriteStream<I>> requestHandler, Function<StreamObserver<O>, StreamObserver<I>> delegate)	Deprecated.
static <I,O> Future<O>	ClientCalls.oneToOne(io.vertx.core.internal.ContextInternal ctx, I request, BiConsumer<I, StreamObserver<O>> delegate)	Deprecated.
Future<Void>	GrpcWriteStream.write(T data)	Deprecated.

Method parameters in io.vertx.grpc.stub with type arguments of type Future

Modifier and Type	Method	Description
static <I,O> StreamObserver<I>	ServerCalls.manyToOne(StreamObserver<O> response, String compression, Function<ReadStream<I>, Future<O>> delegate)	Deprecated, for removal: This API element is subject to removal in a future version.
static <I,O> void	ServerCalls.oneToOne(I request, StreamObserver<O> response, String compression, Function<I, Future<O>> delegate)	Deprecated, for removal: This API element is subject to removal in a future version.

Uses of Future in io.vertx.grpcio.client

Methods in io.vertx.grpcio.client that return Future

Modifier and Type	Method	Description
default <Req,Resp,T> Future<T>	GrpcIoClient.call(MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, Function<GrpcClientResponse<Req,Resp>, Future<T>> resultFn)	Like GrpcIoClient.call(Address, MethodDescriptor, Handler, Function) with the default remote server.
default <Req,Resp,T> Future<T>	GrpcIoClient.call(Address server, MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, Function<GrpcClientResponse<Req,Resp>, Future<T>> resultFn)	Call the service gRPC service hosted by server.
<Req,Resp> Future<GrpcClientRequest<Req,Resp>>	GrpcIoClient.request(MethodDescriptor<Req,Resp> service)	Like GrpcIoClient.request(Address, MethodDescriptor) with the default remote server.
<Req,Resp> Future<GrpcClientRequest<Req,Resp>>	GrpcIoClient.request(Address server, MethodDescriptor<Req,Resp> service)	Connect to the remote server and create a request for given method of a hosted gRPC service.

Method parameters in io.vertx.grpcio.client with type arguments of type Future

Modifier and Type	Method	Description
default <Req,Resp,T> Future<T>	GrpcIoClient.call(MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, Function<GrpcClientResponse<Req,Resp>, Future<T>> resultFn)	Like GrpcIoClient.call(Address, MethodDescriptor, Handler, Function) with the default remote server.
default <Req,Resp,T> Future<T>	GrpcIoClient.call(Address server, MethodDescriptor<Req,Resp> service, Handler<GrpcClientRequest<Req,Resp>> requestHandler, Function<GrpcClientResponse<Req,Resp>, Future<T>> resultFn)	Call the service gRPC service hosted by server.

Uses of Future in io.vertx.httpproxy

Methods in io.vertx.httpproxy that return Future

Modifier and Type	Method	Description
Future<HttpClientRequest>	OriginRequestProvider.create(ProxyContext proxyContext)	Create the HttpClientRequest to the origin server for a given ProxyContext.
default Future<ProxyResponse>	ProxyInterceptor.handleProxyRequest(ProxyContext context)	Handle the proxy request at the stage of this interceptor.
default Future<Void>	ProxyInterceptor.handleProxyResponse(ProxyContext context)	Handle the proxy response at the stage of this interceptor.
default Future<Void>	ProxyRequest.proxy(HttpClientRequest request)	Proxy this request to the origin server using the specified request and then send the proxy response.
Future<ProxyResponse>	ProxyRequest.send(HttpClientRequest request)	Send this request to the origin server using the specified request.
Future<Void>	ProxyResponse.send()	Send the proxies response to the user agent.
Future<ProxyResponse>	ProxyContext.sendRequest()
Future<Void>	ProxyContext.sendResponse()
default Future<Body>	BodyTransformer.transform(Body body)	Return the future body, transformed.

Method parameters in io.vertx.httpproxy with type arguments of type Future

Modifier and Type	Method	Description
static OriginRequestProvider	OriginRequestProvider.selector(Function<ProxyContext, Future<SocketAddress>> selector)	Creates a provider that selects the origin server based on ProxyContext.

Uses of Future in io.vertx.httpproxy.spi.cache

Methods in io.vertx.httpproxy.spi.cache that return Future

Modifier and Type	Method	Description
Future<Resource>	Cache.get(String key)	Being called when the proxy attempts to fetch a cache item.
Future<Void>	Cache.put(String key, Resource value)	Being called when the proxy attempts to add a new cache item.
Future<Void>	Cache.remove(String key)	Being called when the proxy attempts to delete a cache item, typically caused by invalidating an existing item.

Uses of Future in io.vertx.jdbcclient

Methods in io.vertx.jdbcclient that return Future

Modifier and Type	Method	Description
Future<Integer>	JDBCConnection.getTransactionIsolation()
Future<Void>	JDBCConnection.setTransactionIsolation(int isolationLevel)

Uses of Future in io.vertx.junit5

Methods in io.vertx.junit5 that return Future

Modifier and Type	Method	Description
<T> Future<T>	VertxTestContext.assertComplete(Future<T> fut)	This method allows you to check if a future is completed.
<T> Future<T>	VertxTestContext.assertFailure(Future<T> fut)	This method allows you to check if a future is failed.

Methods in io.vertx.junit5 with parameters of type Future

Modifier and Type	Method	Description
<T> Future<T>	VertxTestContext.assertComplete(Future<T> fut)	This method allows you to check if a future is completed.
<T> Future<T>	VertxTestContext.assertFailure(Future<T> fut)	This method allows you to check if a future is failed.

Constructor parameters in io.vertx.junit5 with type arguments of type Future

Modifier	Constructor	Description
	RunTestOnContext(Supplier<Future<Vertx>> supplier)	Create an instance of this extension that gets a Vertx object using the specified asynchronous supplier.
	RunTestOnContext(Supplier<Future<Vertx>> supplier, Function<Vertx, Future<Void>> shutdown)	Create an instance of this extension that gets a Vertx object using the specified asynchronous supplier.
	RunTestOnContext(Supplier<Future<Vertx>> supplier, Function<Vertx, Future<Void>> shutdown)	Create an instance of this extension that gets a Vertx object using the specified asynchronous supplier.

Uses of Future in io.vertx.kafka.admin

Methods in io.vertx.kafka.admin that return Future

Modifier and Type	Method	Description
Future<Void>	KafkaAdminClient.alterConfigs(Map<ConfigResource, Config> configs)	Update the configuration for the specified resources with the default options
Future<Void>	KafkaAdminClient.alterConsumerGroupOffsets(String groupId, Map<TopicPartition, OffsetAndMetadata> offsets)	Alter committed offsets for a set of partitions in a consumer group.
Future<Void>	KafkaAdminClient.close()	Close the admin client
Future<Void>	KafkaAdminClient.close(long timeout)	Close the admin client
Future<List<org.apache.kafka.common.acl.AclBinding>>	KafkaAdminClient.createAcls(List<org.apache.kafka.common.acl.AclBinding> aclBindings)	Create the ACL rules.
Future<Void>	KafkaAdminClient.createPartitions(Map<String, NewPartitions> partitions)	Creates a batch of new partitions in the Kafka topic
Future<Void>	KafkaAdminClient.createTopics(List<NewTopic> topics)	Creates a batch of new Kafka topics
Future<List<org.apache.kafka.common.acl.AclBinding>>	KafkaAdminClient.deleteAcls(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings)	Delete the ACL rules.
Future<Void>	KafkaAdminClient.deleteConsumerGroupOffsets(String groupId, Set<TopicPartition> partitions)	Delete committed offsets for a set of partitions in a consumer group.
Future<Void>	KafkaAdminClient.deleteConsumerGroups(List<String> groupIds)	Delete consumer groups from the cluster.
Future<Map<TopicPartition, org.apache.kafka.clients.admin.DeletedRecords>>	KafkaAdminClient.deleteRecords(Map<TopicPartition, org.apache.kafka.clients.admin.RecordsToDelete> recordsToDelete)	Delete records from a topic partition.
Future<Void>	KafkaAdminClient.deleteTopics(List<String> topicNames)	Deletes a batch of Kafka topics
Future<List<org.apache.kafka.common.acl.AclBinding>>	KafkaAdminClient.describeAcls(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter)	Describe the ACL rules.
Future<ClusterDescription>	KafkaAdminClient.describeCluster()	Describe the nodes in the cluster with the default options
Future<ClusterDescription>	KafkaAdminClient.describeCluster(DescribeClusterOptions options)	Like KafkaAdminClient.describeCluster() but allows customized options.
Future<Map<ConfigResource, Config>>	KafkaAdminClient.describeConfigs(List<ConfigResource> configResources)	Get the configuration for the specified resources with the default options
Future<Map<String, ConsumerGroupDescription>>	KafkaAdminClient.describeConsumerGroups(List<String> groupIds)	Describe some group ids in the cluster, with the default options
Future<Map<String, ConsumerGroupDescription>>	KafkaAdminClient.describeConsumerGroups(List<String> groupIds, DescribeConsumerGroupsOptions options)	Like KafkaAdminClient.describeConsumerGroups(List) but allows customized options
Future<Map<Integer, Map<String, org.apache.kafka.clients.admin.LogDirDescription>>>	KafkaAdminClient.describeLogDirs(List<Integer> brokers)	Query the information of all log directories on the given set of brokers
Future<Map<String, TopicDescription>>	KafkaAdminClient.describeTopics(List<String> topicNames)	Describe some topics in the cluster, with the default options.
Future<Map<String, TopicDescription>>	KafkaAdminClient.describeTopics(List<String> topicNames, DescribeTopicsOptions options)	Like KafkaAdminClient.describeTopics(List) but allows for customised otions
default Future<Map<TopicPartition, OffsetAndMetadata>>	KafkaAdminClient.listConsumerGroupOffsets(String groupId)	List the consumer group offsets available in the cluster.
Future<Map<TopicPartition, OffsetAndMetadata>>	KafkaAdminClient.listConsumerGroupOffsets(String groupId, ListConsumerGroupOffsetsSpec spec, ListConsumerGroupOffsetsOptions options)	List the consumer group offsets available in the cluster.
Future<List<ConsumerGroupListing>>	KafkaAdminClient.listConsumerGroups()	Get the the consumer groups available in the cluster with the default options
Future<Map<TopicPartition, ListOffsetsResultInfo>>	KafkaAdminClient.listOffsets(Map<TopicPartition, OffsetSpec> topicPartitionOffsets)	List the offsets available for a set of partitions.
Future<Set<String>>	KafkaAdminClient.listTopics()	List the topics available in the cluster with the default options.

Uses of Future in io.vertx.kafka.client.consumer

Methods in io.vertx.kafka.client.consumer that return Future

Modifier and Type	Method	Description
Future<Void>	KafkaConsumer.assign(TopicPartition topicPartition)	Manually assign a partition to this consumer.
Future<Void>	KafkaConsumer.assign(Set<TopicPartition> topicPartitions)	Manually assign a list of partition to this consumer.
Future<Void>	KafkaReadStream.assign(Set<org.apache.kafka.common.TopicPartition> partitions)	Manually assign a set of partitions to this consumer.
Future<Set<TopicPartition>>	KafkaConsumer.assignment()	Get the set of partitions currently assigned to this consumer.
Future<Set<org.apache.kafka.common.TopicPartition>>	KafkaReadStream.assignment()	Get the set of partitions currently assigned to this consumer.
Future<Long>	KafkaConsumer.beginningOffsets(TopicPartition topicPartition)	Get the first offset for the given partitions.
Future<Map<TopicPartition, Long>>	KafkaConsumer.beginningOffsets(Set<TopicPartition> topicPartitions)	Get the first offset for the given partitions.
Future<Map<org.apache.kafka.common.TopicPartition, Long>>	KafkaReadStream.beginningOffsets(Set<org.apache.kafka.common.TopicPartition> topicPartitions)	Get the first offset for the given partitions.
Future<Long>	KafkaReadStream.beginningOffsets(org.apache.kafka.common.TopicPartition topicPartition)	Get the first offset for the given partition.
Future<Void>	KafkaConsumer.close()	Close the consumer
Future<Void>	KafkaReadStream.close()	Close the stream
Future<Void>	KafkaConsumer.commit()	Commit current offsets for all the subscribed list of topics and partition.
Future<Map<TopicPartition, OffsetAndMetadata>>	KafkaConsumer.commit(Map<TopicPartition, OffsetAndMetadata> offsets)	Commit the specified offsets for the specified list of topics and partitions to Kafka.
Future<Map<org.apache.kafka.common.TopicPartition, org.apache.kafka.clients.consumer.OffsetAndMetadata>>	KafkaReadStream.commit()	Commit current offsets for all the subscribed list of topics and partition.
Future<Map<org.apache.kafka.common.TopicPartition, org.apache.kafka.clients.consumer.OffsetAndMetadata>>	KafkaReadStream.commit(Map<org.apache.kafka.common.TopicPartition, org.apache.kafka.clients.consumer.OffsetAndMetadata> offsets)	Commit the specified offsets for the specified list of topics and partitions to Kafka.
Future<OffsetAndMetadata>	KafkaConsumer.committed(TopicPartition topicPartition)	Get the last committed offset for the given partition (whether the commit happened by this process or another).
Future<org.apache.kafka.clients.consumer.OffsetAndMetadata>	KafkaReadStream.committed(org.apache.kafka.common.TopicPartition topicPartition)	Get the last committed offset for the given partition (whether the commit happened by this process or another).
Future<Long>	KafkaConsumer.endOffsets(TopicPartition topicPartition)	Get the last offset for the given partition.
Future<Map<TopicPartition, Long>>	KafkaConsumer.endOffsets(Set<TopicPartition> topicPartitions)	Get the last offset for the given partitions.
Future<Map<org.apache.kafka.common.TopicPartition, Long>>	KafkaReadStream.endOffsets(Set<org.apache.kafka.common.TopicPartition> topicPartitions)	Get the last offset for the given partitions.
Future<Long>	KafkaReadStream.endOffsets(org.apache.kafka.common.TopicPartition topicPartition)	Get the last offset for the given partition.
Future<Map<String, List<PartitionInfo>>>	KafkaConsumer.listTopics()	Get metadata about partitions for all topics that the user is authorized to view.
Future<Map<String, List<org.apache.kafka.common.PartitionInfo>>>	KafkaReadStream.listTopics()	Get metadata about partitions for all topics that the user is authorized to view.
Future<OffsetAndTimestamp>	KafkaConsumer.offsetsForTimes(TopicPartition topicPartition, Long timestamp)	Look up the offset for the given partition by timestamp.
Future<Map<TopicPartition, OffsetAndTimestamp>>	KafkaConsumer.offsetsForTimes(Map<TopicPartition, Long> topicPartitionTimestamps)	Look up the offsets for the given partitions by timestamp.
Future<Map<org.apache.kafka.common.TopicPartition, org.apache.kafka.clients.consumer.OffsetAndTimestamp>>	KafkaReadStream.offsetsForTimes(Map<org.apache.kafka.common.TopicPartition, Long> topicPartitionTimestamps)	Look up the offsets for the given partitions by timestamp.
Future<org.apache.kafka.clients.consumer.OffsetAndTimestamp>	KafkaReadStream.offsetsForTimes(org.apache.kafka.common.TopicPartition topicPartition, long timestamp)	* Look up the offset for the given partition by timestamp.
Future<List<PartitionInfo>>	KafkaConsumer.partitionsFor(String topic)	Get metadata about the partitions for a given topic.
Future<List<org.apache.kafka.common.PartitionInfo>>	KafkaReadStream.partitionsFor(String topic)	Get metadata about the partitions for a given topic.
Future<Void>	KafkaConsumer.pause(TopicPartition topicPartition)	Suspend fetching from the requested partition.
Future<Void>	KafkaConsumer.pause(Set<TopicPartition> topicPartitions)	Suspend fetching from the requested partitions.
Future<Void>	KafkaReadStream.pause(Set<org.apache.kafka.common.TopicPartition> topicPartitions)	Suspend fetching from the requested partitions.
Future<Set<TopicPartition>>	KafkaConsumer.paused()	Get the set of partitions that were previously paused by a call to pause(Set).
Future<Set<org.apache.kafka.common.TopicPartition>>	KafkaReadStream.paused()	Get the set of partitions that were previously paused by a call to KafkaReadStream.pause(Set).
Future<KafkaConsumerRecords<K,V>>	KafkaConsumer.poll(Duration timeout)	Executes a poll for getting messages from Kafka.
Future<org.apache.kafka.clients.consumer.ConsumerRecords<K,V>>	KafkaReadStream.poll(Duration timeout)	Executes a poll for getting messages from Kafka.
Future<Long>	KafkaConsumer.position(TopicPartition partition)	Get the offset of the next record that will be fetched (if a record with that offset exists).
Future<Long>	KafkaReadStream.position(org.apache.kafka.common.TopicPartition partition)	Get the offset of the next record that will be fetched (if a record with that offset exists).
Future<Void>	KafkaConsumer.resume(TopicPartition topicPartition)	Resume specified partition which have been paused with pause.
Future<Void>	KafkaConsumer.resume(Set<TopicPartition> topicPartitions)	Resume specified partitions which have been paused with pause.
Future<Void>	KafkaReadStream.resume(Set<org.apache.kafka.common.TopicPartition> topicPartitions)	Resume specified partitions which have been paused with pause.
Future<Void>	KafkaConsumer.seek(TopicPartition topicPartition, long offset)	Overrides the fetch offsets that the consumer will use on the next poll.
Future<Void>	KafkaConsumer.seek(TopicPartition topicPartition, OffsetAndMetadata offsetAndMetadata)	Overrides the fetch offsets that the consumer will use on the next poll.
Future<Void>	KafkaReadStream.seek(org.apache.kafka.common.TopicPartition topicPartition, long offset)	Overrides the fetch offsets that the consumer will use on the next poll.
Future<Void>	KafkaReadStream.seek(org.apache.kafka.common.TopicPartition topicPartition, org.apache.kafka.clients.consumer.OffsetAndMetadata offsetAndMetadata)	Overrides the fetch offsets that the consumer will use on the next poll.
Future<Void>	KafkaConsumer.seekToBeginning(TopicPartition topicPartition)	Seek to the first offset for each of the given partition.
Future<Void>	KafkaConsumer.seekToBeginning(Set<TopicPartition> topicPartitions)	Seek to the first offset for each of the given partitions.
Future<Void>	KafkaReadStream.seekToBeginning(Set<org.apache.kafka.common.TopicPartition> topicPartitions)	Seek to the first offset for each of the given partitions.
Future<Void>	KafkaConsumer.seekToEnd(TopicPartition topicPartition)	Seek to the last offset for each of the given partition.
Future<Void>	KafkaConsumer.seekToEnd(Set<TopicPartition> topicPartitions)	Seek to the last offset for each of the given partitions.
Future<Void>	KafkaReadStream.seekToEnd(Set<org.apache.kafka.common.TopicPartition> topicPartitions)	Seek to the last offset for each of the given partitions.
Future<Void>	KafkaConsumer.subscribe(String topic)	Subscribe to the given topic to get dynamically assigned partitions.
Future<Void>	KafkaConsumer.subscribe(Pattern pattern)	Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
Future<Void>	KafkaConsumer.subscribe(Set<String> topics)	Subscribe to the given list of topics to get dynamically assigned partitions.
Future<Void>	KafkaReadStream.subscribe(Pattern pattern)	Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
Future<Void>	KafkaReadStream.subscribe(Set<String> topics)	Subscribe to the given list of topics to get dynamically assigned partitions.
Future<Set<String>>	KafkaConsumer.subscription()	Get the current subscription.
Future<Set<String>>	KafkaReadStream.subscription()	Get the current subscription.
Future<Void>	KafkaConsumer.unsubscribe()	Unsubscribe from topics currently subscribed with subscribe.
Future<Void>	KafkaReadStream.unsubscribe()	Unsubscribe from topics currently subscribed with subscribe.

Uses of Future in io.vertx.kafka.client.producer

Methods in io.vertx.kafka.client.producer that return Future

Modifier and Type	Method	Description
Future<Void>	KafkaProducer.abortTransaction()	Aborts the ongoing transaction.
Future<Void>	KafkaWriteStream.abortTransaction()	Aborts the ongoing transaction.
Future<Void>	KafkaProducer.beginTransaction()	Starts a new kafka transaction.
Future<Void>	KafkaWriteStream.beginTransaction()	Starts a new kafka transaction.
Future<Void>	KafkaProducer.close()	Close the producer
Future<Void>	KafkaProducer.close(long timeout)	Close the producer
Future<Void>	KafkaWriteStream.close()	Close the stream
Future<Void>	KafkaWriteStream.close(long timeout)	Close the stream
Future<Void>	KafkaProducer.commitTransaction()	Commits the ongoing transaction.
Future<Void>	KafkaWriteStream.commitTransaction()	Commits the ongoing transaction.
Future<Void>	KafkaProducer.flush()	Invoking this method makes all buffered records immediately available to write
Future<Void>	KafkaWriteStream.flush()	Invoking this method makes all buffered records immediately available to write
Future<Void>	KafkaProducer.initTransactions()	Initializes the underlying kafka transactional producer.
Future<Void>	KafkaWriteStream.initTransactions()	Initializes the underlying kafka transactional producer.
Future<List<PartitionInfo>>	KafkaProducer.partitionsFor(String topic)	Get the partition metadata for the give topic.
Future<List<org.apache.kafka.common.PartitionInfo>>	KafkaWriteStream.partitionsFor(String topic)	Get the partition metadata for the give topic.
Future<RecordMetadata>	KafkaProducer.send(KafkaProducerRecord<K,V> record)	Asynchronously write a record to a topic
Future<org.apache.kafka.clients.producer.RecordMetadata>	KafkaWriteStream.send(org.apache.kafka.clients.producer.ProducerRecord<K,V> record)	Asynchronously write a record to a topic

Uses of Future in io.vertx.mqtt

Methods in io.vertx.mqtt that return Future

Modifier and Type	Method	Description
Future<Void>	MqttClient.authenticationExchange(MqttAuthenticationExchangeMessage message)	It is used for Enhanced Authentication and is able to carry an authentication method and authentication data.
Future<Void>	MqttServer.close()	Close the server.
Future<MqttConnAckMessage>	MqttClient.connect(int port, String host)	Connects to an MQTT server calling connectHandler after connection
Future<MqttConnAckMessage>	MqttClient.connect(int port, String host, String serverName)	Connects to an MQTT server calling connectHandler after connection
Future<Void>	MqttClient.disconnect()	Disconnects from the MQTT server
Future<MqttServer>	MqttServer.listen()	Start the server listening for incoming connections using the specified options through the constructor
Future<MqttServer>	MqttServer.listen(int port)	Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
Future<MqttServer>	MqttServer.listen(int port, String host)	Start the server listening for incoming connections on the port and host specified
Future<Integer>	MqttClient.publish(int id, String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain)	Sends the PUBLISH message to the remote MQTT server
Future<Integer>	MqttClient.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain)	Sends the PUBLISH message to the remote MQTT server
Future<Integer>	MqttEndpoint.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain)	Sends the PUBLISH message to the remote MQTT client
Future<Integer>	MqttEndpoint.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId)	Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
Future<Integer>	MqttEndpoint.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, MqttProperties properties)	Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
Future<Void>	MqttClient.publishRelease(int publishMessageId)	Sends the PUBREL message to the remote MQTT server.
Future<Integer>	MqttClient.subscribe(String topic, int qos)	Subscribes to the topic with a specified QoS level
Future<Integer>	MqttClient.subscribe(Map<String,Integer> topics)	Subscribes to the topics with related QoS levels
Future<Integer>	MqttClient.unsubscribe(String topic)	Unsubscribe from receiving messages on given topic
Future<Integer>	MqttClient.unsubscribe(List<String> topics)	Unsubscribe from receiving messages on given list of topic

Uses of Future in io.vertx.mssqlclient

Methods in io.vertx.mssqlclient that return Future

Modifier and Type	Method	Description
static Future<MSSQLConnection>	MSSQLConnection.connect(Vertx vertx, MSSQLConnectOptions connectOptions)	Create a connection to SQL Server with the given connectOptions.
static Future<MSSQLConnection>	MSSQLConnection.connect(Vertx vertx, String connectionUri)	Like MSSQLConnection.connect(Vertx, MSSQLConnectOptions) with options built from connectionUri.

Uses of Future in io.vertx.mysqlclient

Methods in io.vertx.mysqlclient that return Future

Modifier and Type	Method	Description
Future<Void>	MySQLConnection.changeUser(MySQLAuthOptions options)	Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
static Future<MySQLConnection>	MySQLConnection.connect(Vertx vertx, MySQLConnectOptions connectOptions)	Create a connection to MySQL server with the given connectOptions.
static Future<MySQLConnection>	MySQLConnection.connect(Vertx vertx, String connectionUri)	Like MySQLConnection.connect(Vertx, MySQLConnectOptions) with options built from connectionUri.
Future<Void>	MySQLConnection.debug()	Send a DEBUG command to dump debug information to the server's stdout.
Future<String>	MySQLConnection.getInternalStatistics()	Send a STATISTICS command to get a human readable string of the server internal status.
Future<Void>	MySQLConnection.ping()	Send a PING command to check if the server is alive.
Future<Void>	MySQLConnection.resetConnection()	Send a RESET_CONNECTION command to reset the session state.
Future<Void>	MySQLConnection.setOption(MySQLSetOption option)	Send a SET_OPTION command to set options for the current connection.
Future<Void>	MySQLConnection.specifySchema(String schemaName)	Send a INIT_DB command to change the default schema of the connection.

Uses of Future in io.vertx.mysqlclient.spi

Method parameters in io.vertx.mysqlclient.spi with type arguments of type Future

Modifier and Type	Method	Description
protected Pool	MySQLDriver.newPool(io.vertx.core.internal.VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<MySQLConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, io.vertx.core.internal.CloseFuture closeFuture)

Uses of Future in io.vertx.openapi.contract

Methods in io.vertx.openapi.contract that return Future

Modifier and Type	Method	Description
Future<OpenAPIContract>	OpenAPIContractBuilder.build()	Builds the contract.
static Future<OpenAPIContract>	OpenAPIContract.from(Vertx vertx, JsonObject contract)	Resolves / dereferences the passed contract and creates an OpenAPIContract instance.
static Future<OpenAPIContract>	OpenAPIContract.from(Vertx vertx, JsonObject contract, Map<String, JsonObject> additionalContractParts)	Resolves / dereferences the passed contract and creates an OpenAPIContract instance.
static Future<OpenAPIContract>	OpenAPIContract.from(Vertx vertx, String contractPath)	Resolves / dereferences the passed contract and creates an OpenAPIContract instance.
static Future<OpenAPIContract>	OpenAPIContract.from(Vertx vertx, String contractPath, Map<String,String> additionalContractPartPaths)	Resolves / dereferences the passed contract and creates an OpenAPIContract instance.
Future<SchemaRepository>	OpenAPIVersion.getRepository(Vertx vertx, String baseUri)
Future<JsonObject>	OpenAPIVersion.resolve(Vertx vertx, SchemaRepository repo, JsonObject contract)
Future<Void>	OpenAPIVersion.validateAdditionalContractFile(Vertx vertx, SchemaRepository repo, JsonObject file)	Deprecated.
Future<Void>	OpenAPIVersion.validateAdditionalContractPart(Vertx vertx, SchemaRepository repo, JsonObject part)	Validates an additional contract against the openapi schema.
Future<OutputUnit>	OpenAPIVersion.validateContract(Vertx vertx, SchemaRepository repo, JsonObject contract)

Uses of Future in io.vertx.openapi.validation

Methods in io.vertx.openapi.validation that return Future

Modifier and Type	Method	Description
static Future<ValidatableRequest>	RequestUtils.extract(HttpServerRequest request, Operation operation)	Extracts and transforms the parameters and the body of an incoming request into a format that can be validated by the RequestValidator.
static Future<ValidatableRequest>	RequestUtils.extract(HttpServerRequest request, Operation operation, Supplier<Future<Buffer>> bodySupplier)	Like RequestUtils.extract(HttpServerRequest, Operation), but offers to pass a supplier fpr the body.
static Future<ValidatableRequest>	ValidatableRequest.of(HttpServerRequest request, Operation operation)	Creates a new ValidatableRequest object based on the passed request and operation.
Future<Void>	ValidatedResponse.send(HttpServerResponse serverResponse)	Add all parameters from the validated response to the passed HttpServerResponse and send it.
Future<ValidatedRequest>	RequestValidator.validate(HttpServerRequest request)	Like RequestValidator.validate(ValidatableRequest, String), but the operationId and ValidatableRequest are determined from the passed request.
Future<ValidatedRequest>	RequestValidator.validate(HttpServerRequest request, String operationId)	Like RequestValidator.validate(ValidatableRequest, String), but ValidatableRequest are directly extracted from the passed request.
Future<ValidatedRequest>	RequestValidator.validate(ValidatableRequest params, String operationId)	Validates the passed request parameters against the operation defined in the related OpenAPI contract.
Future<ValidatedResponse>	ResponseValidator.validate(ValidatableResponse params, String operationId)	Validates the passed response parameters against the operation defined in the related OpenAPI contract.

Method parameters in io.vertx.openapi.validation with type arguments of type Future

Modifier and Type	Method	Description
static Future<ValidatableRequest>	RequestUtils.extract(HttpServerRequest request, Operation operation, Supplier<Future<Buffer>> bodySupplier)	Like RequestUtils.extract(HttpServerRequest, Operation), but offers to pass a supplier fpr the body.

Uses of Future in io.vertx.oracleclient

Methods in io.vertx.oracleclient that return Future

Modifier and Type	Method	Description
static Future<OracleConnection>	OracleConnection.connect(Vertx vertx, OracleConnectOptions connectOptions)	Create a connection to Oracle with the given connectOptions.
static Future<OracleConnection>	OracleConnection.connect(Vertx vertx, String connectionUri)	Like OracleConnection.connect(Vertx, OracleConnectOptions) with options built from connectionUri.

Uses of Future in io.vertx.pgclient

Methods in io.vertx.pgclient that return Future

Modifier and Type	Method	Description
Future<Void>	PgConnection.cancelRequest()	Send a request cancellation message to tell the server to cancel processing request in this connection.
static Future<PgConnection>	PgConnection.connect(Vertx vertx)	Like PgConnection.connect(Vertx, PgConnectOptions) with options build from the environment variables.
static Future<PgConnection>	PgConnection.connect(Vertx vertx, PgConnectOptions options)	Connects to the database and returns the connection if that succeeds.
static Future<PgConnection>	PgConnection.connect(Vertx vertx, String connectionUri)	Like PgConnection.connect(Vertx, PgConnectOptions) with options build from connectionUri.

Uses of Future in io.vertx.pgclient.pubsub

Methods in io.vertx.pgclient.pubsub that return Future

Modifier and Type	Method	Description
Future<Void>	PgSubscriber.close()	Close the subscriber, the retry policy will not be invoked.
Future<Void>	PgSubscriber.connect()	Connect the subscriber to Postgres.

Uses of Future in io.vertx.pgclient.spi

Method parameters in io.vertx.pgclient.spi with type arguments of type Future

Modifier and Type	Method	Description
protected Pool	PgDriver.newPool(io.vertx.core.internal.VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<PgConnectOptions>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, io.vertx.core.internal.CloseFuture closeFuture)

Uses of Future in io.vertx.rabbitmq

Methods in io.vertx.rabbitmq that return Future

Modifier and Type	Method	Description
Future<ReadStream<RabbitMQConfirmation>>	RabbitMQClient.addConfirmListener(int maxQueueSize)	Add a Confirm Listener to the channel.
Future<Void>	RabbitMQClient.basicAck(long deliveryTag, boolean multiple)	Acknowledge one or several received messages.
default Future<RabbitMQConsumer>	RabbitMQClient.basicConsumer(String queue)
Future<RabbitMQConsumer>	RabbitMQClient.basicConsumer(String queue, QueueOptions options)	Create a consumer with the given options.
Future<RabbitMQMessage>	RabbitMQClient.basicGet(String queue, boolean autoAck)	Retrieve a message from a queue using AMQP.Basic.Get
Future<Void>	RabbitMQClient.basicNack(long deliveryTag, boolean multiple, boolean requeue)	Reject one or several received messages.
Future<Void>	RabbitMQClient.basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)	Publish a message.
Future<Void>	RabbitMQClient.basicPublish(String exchange, String routingKey, Buffer body)	Publish a message.
Future<Void>	RabbitMQClient.basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)	Publish a message.
default Future<Void>	RabbitMQClient.basicQos(int prefetchCount)	Request a specific prefetchCount "quality of service" settings for this channel.
default Future<Void>	RabbitMQClient.basicQos(int prefetchCount, boolean global)	Request a specific prefetchCount "quality of service" settings for this channel.
Future<Void>	RabbitMQClient.basicQos(int prefetchSize, int prefetchCount, boolean global)	Request specific "quality of service" settings.
Future<Void>	RabbitMQConsumer.cancel()	Stop message consumption from a queue.
Future<Void>	RabbitMQClient.confirmSelect()	Enables publisher acknowledgements on this channel.
Future<Void>	RabbitMQClient.exchangeBind(String destination, String source, String routingKey)	Bind an exchange to an exchange.
Future<Void>	RabbitMQClient.exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments)	Bind an exchange to an exchange.
Future<Void>	RabbitMQClient.exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete)	Declare an exchange.
Future<Void>	RabbitMQClient.exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config)	Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
Future<Void>	RabbitMQClient.exchangeDelete(String exchange)	Delete an exchange, without regard for whether it is in use or not.
Future<Void>	RabbitMQClient.exchangeUnbind(String destination, String source, String routingKey)	Unbind an exchange from an exchange.
Future<Void>	RabbitMQClient.exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments)	Unbind an exchange from an exchange.
Future<Long>	RabbitMQClient.messageCount(String queue)	Returns the number of messages in a queue ready to be delivered.
Future<Void>	RabbitMQPublisher.publish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)	Publish a message.
Future<Long>	RabbitMQPublisher.publishConfirm(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)	Publish a message and complete when publish confirm has returned.
Future<Void>	RabbitMQClient.queueBind(String queue, String exchange, String routingKey)	Bind a queue to an exchange
Future<Void>	RabbitMQClient.queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments)	Bind a queue to an exchange
Future<com.rabbitmq.client.AMQP.Queue.DeclareOk>	RabbitMQClient.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete)	Declare a queue
Future<com.rabbitmq.client.AMQP.Queue.DeclareOk>	RabbitMQClient.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config)	Declare a queue with config options
Future<JsonObject>	RabbitMQClient.queueDeclareAuto()	Actively declare a server-named exclusive, autodelete, non-durable queue.
Future<com.rabbitmq.client.AMQP.Queue.DeleteOk>	RabbitMQClient.queueDelete(String queue)	Delete a queue, without regard for whether it is in use or has messages on it
Future<com.rabbitmq.client.AMQP.Queue.DeleteOk>	RabbitMQClient.queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty)	Delete a queue
Future<Void>	RabbitMQClient.queueUnbind(String queue, String exchange, String routingKey)	Unbind a queue from an exchange
Future<Void>	RabbitMQClient.queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments)	Unbind a queue from an exchange
Future<Void>	RabbitMQClient.restartConnect(int attempts)	restart the rabbitMQ connect.
Future<Void>	RabbitMQClient.start()	Start the rabbitMQ client.
Future<Void>	RabbitMQPublisher.start()	Start the rabbitMQ publisher.
Future<Void>	RabbitMQClient.stop()	Stop the rabbitMQ client.
Future<Void>	RabbitMQPublisher.stop()	Stop the rabbitMQ publisher.
Future<Void>	RabbitMQClient.waitForConfirms()	Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
Future<Void>	RabbitMQClient.waitForConfirms(long timeout)	Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

Uses of Future in io.vertx.reactivex

Methods in io.vertx.reactivex that return Future

Modifier and Type	Method	Description
static <T> Future<Void>	CompletableHelper.toFuture(Completable maybe)	Adapts an RxJava2 Completable<T> to a Vert.x .
static <T> Future<T>	MaybeHelper.toFuture(Maybe<T> maybe)	Adapts an RxJava2 Maybe<T> to a Vert.x Future<T>.
static <T,U> Future<U>	MaybeHelper.toFuture(Maybe<T> maybe, Function<T,U> adapter)	Like MaybeHelper.toFuture(Maybe) but with an adapter of the result.
static <T> Future<T>	SingleHelper.toFuture(Single<T> single)	Adapts an RxJava2 Single<T> to a Vert.x Future<T>.
static <T,U> Future<U>	SingleHelper.toFuture(Single<T> single, Function<T,U> adapter)	Like SingleHelper.toFuture(Single) but with an adapter of the result.

Uses of Future in io.vertx.reactivex.amqp

Methods in io.vertx.reactivex.amqp that return Future

Modifier and Type	Method	Description
Future<Void>	AmqpClient.close()	Closes the client.
Future<Void>	AmqpConnection.close()	Closes the AMQP connection, i.e. allows the Close frame to be emitted.
Future<Void>	AmqpReceiver.close()	Closes the receiver.
Future<Void>	AmqpSender.close()	Closes the sender.
Future<Void>	AmqpConnection.closeFuture()
Future<AmqpConnection>	AmqpClient.connect()	Connects to the AMQP broker or router.
Future<AmqpSender>	AmqpConnection.createAnonymousSender()	Creates an anonymous sender.
Future<AmqpReceiver>	AmqpConnection.createDynamicReceiver()	Creates a dynamic receiver.
Future<AmqpReceiver>	AmqpClient.createReceiver(String address)	Creates a receiver used to consume messages from the given address.
Future<AmqpReceiver>	AmqpClient.createReceiver(String address, AmqpReceiverOptions receiverOptions)	Creates a receiver used to consumer messages from the given address.
Future<AmqpReceiver>	AmqpConnection.createReceiver(String address)	Creates a receiver used to consume messages from the given address.
Future<AmqpReceiver>	AmqpConnection.createReceiver(String address, AmqpReceiverOptions receiverOptions)	Creates a receiver used to consumer messages from the given address.
Future<AmqpSender>	AmqpClient.createSender(String address)	Creates a sender used to send messages to the given address.
Future<AmqpSender>	AmqpClient.createSender(String address, AmqpSenderOptions options)	Creates a sender used to send messages to the given address.
Future<AmqpSender>	AmqpConnection.createSender(String address)	Creates a sender used to send messages to the given address.
Future<AmqpSender>	AmqpConnection.createSender(String address, AmqpSenderOptions options)	Creates a sender used to send messages to the given address.
Future<Void>	AmqpSender.end()	Ends the stream.
Future<Void>	AmqpSender.end(AmqpMessage data)	Same as WriteStream.end() but writes some data to the stream before ending.
Future<Void>	AmqpReceiver.pipeTo(WriteStream<AmqpMessage> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	AmqpSender.sendWithAck(AmqpMessage message)	Sends an AMQP message and waits for an acknowledgement.
Future<Void>	AmqpSender.write(AmqpMessage data)	Write some data to the stream.

Uses of Future in io.vertx.reactivex.cassandra

Methods in io.vertx.reactivex.cassandra that return Future

Modifier and Type	Method	Description
Future<List<com.datastax.oss.driver.api.core.cql.Row>>	ResultSet.all()	The method should not be used concurrently with others like ResultSet.fetchNextPage() or ResultSet.one().
Future<Void>	CassandraClient.close()	Closes this client.
Future<ResultSet>	CassandraClient.execute(com.datastax.oss.driver.api.core.cql.Statement statement)	Execute the statement and provide a handler for consuming results.
Future<ResultSet>	CassandraClient.execute(String query)	Execute the query and provide a handler for consuming results.
Future<List<com.datastax.oss.driver.api.core.cql.Row>>	CassandraClient.executeWithFullFetch(com.datastax.oss.driver.api.core.cql.Statement statement)	Execute the query and provide a handler for consuming results.
Future<List<com.datastax.oss.driver.api.core.cql.Row>>	CassandraClient.executeWithFullFetch(String query)	Execute the query and provide a handler for consuming results.
Future<ResultSet>	ResultSet.fetchNextPage()
Future<com.datastax.oss.driver.api.core.metadata.Metadata>	CassandraClient.metadata()	Get for the session.
Future<Void>	CassandraRowStream.pipeTo(WriteStream<com.datastax.oss.driver.api.core.cql.Row> dst)
Future<com.datastax.oss.driver.api.core.cql.PreparedStatement>	CassandraClient.prepare(com.datastax.oss.driver.api.core.cql.SimpleStatement statement)	Prepares the provided a .
Future<com.datastax.oss.driver.api.core.cql.PreparedStatement>	CassandraClient.prepare(String query)	Prepares the provided query string.
Future<CassandraRowStream>	CassandraClient.queryStream(com.datastax.oss.driver.api.core.cql.Statement statement)	Executes the given SQL statement which returns the results of the query as a read stream.
Future<CassandraRowStream>	CassandraClient.queryStream(String sql)	Executes the given SQL SELECT statement which returns the results of the query as a read stream.

Uses of Future in io.vertx.reactivex.circuitbreaker

Methods in io.vertx.reactivex.circuitbreaker that return Future

Modifier and Type	Method	Description
<T> Future<T>	CircuitBreaker.execute(Handler<Promise<T>> command)	Same as CircuitBreaker.executeWithFallback(Handler, Function) but using the circuit breaker .
<T> Future<T>	CircuitBreaker.execute(Supplier<Future<T>> command)	Same as CircuitBreaker.executeWithFallback(Handler, Function) but using the circuit breaker .
<T> Future<T>	CircuitBreaker.executeWithFallback(Handler<Promise<T>> command, Function<Throwable, T> fallback)	Executes the given operation with the circuit breaker control.
<T> Future<T>	CircuitBreaker.executeWithFallback(Supplier<Future<T>> command, Function<Throwable, T> fallback)	Executes the given operation with the circuit breaker control.

Methods in io.vertx.reactivex.circuitbreaker with parameters of type Future

Modifier and Type	Method	Description
boolean	FailurePolicy.test(Future<T> future)	Invoked by the CircuitBreaker when an operation completes.

Method parameters in io.vertx.reactivex.circuitbreaker with type arguments of type Future

Modifier and Type	Method	Description
<T> Future<T>	CircuitBreaker.execute(Supplier<Future<T>> command)	Same as CircuitBreaker.executeWithFallback(Handler, Function) but using the circuit breaker .
<T> Future<T>	CircuitBreaker.executeWithFallback(Supplier<Future<T>> command, Function<Throwable, T> fallback)	Executes the given operation with the circuit breaker control.
<T> Single<T>	CircuitBreaker.rxExecute(Supplier<Future<T>> command)	Same as CircuitBreaker.executeWithFallback(Handler, Function) but using the circuit breaker .
<T> Single<T>	CircuitBreaker.rxExecuteWithFallback(Supplier<Future<T>> command, Function<Throwable, T> fallback)	Executes the given operation with the circuit breaker control.

Uses of Future in io.vertx.reactivex.config

Methods in io.vertx.reactivex.config that return Future

Modifier and Type	Method	Description
Future<Void>	ConfigRetriever.close()	Closes the retriever.
Future<JsonObject>	ConfigRetriever.getConfig()	Reads the configuration from the different and computes the final configuration.

Uses of Future in io.vertx.reactivex.core

Methods in io.vertx.reactivex.core that return Future

Modifier and Type	Method	Description
Future<Vertx>	VertxBuilder.buildClustered()	Creates a clustered instance.
Future<Void>	Vertx.close()	Stop the Vertx instance and release any resources held by it.
Future<Void>	WorkerExecutor.close()	Close the executor.
static Future<Vertx>	Vertx.clusteredVertx(VertxOptions options)	Creates a clustered instance using the specified options.
Future<String>	Vertx.deployVerticle(Deployable verticle)	Deploy a verticle instance that you have created yourself.
Future<String>	Vertx.deployVerticle(Deployable verticle, DeploymentOptions options)	Like Vertx.deployVerticle(String) but DeploymentOptions are provided to configure the deployment.
Future<String>	Vertx.deployVerticle(String name)	Deploy a verticle instance given a name.
Future<String>	Vertx.deployVerticle(String name, DeploymentOptions options)	Like Vertx.deployVerticle(String) but DeploymentOptions are provided to configure the deployment.
Future<String>	Vertx.deployVerticle(Supplier<? extends Deployable> supplier, DeploymentOptions options)	Like Vertx.deployVerticle(String) but Deployable instance is created by invoking the verticleSupplier.
<T> Future<T>	Context.executeBlocking(Callable<T> blockingCodeHandler)	Invoke Context.executeBlocking(Callable, boolean) with order = true.
<T> Future<T>	Context.executeBlocking(Callable<T> blockingCodeHandler, boolean ordered)	Safely execute some blocking code.
<T> Future<T>	Vertx.executeBlocking(Callable<T> blockingCodeHandler)	Like Vertx.executeBlocking(Callable, boolean) called with ordered = true.
<T> Future<T>	Vertx.executeBlocking(Callable<T> blockingCodeHandler, boolean ordered)	Safely execute some blocking code.
<T> Future<T>	WorkerExecutor.executeBlocking(Callable<T> blockingCodeHandler)	Like WorkerExecutor.executeBlocking(Callable, boolean) called with ordered = true.
<T> Future<T>	WorkerExecutor.executeBlocking(Callable<T> blockingCodeHandler, boolean ordered)	Safely execute some blocking code.
Future<T>	Promise.future()
Future<Void>	Vertx.undeploy(String deploymentID)	Undeploy a verticle deployment.

Uses of Future in io.vertx.reactivex.core.datagram

Methods in io.vertx.reactivex.core.datagram that return Future

Modifier and Type	Method	Description
Future<Void>	DatagramSocket.blockMulticastGroup(String multicastAddress, String sourceToBlock)	Block the given address for the given multicast address and notifies the once the operation completes.
Future<Void>	DatagramSocket.blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock)	Block the given address for the given multicast address on the given network interface and notifies the once the operation completes.
Future<Void>	DatagramSocket.close()	Closes the DatagramSocket implementation asynchronous and notifies the handler once done.
Future<DatagramSocket>	DatagramSocket.listen(int port, String host)	Start listening on the given port and host.
Future<Void>	DatagramSocket.listenMulticastGroup(String multicastAddress)	Joins a multicast group and listens for packets send to it.
Future<Void>	DatagramSocket.listenMulticastGroup(String multicastAddress, String networkInterface, String source)	Joins a multicast group and listens for packets send to it on the given network interface.
Future<Void>	DatagramSocket.send(Buffer packet, int port, String host)	Write the given Buffer to the SocketAddress.
Future<Void>	DatagramSocket.send(String str, int port, String host)	Write the given String to the SocketAddress using UTF8 encoding.
Future<Void>	DatagramSocket.send(String str, String enc, int port, String host)	Write the given String to the SocketAddress using the given encoding.
Future<Void>	DatagramSocket.unlistenMulticastGroup(String multicastAddress)	Leaves a multicast group and stops listening for packets send to it.
Future<Void>	DatagramSocket.unlistenMulticastGroup(String multicastAddress, String networkInterface, String source)	Leaves a multicast group and stops listening for packets send to it on the given network interface.

Uses of Future in io.vertx.reactivex.core.dns

Methods in io.vertx.reactivex.core.dns that return Future

Modifier and Type	Method	Description
Future<Void>	DnsClient.close()	Close the client.
Future<String>	DnsClient.lookup(String name)	Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
Future<String>	DnsClient.lookup4(String name)	Try to lookup the A (ipv4) record for the given name.
Future<String>	DnsClient.lookup6(String name)	Try to lookup the AAAA (ipv6) record for the given name.
Future<List<String>>	DnsClient.resolveA(String name)	Try to resolve all A (ipv4) records for the given name.
Future<List<String>>	DnsClient.resolveAAAA(String name)	Try to resolve all AAAA (ipv6) records for the given name.
Future<List<String>>	DnsClient.resolveCNAME(String name)	Try to resolve the CNAME record for the given name.
Future<List<MxRecord>>	DnsClient.resolveMX(String name)	Try to resolve the MX records for the given name.
Future<List<String>>	DnsClient.resolveNS(String name)	Try to resolve the NS records for the given name.
Future<String>	DnsClient.resolvePTR(String name)	Try to resolve the PTR record for the given name.
Future<List<SrvRecord>>	DnsClient.resolveSRV(String name)	Try to resolve the SRV records for the given name.
Future<List<String>>	DnsClient.resolveTXT(String name)	Try to resolve the TXT records for the given name.
Future<String>	DnsClient.reverseLookup(String ipaddress)	Try to do a reverse lookup of an IP address.

Uses of Future in io.vertx.reactivex.core.eventbus

Methods in io.vertx.reactivex.core.eventbus that return Future

Modifier and Type	Method	Description
Future<Void>	MessageProducer.close()	Closes the producer, this method should be called when the message producer is not used anymore.
Future<Void>	MessageConsumer.completion()
Future<Void>	MessageConsumer.pipeTo(WriteStream<Message<T>> dst)	Pipe this ReadStream to the WriteStream.
<R> Future<Message<R>>	Message.replyAndRequest(Object message)	Reply to this message, specifying a replyHandler for the reply - i.e. to receive the reply to the reply.
<R> Future<Message<R>>	Message.replyAndRequest(Object message, DeliveryOptions options)	Like Message.replyAndRequest(Object) but specifying options that can be used to configure the delivery.
<T> Future<Message<T>>	EventBus.request(String address, Object message)	Sends a message and specify a replyHandler that will be called if the recipient subsequently replies to the message.
<T> Future<Message<T>>	EventBus.request(String address, Object message, DeliveryOptions options)	Like EventBus.request(String, Object) but specifying options that can be used to configure the delivery.
Future<Void>	MessageConsumer.unregister()	Unregisters the handler which created this registration
Future<Void>	MessageProducer.write(T body)	Write a message to the event-bus, either sending or publishing.

Uses of Future in io.vertx.reactivex.core.file

Methods in io.vertx.reactivex.core.file that return Future

Modifier and Type	Method	Description
Future<Void>	FileSystem.chmod(String path, String perms)	Change the permissions on the file represented by path to perms, asynchronously.
Future<Void>	FileSystem.chmodRecursive(String path, String perms, String dirPerms)	Change the permissions on the file represented by path to perms, asynchronously.
Future<Void>	FileSystem.chown(String path, String user, String group)	Change the ownership on the file represented by path to user and {code group}, asynchronously.
Future<Void>	AsyncFile.close()	Close the file.
Future<Void>	FileSystem.copy(String from, String to)	Copy a file from the path from to path to, asynchronously.
Future<Void>	FileSystem.copy(String from, String to, CopyOptions options)	Copy a file from the path from to path to, asynchronously.
Future<Void>	FileSystem.copyRecursive(String from, String to, boolean recursive)	Copy a file from the path from to path to, asynchronously.
Future<Void>	FileSystem.createFile(String path)	Creates an empty file with the specified path, asynchronously.
Future<Void>	FileSystem.createFile(String path, String perms)	Creates an empty file with the specified path and permissions perms, asynchronously.
Future<String>	FileSystem.createTempDirectory(String prefix)	Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
Future<String>	FileSystem.createTempDirectory(String prefix, String perms)	Creates a new directory in the default temporary-file directory, using the given prefix to generate its name, asynchronously.
Future<String>	FileSystem.createTempDirectory(String dir, String prefix, String perms)	Creates a new directory in the directory provided by the path path, using the given prefix to generate its name, asynchronously.
Future<String>	FileSystem.createTempFile(String prefix, String suffix)	Creates a new file in the default temporary-file directory, using the given prefix and suffix to generate its name, asynchronously.
Future<String>	FileSystem.createTempFile(String prefix, String suffix, String perms)	Creates a new file in the directory provided by the path dir, using the given prefix and suffix to generate its name, asynchronously.
Future<String>	FileSystem.createTempFile(String dir, String prefix, String suffix, String perms)	Creates a new file in the directory provided by the path dir, using the given prefix and suffix to generate its name, asynchronously.
Future<Void>	FileSystem.delete(String path)	Deletes the file represented by the specified path, asynchronously.
Future<Void>	FileSystem.deleteRecursive(String path)	Deletes the file represented by the specified path, asynchronously.
Future<Void>	AsyncFile.end()	Ends the stream.
Future<Void>	AsyncFile.end(Buffer data)	Same as WriteStream.end() but writes some data to the stream before ending.
Future<Boolean>	FileSystem.exists(String path)	Determines whether the file as specified by the path path exists, asynchronously.
Future<Void>	AsyncFile.flush()	Flush any writes made to this file to underlying persistent storage.
Future<FileSystemProps>	FileSystem.fsProps(String path)	Returns properties of the file-system being used by the specified path, asynchronously.
Future<Boolean>	AsyncFileLock.isValid()	A lock remains valid until it is released or the file corresponding AsyncFile is closed.
Future<Void>	FileSystem.link(String link, String existing)	Create a hard link on the file system from link to existing, asynchronously.
Future<AsyncFileLock>	AsyncFile.lock()	Acquire a non-shared lock on the entire file.
Future<AsyncFileLock>	AsyncFile.lock(long position, long size, boolean shared)	Acquire a lock on a portion of this file.
Future<FileProps>	FileSystem.lprops(String path)	Obtain properties for the link represented by path, asynchronously.
Future<Void>	FileSystem.mkdir(String path)	Create the directory represented by path, asynchronously.
Future<Void>	FileSystem.mkdir(String path, String perms)	Create the directory represented by path, asynchronously.
Future<Void>	FileSystem.mkdirs(String path)	Create the directory represented by path and any non existent parents, asynchronously.
Future<Void>	FileSystem.mkdirs(String path, String perms)	Create the directory represented by path and any non existent parents, asynchronously.
Future<Void>	FileSystem.move(String from, String to)	Move a file from the path from to path to, asynchronously.
Future<Void>	FileSystem.move(String from, String to, CopyOptions options)	Move a file from the path from to path to, asynchronously.
Future<AsyncFile>	FileSystem.open(String path, OpenOptions options)	Open the file represented by path, asynchronously.
Future<Void>	AsyncFile.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<FileProps>	FileSystem.props(String path)	Obtain properties for the file represented by path, asynchronously.
Future<Buffer>	AsyncFile.read(Buffer buffer, int offset, long position, int length)	Reads length bytes of data from the file at position position in the file, asynchronously.
Future<List<String>>	FileSystem.readDir(String path)	Read the contents of the directory specified by path, asynchronously.
Future<List<String>>	FileSystem.readDir(String path, String filter)	Read the contents of the directory specified by path, asynchronously.
Future<Buffer>	FileSystem.readFile(String path)	Reads the entire file as represented by the path path as a , asynchronously.
Future<String>	FileSystem.readSymlink(String link)	Returns the path representing the file that the symbolic link specified by link points to, asynchronously.
Future<Void>	AsyncFileLock.release()	Releases this lock;
Future<Long>	AsyncFile.size()
Future<Void>	FileSystem.symlink(String link, String existing)	Create a symbolic link on the file system from link to existing, asynchronously.
Future<Void>	FileSystem.truncate(String path, long len)	Truncate the file represented by path to length len in bytes, asynchronously.
Future<Void>	FileSystem.unlink(String link)	Unlinks the link on the file system represented by the path link, asynchronously.
<T> Future<T>	AsyncFile.withLock(long position, long size, boolean shared, Supplier<Future<T>> block)	Acquire a lock on a portion of this file.
<T> Future<T>	AsyncFile.withLock(Supplier<Future<T>> block)	Acquire a non-shared lock on the entire file.
Future<Void>	AsyncFile.write(Buffer data)	Write some data to the stream.
Future<Void>	AsyncFile.write(Buffer buffer, long position)	Write a Buffer to the file at position position in the file, asynchronously.
Future<Void>	FileSystem.writeFile(String path, Buffer data)	Creates the file, and writes the specified Buffer data to the file represented by the path path, asynchronously.

Method parameters in io.vertx.reactivex.core.file with type arguments of type Future

Modifier and Type	Method	Description
<T> Single<T>	AsyncFile.rxWithLock(long position, long size, boolean shared, Supplier<Future<T>> block)	Acquire a lock on a portion of this file.
<T> Single<T>	AsyncFile.rxWithLock(Supplier<Future<T>> block)	Acquire a non-shared lock on the entire file.
<T> Future<T>	AsyncFile.withLock(long position, long size, boolean shared, Supplier<Future<T>> block)	Acquire a lock on a portion of this file.
<T> Future<T>	AsyncFile.withLock(Supplier<Future<T>> block)	Acquire a non-shared lock on the entire file.

Uses of Future in io.vertx.reactivex.core.http

Methods in io.vertx.reactivex.core.http that return Future

Modifier and Type	Method	Description
Future<ServerWebSocket>	ServerWebSocketHandshake.accept()	Accept the WebSocket and terminate the WebSocket handshake.
Future<Buffer>	HttpClientResponse.body()	Convenience method for receiving the entire request body in one piece.
Future<Buffer>	HttpServerRequest.body()	Convenience method for receiving the entire request body in one piece.
Future<Boolean>	HttpClientRequest.cancel()	Attempt to cancel the request according to the semantics of the underlying HTTP implementation.
Future<Boolean>	HttpServerResponse.cancel()	Attempt to cancel the request according to the semantics of the underlying HTTP implementation.
Future<Void>	ClientWebSocket.close()	Close the WebSocket sending the default close frame.
Future<Void>	ClientWebSocket.close(short statusCode)	Close the WebSocket sending a close frame with specified status code.
Future<Void>	ClientWebSocket.close(short statusCode, String reason)	Close sending a close frame with specified status code and reason.
Future<Void>	HttpClient.close()	Close immediately (shutdown(0, TimeUnit.SECONDS).
Future<Void>	HttpClientAgent.close()	Close immediately (shutdown(0, TimeUnit.SECONDS).
Future<Void>	HttpClientConnection.close()
Future<Void>	HttpConnection.close()	Close immediately (shutdown(0, TimeUnit.SECONDS).
Future<Void>	HttpServer.close()	Close the server.
Future<Void>	ServerWebSocket.close()	The WebSocket handshake will be accepted when it hasn't yet been settled or when an asynchronous handshake is in progress.
Future<Void>	ServerWebSocket.close(short statusCode)	Close the WebSocket sending a close frame with specified status code.
Future<Void>	ServerWebSocket.close(short statusCode, String reason)	Close sending a close frame with specified status code and reason.
Future<Void>	WebSocket.close()	Close the WebSocket sending the default close frame.
Future<Void>	WebSocket.close(short statusCode)	Close the WebSocket sending a close frame with specified status code.
Future<Void>	WebSocket.close(short statusCode, String reason)	Close sending a close frame with specified status code and reason.
Future<Void>	WebSocketBase.close()	Close the WebSocket sending the default close frame.
Future<Void>	WebSocketBase.close(short statusCode)	Close the WebSocket sending a close frame with specified status code.
Future<Void>	WebSocketBase.close(short statusCode, String reason)	Close sending a close frame with specified status code and reason.
Future<Void>	WebSocketClient.close()	Close immediately (shutdown(0, TimeUnit.SECONDS).
Future<WebSocket>	ClientWebSocket.connect(int port, String host, String requestURI)	Connect this WebSocket to the specified port, host and relative request URI.
Future<WebSocket>	ClientWebSocket.connect(WebSocketConnectOptions options)	Connect this WebSocket with the specified options.
Future<WebSocket>	ClientWebSocket.connect(String requestURI)	Connect this WebSocket at the relative request URI using the default host and port.
Future<WebSocket>	ClientWebSocket.connect(String host, String requestURI)	Connect this WebSocket to the host and relative request URI and default port.
Future<HttpClientConnection>	HttpClientAgent.connect(HttpConnectOptions options)	Connect to a remote HTTP server with the specific options, the connection is un-pooled and the management of the connection is left to the user.
Future<HttpClientResponse>	HttpClientRequest.connect()	Create an HTTP tunnel to the server.
Future<WebSocket>	WebSocketClient.connect(int port, String host, String requestURI)	Connect a WebSocket to the specified port, host and relative request URI.
Future<WebSocket>	WebSocketClient.connect(WebSocketConnectOptions options)	Connect a WebSocket with the specified options.
Future<WebSocket>	WebSocketClient.connect(String requestURI)	Connect a WebSocket to the default client port, default client host and specified, relative request URI.
Future<WebSocket>	WebSocketClient.connect(String host, String requestURI)	Connect a WebSocket to the default client port and specified host and relative request URI.
Future<Void>	ClientWebSocket.end()	Calls WebSocketBase.close()
Future<Void>	ClientWebSocket.end(Buffer data)	Same as WebSocketBase.end(Buffer) but writes some data to the stream before ending.
Future<Void>	HttpClientRequest.end()	Ends the request.
Future<Void>	HttpClientRequest.end(Buffer chunk)	Same as HttpClientRequest.end(String) but writes some data to the request body before ending.
Future<Void>	HttpClientRequest.end(String chunk)	Same as HttpClientRequest.end(String) but writes a String in UTF-8 encoding
Future<Void>	HttpClientRequest.end(String chunk, String enc)	Same as HttpClientRequest.end(String) but writes a String with the specified encoding
Future<Void>	HttpClientResponse.end()	Returns a future signaling when the response has been fully received successfully or failed.
Future<Void>	HttpServerRequest.end()	Returns a future signaling when the request has been fully received successfully or failed.
Future<Void>	HttpServerResponse.end()	Ends the response.
Future<Void>	HttpServerResponse.end(Buffer chunk)	Same as HttpServerResponse.end(String) but writes some data to the response body before ending.
Future<Void>	HttpServerResponse.end(String chunk)	Same as HttpServerResponse.end(String) but writes a String in UTF-8 encoding before ending the response.
Future<Void>	HttpServerResponse.end(String chunk, String enc)	Same as HttpServerResponse.end(String) but writes a String with the specified encoding before ending the response.
Future<Void>	ServerWebSocket.end()	Calls ServerWebSocket.close(short)
Future<Void>	ServerWebSocket.end(Buffer data)	Same as WebSocketBase.end(Buffer) but writes some data to the stream before ending.
Future<Void>	WebSocket.end()	Calls WebSocketBase.close()
Future<Void>	WebSocket.end(Buffer data)	Same as WebSocketBase.end(Buffer) but writes some data to the stream before ending.
Future<Void>	WebSocketBase.end()	Calls WebSocketBase.close()
Future<Void>	WebSocketBase.end(Buffer data)	Same as WebSocketBase.end(Buffer) but writes some data to the stream before ending.
Future<HttpServer>	HttpServer.listen()	Tell the server to start listening.
Future<HttpServer>	HttpServer.listen(int port)	Like HttpServer.listen() but the server will listen on host "0.0.0.0" and port specified here ignoring any value in the HttpServerOptions that was used when creating the server.
Future<HttpServer>	HttpServer.listen(int port, String host)	Tell the server to start listening.
Future<HttpServer>	HttpServer.listen(SocketAddress address)	Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).
Future<Buffer>	HttpConnection.ping(Buffer data)	Send a frame to the remote endpoint.
Future<Void>	ClientWebSocket.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	HttpClientResponse.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	HttpServerFileUpload.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	HttpServerRequest.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	ServerWebSocket.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	WebSocket.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	WebSocketBase.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<HttpServerResponse>	HttpServerResponse.push(HttpMethod method, HostAndPort authority, String path)	Like HttpServerResponse.push(HttpMethod, HostAndPort, String) with no headers.
Future<HttpServerResponse>	HttpServerResponse.push(HttpMethod method, HostAndPort authority, String path, MultiMap headers)	Push a response to the client.
Future<HttpServerResponse>	HttpServerResponse.push(HttpMethod method, String path)	Like HttpServerResponse.push(HttpMethod, HostAndPort, String) with the host copied from the current request.
Future<HttpServerResponse>	HttpServerResponse.push(HttpMethod method, String path, MultiMap headers)	Like HttpServerResponse.push(HttpMethod, HostAndPort, String) with the host copied from the current request.
Future<Void>	ServerWebSocketHandshake.reject()	Reject the WebSocket.
Future<Void>	ServerWebSocketHandshake.reject(int status)	Like ServerWebSocketHandshake.reject() but with a status.
Future<HttpClientRequest>	HttpClient.request()	Create an HTTP request to send to the server with the default host and port of the client.
Future<HttpClientRequest>	HttpClient.request(HttpMethod method, int port, String host, String requestURI)	Create an HTTP request to send to the server at the host and port.
Future<HttpClientRequest>	HttpClient.request(HttpMethod method, String requestURI)	Create an HTTP request to send to the server at the default host and port.
Future<HttpClientRequest>	HttpClient.request(HttpMethod method, String host, String requestURI)	Create an HTTP request to send to the server at the host and default port.
Future<HttpClientRequest>	HttpClient.request(RequestOptions options)	Create an HTTP request to send to the server.
Future<HttpClientRequest>	HttpClientAgent.request()	Create an HTTP request to send to the server with the default host and port of the client.
Future<HttpClientRequest>	HttpClientAgent.request(HttpMethod method, int port, String host, String requestURI)	Create an HTTP request to send to the server at the host and port.
Future<HttpClientRequest>	HttpClientAgent.request(HttpMethod method, String requestURI)	Create an HTTP request to send to the server at the default host and port.
Future<HttpClientRequest>	HttpClientAgent.request(HttpMethod method, String host, String requestURI)	Create an HTTP request to send to the server at the host and default port.
Future<HttpClientRequest>	HttpClientAgent.request(RequestOptions options)	Create an HTTP request to send to the server.
Future<HttpClientRequest>	HttpClientConnection.request()	Create an HTTP request to send to the server with the default host and port of the client.
Future<HttpClientRequest>	HttpClientConnection.request(HttpMethod method, int port, String host, String requestURI)	Create an HTTP request to send to the server at the host and port.
Future<HttpClientRequest>	HttpClientConnection.request(HttpMethod method, String requestURI)	Create an HTTP request to send to the server at the default host and port.
Future<HttpClientRequest>	HttpClientConnection.request(HttpMethod method, String host, String requestURI)	Create an HTTP request to send to the server at the host and default port.
Future<HttpClientRequest>	HttpClientConnection.request(RequestOptions options)	Create an HTTP request to send to the server.
Future<Void>	HttpClientRequest.reset()	Reset this stream with the error code 0.
Future<Void>	HttpClientRequest.reset(long code)	Reset this request:
Future<Void>	HttpClientRequest.reset(long code, Throwable cause)	Reset this request:
Future<Void>	HttpServerResponse.reset()	Equivalent to calling HttpServerResponse.reset() with 0.
Future<Void>	HttpServerResponse.reset(long code)	Reset this response:
Future<HttpClientResponse>	HttpClientRequest.response()
Future<HttpClientResponse>	HttpClientRequest.send()	Send the request with an empty body.
Future<HttpClientResponse>	HttpClientRequest.send(Flowable<Buffer> body)	Send the request with a stream body.
Future<HttpClientResponse>	HttpClientRequest.send(Buffer body)	Send the request with a buffer body.
Future<HttpClientResponse>	HttpClientRequest.send(ClientForm form)	Like HttpClientRequest.send() but with a form.
Future<HttpClientResponse>	HttpClientRequest.send(ReadStream<Buffer> body)	Send the request with a stream body.
Future<HttpClientResponse>	HttpClientRequest.send(String body)	Send the request with a string body.
Future<Void>	HttpServerResponse.send()	Send the request with an empty body.
Future<Void>	HttpServerResponse.send(Flowable<Buffer> body)	Send the request with a stream body.
Future<Void>	HttpServerResponse.send(Buffer body)	Send the request with a buffer body.
Future<Void>	HttpServerResponse.send(ReadStream<Buffer> body)	Send the request with a stream body.
Future<Void>	HttpServerResponse.send(String body)	Send the request with a string body.
Future<Void>	HttpServerResponse.sendFile(RandomAccessFile file)	Same as HttpServerResponse.sendFile(String) with
Future<Void>	HttpServerResponse.sendFile(RandomAccessFile file, long offset)	Same as HttpServerResponse.sendFile(String) with
Future<Void>	HttpServerResponse.sendFile(RandomAccessFile file, long offset, long length)	Same as HttpServerResponse.sendFile(String) with
Future<Void>	HttpServerResponse.sendFile(String filename)	Send the request with a stream body.
Future<Void>	HttpServerResponse.sendFile(String filename, long offset)	Same as HttpServerResponse.sendFile(String) using length @code{Long.MAX_VALUE} which means until the end of the file.
Future<Void>	HttpServerResponse.sendFile(String filename, long offset, long length)	Ask the OS to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	HttpServerResponse.sendFile(FileChannel channel)	Same as HttpServerResponse.sendFile(String) using length @code{Long.MAX_VALUE} which means until the end of the file.
Future<Void>	HttpServerResponse.sendFile(FileChannel channel, long offset)	Same as HttpServerResponse.sendFile(String) using length @code{Long.MAX_VALUE} which means until the end of the file.
Future<Void>	HttpServerResponse.sendFile(FileChannel channel, long offset, long length)	Ask the OS to stream a file as specified by channel directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system).
Future<Void>	HttpClientRequest.sendHead()	Deprecated.
Future<Void>	ClientWebSocket.shutdown()	Like WebSocketBase.shutdown() with a 30 seconds timeout, the status code 1000 a null reason.
Future<Void>	ClientWebSocket.shutdown(long timeout, TimeUnit unit)	Calls WebSocketBase.shutdown() with the status code 1000 and a null reason.
Future<Void>	ClientWebSocket.shutdown(long timeout, TimeUnit unit, short statusCode)	Calls WebSocketBase.shutdown() with a null reason.
Future<Void>	ClientWebSocket.shutdown(long timeout, TimeUnit unit, short statusCode, String reason)	Calls WebSocketBase.shutdown()
Future<Void>	ClientWebSocket.shutdown(short statusCode)	Like WebSocketBase.shutdown() with a 30 seconds timeout and a null reason.
Future<Void>	ClientWebSocket.shutdown(short statusCode, String reason)	Like WebSocketBase.shutdown() with a 30 seconds timeout.
Future<Void>	ClientWebSocket.shutdown(Duration timeout)	Calls WebSocketBase.shutdown() with the status code 1000 and a null reason.
Future<Void>	ClientWebSocket.shutdown(Duration timeout, short statusCode)	Calls WebSocketBase.shutdown() with a null reason.
Future<Void>	ClientWebSocket.shutdown(Duration timeout, short statusCode, String reason)	Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a timeout the WebSocket will be closed.
Future<Void>	HttpClient.shutdown()	Shutdown with a 30 seconds timeout (shutdown(30, TimeUnit.SECONDS)).
Future<Void>	HttpClient.shutdown(long timeout, TimeUnit unit)	Calls HttpClient.shutdown().
Future<Void>	HttpClientAgent.shutdown()	Shutdown with a 30 seconds timeout (shutdown(30, TimeUnit.SECONDS)).
Future<Void>	HttpClientAgent.shutdown(long timeout, TimeUnit unit)	Calls HttpClient.shutdown().
Future<Void>	HttpClientAgent.shutdown(Duration timeout)	Initiate the client shutdown sequence.
Future<Void>	HttpClientConnection.shutdown()
Future<Void>	HttpClientConnection.shutdown(long timeout, TimeUnit unit)
Future<Void>	HttpClientConnection.shutdown(Duration timeout)	Initiate the client shutdown sequence.
Future<Void>	HttpConnection.shutdown()	Shutdown with a 30 seconds timeout (shutdown(30, TimeUnit.SECONDS)).
Future<Void>	HttpConnection.shutdown(long timeout, TimeUnit unit)	Calls HttpConnection.shutdown()
Future<Void>	HttpConnection.shutdown(Duration timeout)	Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight requests are processed, otherwise after a timeout the connection will be closed.
Future<Void>	HttpServer.shutdown()	Shutdown with a 30 seconds timeout (shutdown(Duration.ofSeconds(30))).
Future<Void>	HttpServer.shutdown(long timeout, TimeUnit unit)	Calls HttpServer.shutdown().
Future<Void>	HttpServer.shutdown(Duration timeout)	Initiate the server shutdown sequence.
Future<Void>	ServerWebSocket.shutdown()	Like WebSocketBase.shutdown() with a 30 seconds timeout, the status code 1000 a null reason.
Future<Void>	ServerWebSocket.shutdown(long timeout, TimeUnit unit)	Calls WebSocketBase.shutdown() with the status code 1000 and a null reason.
Future<Void>	ServerWebSocket.shutdown(long timeout, TimeUnit unit, short statusCode)	Calls WebSocketBase.shutdown() with a null reason.
Future<Void>	ServerWebSocket.shutdown(long timeout, TimeUnit unit, short statusCode, String reason)	Calls WebSocketBase.shutdown()
Future<Void>	ServerWebSocket.shutdown(short statusCode)	Like WebSocketBase.shutdown() with a 30 seconds timeout and a null reason.
Future<Void>	ServerWebSocket.shutdown(short statusCode, String reason)	Like WebSocketBase.shutdown() with a 30 seconds timeout.
Future<Void>	ServerWebSocket.shutdown(Duration timeout)	Calls WebSocketBase.shutdown() with the status code 1000 and a null reason.
Future<Void>	ServerWebSocket.shutdown(Duration timeout, short statusCode)	Calls WebSocketBase.shutdown() with a null reason.
Future<Void>	ServerWebSocket.shutdown(Duration timeout, short statusCode, String reason)	Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a timeout the WebSocket will be closed.
Future<Void>	WebSocket.shutdown()	Like WebSocketBase.shutdown() with a 30 seconds timeout, the status code 1000 a null reason.
Future<Void>	WebSocket.shutdown(long timeout, TimeUnit unit)	Calls WebSocketBase.shutdown() with the status code 1000 and a null reason.
Future<Void>	WebSocket.shutdown(long timeout, TimeUnit unit, short statusCode)	Calls WebSocketBase.shutdown() with a null reason.
Future<Void>	WebSocket.shutdown(long timeout, TimeUnit unit, short statusCode, String reason)	Calls WebSocketBase.shutdown()
Future<Void>	WebSocket.shutdown(short statusCode)	Like WebSocketBase.shutdown() with a 30 seconds timeout and a null reason.
Future<Void>	WebSocket.shutdown(short statusCode, String reason)	Like WebSocketBase.shutdown() with a 30 seconds timeout.
Future<Void>	WebSocket.shutdown(Duration timeout)	Calls WebSocketBase.shutdown() with the status code 1000 and a null reason.
Future<Void>	WebSocket.shutdown(Duration timeout, short statusCode)	Calls WebSocketBase.shutdown() with a null reason.
Future<Void>	WebSocket.shutdown(Duration timeout, short statusCode, String reason)	Initiate a graceful WebSocket shutdown, the shutdown handler is notified and shall close the WebSocket, otherwise after a timeout the WebSocket will be closed.
Future<Void>	WebSocketBase.shutdown()	Like WebSocketBase.shutdown() with a 30 seconds timeout, the status code 1000 a null reason.
Future<Void>	WebSocketBase.shutdown(long timeout, TimeUnit unit)	Calls WebSocketBase.shutdown() with the status code 1000 and a null reason.
Future<Void>	WebSocketBase.shutdown(long timeout, TimeUnit unit, short statusCode)	Calls WebSocketBase.shutdown() with a null reason.
Future<Void>	WebSocketBase.shutdown(long timeout, TimeUnit unit, short statusCode, String reason)	Calls WebSocketBase.shutdown()
Future<Void>	WebSocketBase.shutdown(short statusCode)	Like WebSocketBase.shutdown() with a 30 seconds timeout and a null reason.
Future<Void>	WebSocketBase.shutdown(short statusCode, String reason)	Like WebSocketBase.shutdown() with a 30 seconds timeout.
Future<Void>	WebSocketClient.shutdown()	Shutdown with a 30 seconds timeout (shutdown(30, TimeUnit.SECONDS)).
Future<Void>	WebSocketClient.shutdown(long timeout, TimeUnit unit)	Calls WebSocketClient.shutdown().
Future<Void>	WebSocketClient.shutdown(Duration timeout)	Initiate the client shutdown sequence.
Future<Void>	HttpServerFileUpload.streamToFileSystem(String filename)	Stream the content of this upload to the given file on storage.
Future<NetSocket>	HttpServerRequest.toNetSocket()	Establish a TCP tunnel with the client.
Future<ServerWebSocket>	HttpServerRequest.toWebSocket()	Upgrade the connection of the current request to a WebSocket.
Future<Void>	HttpConnection.updateSettings(HttpSettings settings)	Send to the remote endpoint an update of this endpoint settings
Future<Boolean>	HttpClientAgent.updateSSLOptions(ClientSSLOptions options)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	HttpClientAgent.updateSSLOptions(ClientSSLOptions options, boolean force)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	HttpServer.updateSSLOptions(ServerSSLOptions options)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	HttpServer.updateSSLOptions(ServerSSLOptions options, boolean force)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	WebSocketClient.updateSSLOptions(ClientSSLOptions options)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	WebSocketClient.updateSSLOptions(ClientSSLOptions options, boolean force)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	HttpServer.updateTrafficShapingOptions(TrafficShapingOptions options)	Update the server with new traffic options, the update happens if the options object is valid and different from the existing options object.
Future<Void>	ClientWebSocket.write(Buffer data)	Write some data to the stream.
Future<Void>	HttpClientRequest.write(Buffer data)	Write some data to the stream.
Future<Void>	HttpClientRequest.write(String chunk)	Write a String to the request body, encoded as UTF-8.
Future<Void>	HttpClientRequest.write(String chunk, String enc)	Write a String to the request body, encoded using the encoding enc.
Future<Void>	HttpServerResponse.write(Buffer data)	Write some data to the stream.
Future<Void>	HttpServerResponse.write(String chunk)	Write a String to the response body, encoded in UTF-8.
Future<Void>	HttpServerResponse.write(String chunk, String enc)	Write a String to the response body, encoded using the encoding enc.
Future<Void>	ServerWebSocket.write(Buffer data)	Write some data to the stream.
Future<Void>	WebSocket.write(Buffer data)	Write some data to the stream.
Future<Void>	WebSocketBase.write(Buffer data)	Write some data to the stream.
Future<Void>	HttpServerResponse.writeAltSvc(String advertisement)	Write an invalid input: '<'a href="https://datatracker.ietf.org/doc/html/rfc7838"HTTP Alternative Services advertisement for the given request and its authority, according to the underlying protocol.
Future<Void>	ClientWebSocket.writeBinaryMessage(Buffer data)	Writes a (potentially large) piece of binary data to the connection.
Future<Void>	ServerWebSocket.writeBinaryMessage(Buffer data)	Writes a (potentially large) piece of binary data to the connection.
Future<Void>	WebSocket.writeBinaryMessage(Buffer data)	Writes a (potentially large) piece of binary data to the connection.
Future<Void>	WebSocketBase.writeBinaryMessage(Buffer data)	Writes a (potentially large) piece of binary data to the connection.
Future<Void>	HttpServerResponse.writeContinue()	Used to write an interim 100 Continue response to signify that the client should send the rest of the request.
Future<Void>	HttpClientRequest.writeCustomFrame(int type, int flags, Buffer payload)	Write an HTTP/2 frame to the request, allowing to extend the HTTP/2 protocol.
Future<Void>	HttpClientRequest.writeCustomFrame(HttpFrame frame)	Like HttpClientRequest.writeCustomFrame(int, int, Buffer) but with an HttpFrame.
Future<Void>	HttpServerResponse.writeCustomFrame(int type, int flags, Buffer payload)	Write an HTTP/2 frame to the response, allowing to extend the HTTP/2 protocol.
Future<Void>	HttpServerResponse.writeCustomFrame(HttpFrame frame)	Like HttpServerResponse.writeCustomFrame(int, int, Buffer) but with an HttpFrame.
Future<Void>	HttpServerResponse.writeEarlyHints(MultiMap headers)	Used to write an interim 103 Early Hints response to return some HTTP headers before the final HTTP message.
Future<Void>	ClientWebSocket.writeFinalBinaryFrame(Buffer data)	Write a final WebSocket binary frame to the connection
Future<Void>	ServerWebSocket.writeFinalBinaryFrame(Buffer data)	Write a final WebSocket binary frame to the connection
Future<Void>	WebSocket.writeFinalBinaryFrame(Buffer data)	Write a final WebSocket binary frame to the connection
Future<Void>	WebSocketBase.writeFinalBinaryFrame(Buffer data)	Write a final WebSocket binary frame to the connection
Future<Void>	ClientWebSocket.writeFinalTextFrame(String text)	Write a final WebSocket text frame to the connection
Future<Void>	ServerWebSocket.writeFinalTextFrame(String text)	Write a final WebSocket text frame to the connection
Future<Void>	WebSocket.writeFinalTextFrame(String text)	Write a final WebSocket text frame to the connection
Future<Void>	WebSocketBase.writeFinalTextFrame(String text)	Write a final WebSocket text frame to the connection
Future<Void>	ClientWebSocket.writeFrame(WebSocketFrame frame)	Write a WebSocket frame to the connection
Future<Void>	ServerWebSocket.writeFrame(WebSocketFrame frame)	Write a WebSocket frame to the connection
Future<Void>	WebSocket.writeFrame(WebSocketFrame frame)	Write a WebSocket frame to the connection
Future<Void>	WebSocketBase.writeFrame(WebSocketFrame frame)	Write a WebSocket frame to the connection
Future<Void>	HttpClientRequest.writeHead()	Write the head of the request.
Future<Void>	HttpServerResponse.writeHead()	Send the response headers.
Future<Void>	ClientWebSocket.writePing(Buffer data)	Writes a ping frame to the connection.
Future<Void>	ServerWebSocket.writePing(Buffer data)	Writes a ping frame to the connection.
Future<Void>	WebSocket.writePing(Buffer data)	Writes a ping frame to the connection.
Future<Void>	WebSocketBase.writePing(Buffer data)	Writes a ping frame to the connection.
Future<Void>	ClientWebSocket.writePong(Buffer data)	Writes a pong frame to the connection.
Future<Void>	ServerWebSocket.writePong(Buffer data)	Writes a pong frame to the connection.
Future<Void>	WebSocket.writePong(Buffer data)	Writes a pong frame to the connection.
Future<Void>	WebSocketBase.writePong(Buffer data)	Writes a pong frame to the connection.
Future<Void>	ClientWebSocket.writeTextMessage(String text)	Writes a (potentially large) piece of text data to the connection.
Future<Void>	ServerWebSocket.writeTextMessage(String text)	Writes a (potentially large) piece of text data to the connection.
Future<Void>	WebSocket.writeTextMessage(String text)	Writes a (potentially large) piece of text data to the connection.
Future<Void>	WebSocketBase.writeTextMessage(String text)	Writes a (potentially large) piece of text data to the connection.

Method parameters in io.vertx.reactivex.core.http with type arguments of type Future

Modifier and Type	Method	Description
HttpClientRequest	HttpClientRequest.redirectHandler(Function<HttpClientResponse, Future<HttpClientRequest>> handler)
HttpClientBuilder	HttpClientBuilder.withRedirectHandler(Function<HttpClientResponse, Future<RequestOptions>> handler)	Set a redirect handler for the http client.

Uses of Future in io.vertx.reactivex.core.net

Methods in io.vertx.reactivex.core.net that return Future

Modifier and Type	Method	Description
Future<Void>	QuicStream.abort(int error)	Instruct the remote peer that this part of the stream is no longer interested in received data and wants it to cease transmission, a STOP_SENDING frame is sent to the remote peer.
Future<SocketAddress>	QuicEndpoint.bind(SocketAddress address)	Binds a UDP socket at the given address.
Future<Void>	NetClient.close()	Close immediately (shutdown(0, TimeUnit.SECONDS).
Future<Void>	NetServer.close()	Close the server.
Future<Void>	NetSocket.close()	Close the socket
Future<Void>	QuicConnection.close()	Close the connection, all associated streams will be closed before.
Future<Void>	QuicConnection.close(QuicConnectionClose payload)	Close the connection, all associated streams will be closed before.
Future<Void>	QuicEndpoint.close()	Close the endpoint and release all associated resources.
Future<Void>	QuicStream.close()	Close the channel
Future<Void>	StreamChannel.close()	Close the channel
Future<NetSocket>	NetClient.connect(int port, String host)	Open a connection to a server at the specific port and host.
Future<NetSocket>	NetClient.connect(int port, String host, String serverName)	Open a connection to a server at the specific port and host.
Future<NetSocket>	NetClient.connect(ConnectOptions connectOptions)	Open a connection to a server at the specific connectOptions.
Future<NetSocket>	NetClient.connect(SocketAddress remoteAddress)	Open a connection to a server at the specific remoteAddress.
Future<NetSocket>	NetClient.connect(SocketAddress remoteAddress, String serverName)	Open a connection to a server at the specific remoteAddress.
Future<QuicConnection>	QuicClient.connect(int port, String host)	Connect to a Quic server at the specific port and host.
Future<QuicConnection>	QuicClient.connect(int port, String host, QuicConnectOptions options)	Connect to a Quic server at the specific port and host, with specific options.
Future<QuicConnection>	QuicClient.connect(SocketAddress address)	Connect to a Quic server.
Future<QuicConnection>	QuicClient.connect(SocketAddress address, QuicConnectOptions options)	Connect to a Quic server with specific options.
Future<Void>	NetSocket.end()	Calls NetSocket.close()
Future<Void>	NetSocket.end(Buffer data)	Same as NetSocket.end(Buffer) but writes some data to the stream before ending.
Future<Void>	QuicStream.end()	Calls StreamChannel.close()
Future<Void>	QuicStream.end(Buffer data)	Same as StreamChannel.end(Buffer) but writes some data to the stream before ending.
Future<Void>	StreamChannel.end()	Calls StreamChannel.close()
Future<Void>	StreamChannel.end(Buffer data)	Same as StreamChannel.end(Buffer) but writes some data to the stream before ending.
Future<NetServer>	NetServer.listen()	Start listening on the port and host as configured in the NetServerOptions used when creating the server.
Future<NetServer>	NetServer.listen(int port)	Start listening on the specified port and host "0.0.0.0", ignoring port and host configured in the NetServerOptions used when creating the server.
Future<NetServer>	NetServer.listen(int port, String host)	Start listening on the specified port and host, ignoring port and host configured in the NetServerOptions used when creating the server.
Future<NetServer>	NetServer.listen(SocketAddress localAddress)	Start listening on the specified local address, ignoring port and host configured in the NetServerOptions used when creating the server.
Future<SocketAddress>	QuicServer.listen()	Start listening on the port and host as configured in the QuicServerConfig used when creating the server.
Future<SocketAddress>	QuicServer.listen(int port)	Start listening on the specified port and host "0.0.0.0".
Future<SocketAddress>	QuicServer.listen(int port, String host)	Start listening on the specified port and host.
Future<SocketAddress>	QuicServer.listen(SocketAddress localAddress)	Start listening on the specified local address.
Future<QuicStream>	QuicConnection.openStream()	Open a bidirectional stream to the remote endpoint.
Future<QuicStream>	QuicConnection.openStream(boolean bidirectional)	Open a stream to the remote endpoint with bidirectional parameter specifying its directionality.
Future<Void>	NetSocket.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	QuicStream.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	StreamChannel.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	QuicStream.reset(int error)	Abruptly terminate the sending part of the stream with the specified application protocol error code argument, a RESET frame is sent to the remote peer.
Future<Void>	NetSocket.sendFile(String filename)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	NetSocket.sendFile(String filename, long offset)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	NetSocket.sendFile(String filename, long offset, long length)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	QuicStream.sendFile(String filename)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	QuicStream.sendFile(String filename, long offset)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	QuicStream.sendFile(String filename, long offset, long length)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	StreamChannel.sendFile(String filename)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	StreamChannel.sendFile(String filename, long offset)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	StreamChannel.sendFile(String filename, long offset, long length)	Tell the operating system to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system.
Future<Void>	NetClient.shutdown()	Shutdown with a 30 seconds timeout (shutdown(30, TimeUnit.SECONDS)).
Future<Void>	NetClient.shutdown(long timeout, TimeUnit unit)	Calls NetClient.shutdown().
Future<Void>	NetClient.shutdown(Duration timeout)	Initiate the client shutdown sequence.
Future<Void>	NetServer.shutdown()	Shutdown with a 30 seconds timeout (shutdown(30, TimeUnit.SECONDS)).
Future<Void>	NetServer.shutdown(long timeout, TimeUnit unit)	Calls NetServer.shutdown().
Future<Void>	NetServer.shutdown(Duration timeout)	Initiate the server shutdown sequence.
Future<Void>	QuicConnection.shutdown()	Shutdown with a 30 seconds timeout.
Future<Void>	QuicConnection.shutdown(Duration timeout)	Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight streams are processed, otherwise after a timeout the connection will be closed.
Future<Void>	QuicConnection.shutdown(Duration timeout, QuicConnectionClose payload)	Initiate a graceful connection shutdown, the connection is taken out of service and closed when all the inflight streams are processed, otherwise after a timeout the connection will be closed.
Future<Void>	QuicEndpoint.shutdown()	Shutdown the endpoint with a 30 seconds grace period (shutdown(30, TimeUnit.SECONDS)).
Future<Void>	QuicEndpoint.shutdown(Duration timeout)	Initiate the endpoint shutdown sequence.
Future<Boolean>	NetClient.updateSSLOptions(ClientSSLOptions options)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	NetClient.updateSSLOptions(ClientSSLOptions options, boolean force)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	NetServer.updateSSLOptions(ServerSSLOptions options)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	NetServer.updateSSLOptions(ServerSSLOptions options, boolean force)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	QuicServer.updateSSLOptions(ServerSSLOptions options)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	QuicServer.updateSSLOptions(ServerSSLOptions options, boolean force)	Update the server with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	NetServer.updateTrafficShapingOptions(TrafficShapingOptions options)	Update the server with new traffic options, the update happens if the options object is valid and different from the existing options object.
Future<Void>	NetSocket.upgradeToSsl()	Like NetSocket.upgradeToSsl() with the default SSL options, without indicating a server name, without an upgrade message.
Future<Void>	NetSocket.upgradeToSsl(Buffer msg)	Like NetSocket.upgradeToSsl() with the default SSL options and without indicating a server name.
Future<Void>	NetSocket.upgradeToSsl(SSLOptions sslOptions)	Upgrade channel to use SSL/TLS.
Future<Void>	NetSocket.upgradeToSsl(SSLOptions sslOptions, Buffer msg)	Like NetSocket.upgradeToSsl() without indicating a server name
Future<Void>	NetSocket.upgradeToSsl(SSLOptions sslOptions, String serverName)	Like NetSocket.upgradeToSsl() without an upgrade message.
Future<Void>	NetSocket.upgradeToSsl(SSLOptions sslOptions, String serverName, Buffer upgrade)	Upgrade the channel to use SSL/TLS, in other words proceeds to the TLS handshake.
Future<Void>	NetSocket.upgradeToSsl(String serverName)	Like NetSocket.upgradeToSsl() with the default SSL options and without an update message.
Future<Void>	NetSocket.upgradeToSsl(String serverName, Buffer msg)	Like NetSocket.upgradeToSsl() with the default SSL options.
Future<Void>	NetSocket.write(Buffer data)	Write some data to the stream.
Future<Void>	NetSocket.write(String str)	Write a String to the connection, encoded in UTF-8.
Future<Void>	NetSocket.write(String str, String enc)	Write a String to the connection, encoded using the encoding enc.
Future<Void>	QuicStream.write(Buffer data)	Write some data to the stream.
Future<Void>	QuicStream.write(String str)	Write a String to the connection, encoded in UTF-8.
Future<Void>	QuicStream.write(String str, String enc)	Write a String to the connection, encoded using the encoding enc.
Future<Void>	StreamChannel.write(Buffer data)	Write some data to the stream.
Future<Void>	StreamChannel.write(String str)	Write a String to the connection, encoded in UTF-8.
Future<Void>	StreamChannel.write(String str, String enc)	Write a String to the connection, encoded using the encoding enc.
Future<Void>	QuicConnection.writeDatagram(Buffer buffer)	Send a datagram.

Uses of Future in io.vertx.reactivex.core.net.endpoint

Methods in io.vertx.reactivex.core.net.endpoint that return Future

Modifier and Type	Method	Description
Future<Endpoint>	EndpointResolver.resolveEndpoint(Address address)	Resolver an endpoint for the specified address

Uses of Future in io.vertx.reactivex.core.parsetools

Methods in io.vertx.reactivex.core.parsetools that return Future

Modifier and Type	Method	Description
Future<Void>	JsonParser.pipeTo(WriteStream<JsonEvent> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	RecordParser.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.

Uses of Future in io.vertx.reactivex.core.shareddata

Methods in io.vertx.reactivex.core.shareddata that return Future

Modifier and Type	Method	Description
Future<Long>	Counter.addAndGet(long value)	Add the value to the counter atomically and return the new count
Future<Void>	AsyncMap.clear()	Clear all entries in the map
Future<Boolean>	Counter.compareAndSet(long expected, long value)	Set the counter to the specified value only if the current value is the expectec value.
Future<Long>	Counter.decrementAndGet()	Decrement the counter atomically and return the new count
Future<V>	AsyncMap.get(K k)	Get a value from the map, asynchronously.
Future<Long>	Counter.get()	Get the current value of the counter
Future<Long>	Counter.getAndAdd(long value)	Add the value to the counter atomically and return the value before the add
Future<Long>	Counter.getAndIncrement()	Increment the counter atomically and return the value before the increment.
<K,V> Future<AsyncMap<K,V>>	SharedData.getAsyncMap(String name)	Get the AsyncMap with the specified name.
<K,V> Future<AsyncMap<K,V>>	SharedData.getClusterWideMap(String name)	Get the cluster wide map with the specified name.
Future<Counter>	SharedData.getCounter(String name)	Get an asynchronous counter.
<K,V> Future<AsyncMap<K,V>>	SharedData.getLocalAsyncMap(String name)	Get the AsyncMap with the specified name.
Future<Counter>	SharedData.getLocalCounter(String name)	Get an asynchronous local counter.
Future<Lock>	SharedData.getLocalLock(String name)	Get an asynchronous local lock with the specified name.
Future<Lock>	SharedData.getLocalLockWithTimeout(String name, long timeout)	Like SharedData.getLocalLock(String) but specifying a timeout.
Future<Lock>	SharedData.getLock(String name)	Get an asynchronous lock with the specified name.
Future<Lock>	SharedData.getLockWithTimeout(String name, long timeout)	Like SharedData.getLock(String) but specifying a timeout.
Future<Long>	Counter.incrementAndGet()	Increment the counter atomically and return the new count
Future<Set<K>>	AsyncMap.keys()	Get the keys of the map, asynchronously.
Future<Void>	AsyncMap.put(K k, V v)	Put a value in the map, asynchronously.
Future<Void>	AsyncMap.put(K k, V v, long ttl)	Like AsyncMap.put(K, V) but specifying a time to live for the entry.
Future<V>	AsyncMap.putIfAbsent(K k, V v)	Put the entry only if there is no entry with the key already present.
Future<V>	AsyncMap.putIfAbsent(K k, V v, long ttl)	Link AsyncMap.putIfAbsent(K, V) but specifying a time to live for the entry.
Future<V>	AsyncMap.remove(K k)	Remove a value from the map, asynchronously.
Future<Boolean>	AsyncMap.removeIfPresent(K k, V v)	Remove a value from the map, only if entry already exists with same value.
Future<V>	AsyncMap.replace(K k, V v)	Replace the entry only if it is currently mapped to some value
Future<V>	AsyncMap.replace(K k, V v, long ttl)	Replace the entry only if it is currently mapped to some value
Future<Boolean>	AsyncMap.replaceIfPresent(K k, V oldValue, V newValue)	Replace the entry only if it is currently mapped to a specific value
Future<Boolean>	AsyncMap.replaceIfPresent(K k, V oldValue, V newValue, long ttl)	Replace the entry only if it is currently mapped to a specific value
Future<Integer>	AsyncMap.size()	Provide the number of entries in the map
Future<List<V>>	AsyncMap.values()	Get the values of the map, asynchronously.
<T> Future<T>	SharedData.withLocalLock(String name, long timeout, Supplier<Future<T>> block)	Like SharedData.withLocalLock(String, Supplier) but specifying a timeout.
<T> Future<T>	SharedData.withLocalLock(String name, Supplier<Future<T>> block)	Get an asynchronous local lock with the specified name.
<T> Future<T>	SharedData.withLock(String name, long timeout, Supplier<Future<T>> block)	Like SharedData.withLock(String, Supplier) but specifying a timeout.
<T> Future<T>	SharedData.withLock(String name, Supplier<Future<T>> block)	Get an asynchronous lock with the specified name.

Method parameters in io.vertx.reactivex.core.shareddata with type arguments of type Future

Modifier and Type	Method	Description
<T> Single<T>	SharedData.rxWithLocalLock(String name, long timeout, Supplier<Future<T>> block)	Like SharedData.withLocalLock(String, Supplier) but specifying a timeout.
<T> Single<T>	SharedData.rxWithLocalLock(String name, Supplier<Future<T>> block)	Get an asynchronous local lock with the specified name.
<T> Single<T>	SharedData.rxWithLock(String name, long timeout, Supplier<Future<T>> block)	Like SharedData.withLock(String, Supplier) but specifying a timeout.
<T> Single<T>	SharedData.rxWithLock(String name, Supplier<Future<T>> block)	Get an asynchronous lock with the specified name.
<T> Future<T>	SharedData.withLocalLock(String name, long timeout, Supplier<Future<T>> block)	Like SharedData.withLocalLock(String, Supplier) but specifying a timeout.
<T> Future<T>	SharedData.withLocalLock(String name, Supplier<Future<T>> block)	Get an asynchronous local lock with the specified name.
<T> Future<T>	SharedData.withLock(String name, long timeout, Supplier<Future<T>> block)	Like SharedData.withLock(String, Supplier) but specifying a timeout.
<T> Future<T>	SharedData.withLock(String name, Supplier<Future<T>> block)	Get an asynchronous lock with the specified name.

Uses of Future in io.vertx.reactivex.core.streams

Methods in io.vertx.reactivex.core.streams that return Future

Modifier and Type	Method	Description
Future<Void>	WriteStream.end()	Ends the stream.
Future<Void>	WriteStream.end(T data)	Same as WriteStream.end() but writes some data to the stream before ending.
Future<Void>	ReadStream.pipeTo(WriteStream<T> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	Pipe.to(WriteStream<T> dst)	Start to pipe the elements to the destination WriteStream.
Future<Void>	WriteStream.write(T data)	Write some data to the stream.

Uses of Future in io.vertx.reactivex.db2client

Methods in io.vertx.reactivex.db2client that return Future

Modifier and Type	Method	Description
static Future<DB2Connection>	DB2Connection.connect(Vertx vertx, DB2ConnectOptions connectOptions)	Create a connection to DB2 server with the given connectOptions.
static Future<DB2Connection>	DB2Connection.connect(Vertx vertx, String connectionUri)	Like DB2Connection.connect(Vertx, DB2ConnectOptions) with options build from connectionUri.
Future<Void>	DB2Connection.debug()	Send a DEBUG command to dump debug information to the server's stdout.
Future<Void>	DB2Connection.ping()	Send a PING command to check if the server is alive.

Uses of Future in io.vertx.reactivex.eventbus.bridge.grpc

Methods in io.vertx.reactivex.eventbus.bridge.grpc that return Future

Modifier and Type	Method	Description
Future<Boolean>	BridgeEvent.future()

Uses of Future in io.vertx.reactivex.ext.auth.abac

Methods in io.vertx.reactivex.ext.auth.abac that return Future

Modifier and Type	Method	Description
Future<Void>	PolicyBasedAuthorizationProvider.getAuthorizations(User user)	Updates the user with the set of authorizations.

Uses of Future in io.vertx.reactivex.ext.auth.authentication

Methods in io.vertx.reactivex.ext.auth.authentication that return Future

Modifier and Type	Method	Description
Future<User>	AuthenticationProvider.authenticate(Credentials credentials)	Authenticate a user.

Uses of Future in io.vertx.reactivex.ext.auth.authorization

Methods in io.vertx.reactivex.ext.auth.authorization that return Future

Modifier and Type	Method	Description
Future<Void>	AuthorizationProvider.getAuthorizations(User user)	Updates the user with the set of authorizations.

Uses of Future in io.vertx.reactivex.ext.auth.jwt.authorization

Methods in io.vertx.reactivex.ext.auth.jwt.authorization that return Future

Modifier and Type	Method	Description
Future<Void>	JWTAuthorization.getAuthorizations(User user)	Updates the user with the set of authorizations.
Future<Void>	MicroProfileAuthorization.getAuthorizations(User user)	Updates the user with the set of authorizations.

Uses of Future in io.vertx.reactivex.ext.auth.oauth2

Methods in io.vertx.reactivex.ext.auth.oauth2 that return Future

Modifier and Type	Method	Description
Future<Void>	OAuth2Auth.jWKSet()	Retrieve the public server JSON Web Key (JWK) required to verify the authenticity of issued ID and access tokens.
Future<User>	OAuth2Auth.refresh(User user)	Refresh the current User (access token).
Future<Void>	OAuth2Auth.revoke(User user)	Revoke an obtained access token.
Future<Void>	OAuth2Auth.revoke(User user, String tokenType)	Revoke an obtained access or refresh token.
Future<JsonObject>	OAuth2Auth.userInfo(User user)	Retrieve profile information and other attributes for a logged-in end-user.

Uses of Future in io.vertx.reactivex.ext.auth.oauth2.authorization

Methods in io.vertx.reactivex.ext.auth.oauth2.authorization that return Future

Modifier and Type	Method	Description
Future<Void>	KeycloakAuthorization.getAuthorizations(User user)	Updates the user with the set of authorizations.
Future<Void>	ScopeAuthorization.getAuthorizations(User user)	Updates the user with the set of authorizations.

Uses of Future in io.vertx.reactivex.ext.auth.oauth2.providers

Methods in io.vertx.reactivex.ext.auth.oauth2.providers that return Future

Modifier and Type	Method	Description
static Future<OAuth2Auth>	AmazonCognitoAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	AppleIdAuth.discover(Vertx vertx, PubSecKeyOptions privateKey, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	AzureADAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	GoogleAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	IBMCloudAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	KeycloakAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	OpenIDConnectAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	SalesforceAuth.discover(Vertx vertx, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	ZohoAuth.discover(Vertx vertx, String soid, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.
static Future<OAuth2Auth>	ZohoAuth.discover(Vertx vertx, String dc, String soid, OAuth2Options config)	Create a OAuth2Auth provider for OpenID Connect Discovery.

Uses of Future in io.vertx.reactivex.ext.auth.otp.hotp

Methods in io.vertx.reactivex.ext.auth.otp.hotp that return Future

Modifier and Type	Method	Description
Future<Authenticator>	HotpAuth.createAuthenticator(String id, OtpKey otpKey)	Creating authenticator from user id and key.

Method parameters in io.vertx.reactivex.ext.auth.otp.hotp with type arguments of type Future

Modifier and Type	Method	Description
HotpAuth	HotpAuth.authenticatorFetcher(Function<String, Future<Authenticator>> fetcher)	Provide a that can fetch s from a backend given an identifier argument.
HotpAuth	HotpAuth.authenticatorUpdater(Function<Authenticator, Future<Void>> updater)	Provide a that can update or insert a .

Uses of Future in io.vertx.reactivex.ext.auth.otp.totp

Methods in io.vertx.reactivex.ext.auth.otp.totp that return Future

Modifier and Type	Method	Description
Future<Authenticator>	TotpAuth.createAuthenticator(String id, OtpKey otpKey)	Creating authenticator from user id and key.

Method parameters in io.vertx.reactivex.ext.auth.otp.totp with type arguments of type Future

Modifier and Type	Method	Description
TotpAuth	TotpAuth.authenticatorFetcher(Function<String, Future<Authenticator>> fetcher)	Provide a that can fetch s from a backend given an identifier argument.
TotpAuth	TotpAuth.authenticatorUpdater(Function<Authenticator, Future<Void>> updater)	Provide a that can update or insert a .

Uses of Future in io.vertx.reactivex.ext.auth.properties

Methods in io.vertx.reactivex.ext.auth.properties that return Future

Modifier and Type	Method	Description
Future<Void>	PropertyFileAuthorization.getAuthorizations(User user)	Updates the user with the set of authorizations.

Uses of Future in io.vertx.reactivex.ext.auth.sqlclient

Methods in io.vertx.reactivex.ext.auth.sqlclient that return Future

Modifier and Type	Method	Description
Future<Void>	SqlUserUtil.createHashedUser(String username, String hash)	Insert a user into a database.
Future<Void>	SqlUserUtil.createRolePermission(String role, String permission)	Insert a role permission into a database.
Future<Void>	SqlUserUtil.createUser(String username, String password)	Insert a user into a database.
Future<Void>	SqlUserUtil.createUserRole(String username, String role)	Insert a user role into a database.
Future<Void>	SqlAuthorization.getAuthorizations(User user)	Updates the user with the set of authorizations.

Uses of Future in io.vertx.reactivex.ext.auth.webauthn4j

Methods in io.vertx.reactivex.ext.auth.webauthn4j that return Future

Modifier and Type	Method	Description
Future<JsonObject>	WebAuthn4J.createCredentialsOptions(JsonObject user)	Gets a challenge and any other parameters for the navigator.credentials.create() call.
Future<List<Authenticator>>	CredentialStorage.find(String userName, String credentialId)	Finds an existing list of credentials for a given user name and credential ID.
Future<JsonObject>	WebAuthn4J.getCredentialsOptions(String username)	Creates an assertion challenge and any other parameters for the navigator.credentials.get() call.
Future<Void>	CredentialStorage.storeCredential(Authenticator authenticator)	Persists a new credential, bound by its user name (may be null) and credential ID (cannot be null, must be unique).
Future<Void>	CredentialStorage.updateCounter(Authenticator authenticator)	Updates a previously stored credential counter, as identified by its user name (may be null) and credential ID (cannot be null, must be unique).

Uses of Future in io.vertx.reactivex.ext.bridge

Methods in io.vertx.reactivex.ext.bridge that return Future

Modifier and Type	Method	Description
Future<Boolean>	BaseBridgeEvent.future()

Uses of Future in io.vertx.reactivex.ext.consul

Methods in io.vertx.reactivex.ext.consul that return Future

Modifier and Type	Method	Description
Future<JsonObject>	ConsulClient.agentInfo()	Returns the configuration and member information of the local agent
Future<List<String>>	ConsulClient.catalogDatacenters()	Return all the datacenters that are known by the Consul server
Future<NodeList>	ConsulClient.catalogNodes()	Returns the nodes registered in a datacenter
Future<ServiceList>	ConsulClient.catalogNodeServices(String node)	Returns the node's registered services
Future<ServiceList>	ConsulClient.catalogNodeServicesWithOptions(String node, BlockingQueryOptions options)	Returns the node's registered services This is blocking query unlike ConsulClient.catalogNodeServices(String)
Future<NodeList>	ConsulClient.catalogNodesWithOptions(NodeQueryOptions options)	Returns the nodes registered in a datacenter
Future<ServiceList>	ConsulClient.catalogServiceNodes(String service)	Returns the nodes providing a service
Future<ServiceList>	ConsulClient.catalogServiceNodesWithOptions(String service, ServiceQueryOptions options)	Returns the nodes providing a service
Future<ServiceList>	ConsulClient.catalogServices()	Returns the services registered in a datacenter
Future<ServiceList>	ConsulClient.catalogServicesWithOptions(BlockingQueryOptions options)	Returns the services registered in a datacenter This is blocking query unlike ConsulClient.catalogServices()
Future<AclToken>	ConsulClient.cloneAclToken(String accessorId, CloneAclTokenOptions cloneAclTokenOptions)	Clones an existing ACL token
Future<List<DcCoordinates>>	ConsulClient.coordinateDatacenters()	Returns the WAN network coordinates for all Consul servers, organized by DCs
Future<CoordinateList>	ConsulClient.coordinateNodes()	Returns the LAN network coordinates for all nodes in a given DC
Future<CoordinateList>	ConsulClient.coordinateNodesWithOptions(BlockingQueryOptions options)	Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike ConsulClient.coordinateNodes()
Future<String>	ConsulClient.createAclPolicy(AclPolicy policy)	Creates a new ACL policy
Future<AclToken>	ConsulClient.createAclToken(AclToken token)	Create an Acl token
Future<String>	ConsulClient.createPreparedQuery(PreparedQueryDefinition definition)
Future<String>	ConsulClient.createSession()	Initialize a new session
Future<String>	ConsulClient.createSessionWithOptions(SessionOptions options)	Initialize a new session
Future<Boolean>	ConsulClient.deleteAclToken(String accessorId)	Deletes an ACL token
Future<Boolean>	ConsulClient.deletePolicy(String id)	This endpoint deletes an ACL policy
Future<Void>	ConsulClient.deletePreparedQuery(String id)	Deletes an existing prepared query
Future<Void>	ConsulClient.deleteValue(String key)	Remove the key/value pair that corresponding to the specified key
Future<Void>	ConsulClient.deleteValues(String keyPrefix)	Removes all the key/value pair that corresponding to the specified key prefix
Future<Void>	ConsulClient.deregisterCatalogService(String nodeId, String serviceId)	Deregister entities from the node or deregister the node itself.
Future<Void>	ConsulClient.deregisterCheck(String checkId)	Remove a check from the local agent.
Future<Void>	ConsulClient.deregisterService(String id)	Remove a service from the local agent.
Future<Void>	ConsulClient.destroySession(String id)	Destroys the given session
Future<PreparedQueryExecuteResponse>	ConsulClient.executePreparedQuery(String query)	Executes an existing prepared query.
Future<PreparedQueryExecuteResponse>	ConsulClient.executePreparedQueryWithOptions(String query, PreparedQueryExecuteOptions options)	Executes an existing prepared query.
Future<Void>	ConsulClient.failCheck(String checkId)	Set status of the check to "critical".
Future<Void>	ConsulClient.failCheckWithNote(String checkId, String note)	Set status of the check to "critical".
Future<Event>	ConsulClient.fireEvent(String name)	Fires a new user event
Future<Event>	ConsulClient.fireEventWithOptions(String name, EventOptions options)	Fires a new user event
Future<List<AclPolicy>>	ConsulClient.getAclPolicies()	This endpoint lists all the ACL policies.
Future<List<AclToken>>	ConsulClient.getAclTokens()	Get list of Acl token
Future<List<PreparedQueryDefinition>>	ConsulClient.getAllPreparedQueries()	Returns a list of all prepared queries.
Future<List<String>>	ConsulClient.getKeys(String keyPrefix)	Returns the list of keys that corresponding to the specified key prefix.
Future<List<String>>	ConsulClient.getKeysWithOptions(String keyPrefix, BlockingQueryOptions options)	Returns the list of keys that corresponding to the specified key prefix.
Future<PreparedQueryDefinition>	ConsulClient.getPreparedQuery(String id)	Returns an existing prepared query
Future<KeyValue>	ConsulClient.getValue(String key)	Returns key/value pair that corresponding to the specified key.
Future<KeyValueList>	ConsulClient.getValues(String keyPrefix)	Returns the list of key/value pairs that corresponding to the specified key prefix.
Future<KeyValueList>	ConsulClient.getValuesWithOptions(String keyPrefix, BlockingQueryOptions options)	Returns the list of key/value pairs that corresponding to the specified key prefix.
Future<KeyValue>	ConsulClient.getValueWithOptions(String key, BlockingQueryOptions options)	Returns key/value pair that corresponding to the specified key.
Future<CheckList>	ConsulClient.healthChecks(String service)	Returns the checks associated with the service
Future<CheckList>	ConsulClient.healthChecksWithOptions(String service, CheckQueryOptions options)	Returns the checks associated with the service
Future<CheckList>	ConsulClient.healthNodesWithOptions(String node, CheckQueryOptions options)	Returns the checks specific to the node provided on the path.
Future<ServiceEntryList>	ConsulClient.healthServiceNodes(String service, boolean passing)	Returns the nodes providing the service.
Future<ServiceEntryList>	ConsulClient.healthServiceNodesWithOptions(String service, boolean passing, ServiceQueryOptions options)	Returns the nodes providing the service.
Future<CheckList>	ConsulClient.healthState(HealthState healthState)	Returns the checks in the specified status
Future<CheckList>	ConsulClient.healthStateWithOptions(HealthState healthState, CheckQueryOptions options)	Returns the checks in the specified status
Future<Session>	ConsulClient.infoSession(String id)	Returns the requested session information
Future<Session>	ConsulClient.infoSessionWithOptions(String id, BlockingQueryOptions options)	Returns the requested session information This is blocking query unlike ConsulClient.infoSession(String)
Future<String>	ConsulClient.leaderStatus()	Get the Raft leader for the datacenter in which the agent is running.
Future<EventList>	ConsulClient.listEvents()	Returns the most recent events known by the agent
Future<EventList>	ConsulClient.listEventsWithOptions(EventListOptions options)	Returns the most recent events known by the agent.
Future<SessionList>	ConsulClient.listNodeSessions(String nodeId)	Returns the active sessions for a given node
Future<SessionList>	ConsulClient.listNodeSessionsWithOptions(String nodeId, BlockingQueryOptions options)	Returns the active sessions for a given node This is blocking query unlike ConsulClient.listNodeSessions(String)
Future<SessionList>	ConsulClient.listSessions()	Returns the active sessions
Future<SessionList>	ConsulClient.listSessionsWithOptions(BlockingQueryOptions options)	Returns the active sessions This is blocking query unlike ConsulClient.listSessions()
Future<List<Check>>	ConsulClient.localChecks()	Return all the checks that are registered with the local agent.
Future<List<Service>>	ConsulClient.localServices()	Returns list of services registered with the local agent.
Future<Void>	ConsulClient.maintenanceService(MaintenanceOptions maintenanceOptions)	Places a given service into "maintenance mode"
Future<Void>	ConsulClient.passCheck(String checkId)	Set status of the check to "passing".
Future<Void>	ConsulClient.passCheckWithNote(String checkId, String note)	Set status of the check to "passing".
Future<List<String>>	ConsulClient.peersStatus()	Retrieves the Raft peers for the datacenter in which the the agent is running.
Future<Boolean>	ConsulClient.putValue(String key, String value)	Adds specified key/value pair
Future<Boolean>	ConsulClient.putValueWithOptions(String key, String value, KeyValueOptions options)
Future<AclToken>	ConsulClient.readAclToken(String accessorId)	Reads an ACL token with the given Accessor ID
Future<AclPolicy>	ConsulClient.readPolicy(String id)	This endpoint reads an ACL policy with the given ID
Future<AclPolicy>	ConsulClient.readPolicyByName(String name)	This endpoint reads an ACL policy with the given name
Future<Void>	ConsulClient.registerCatalogService(Node nodeOptions, ServiceOptions serviceOptions)	Register node with external service
Future<Void>	ConsulClient.registerCheck(CheckOptions checkOptions)	Add a new check to the local agent.
Future<Void>	ConsulClient.registerService(ServiceOptions serviceOptions)	Adds a new service, with an optional health check, to the local agent.
Future<Session>	ConsulClient.renewSession(String id)	Renews the given session.
Future<TxnResponse>	ConsulClient.transaction(TxnRequest request)	Manages multiple operations inside a single, atomic transaction.
Future<AclToken>	ConsulClient.updateAclToken(String accessorId, AclToken token)	Update an existing Acl token
Future<Void>	ConsulClient.updateCheck(String checkId, CheckStatus status)	Set status of the check to given status.
Future<Void>	ConsulClient.updateCheckWithNote(String checkId, CheckStatus status, String note)	Set status of the check to given status.
Future<AclPolicy>	ConsulClient.updatePolicy(String id, AclPolicy policy)	This endpoint updates an existing ACL policy
Future<Void>	ConsulClient.updatePreparedQuery(PreparedQueryDefinition definition)
Future<Void>	ConsulClient.warnCheck(String checkId)	Set status of the check to "warning".
Future<Void>	ConsulClient.warnCheckWithNote(String checkId, String note)	Set status of the check to "warning".

Uses of Future in io.vertx.reactivex.ext.eventbus.bridge.tcp

Methods in io.vertx.reactivex.ext.eventbus.bridge.tcp that return Future

Modifier and Type	Method	Description
Future<Void>	TcpEventBusBridge.close()	Close the current socket.
Future<Boolean>	BridgeEvent.future()
Future<TcpEventBusBridge>	TcpEventBusBridge.listen()	Start listening on the port and host as configured in the NetServerOptions used when creating the server.
Future<TcpEventBusBridge>	TcpEventBusBridge.listen(int port)	Start listening on the specified port and host "0.0.0.0", ignoring port and host configured in the NetServerOptions used when creating the server.
Future<TcpEventBusBridge>	TcpEventBusBridge.listen(int port, String address)	Start listening on the specified port and host, ignoring port and host configured in the NetServerOptions used when creating the server.
Future<TcpEventBusBridge>	TcpEventBusBridge.listen(SocketAddress localAddress)	Start listening on the specified local address, ignoring port and host configured in the used when creating the server.

Uses of Future in io.vertx.reactivex.ext.healthchecks

Methods in io.vertx.reactivex.ext.healthchecks that return Future

Modifier and Type	Method	Description
Future<CheckResult>	HealthChecks.checkStatus()	Invokes the registered procedures.
Future<CheckResult>	HealthChecks.checkStatus(String name)	Invokes the registered procedure with the given name and sub-procedures.
Future<JsonObject>	HealthChecks.invoke(String name)	Invokes the registered procedure with the given name and sub-procedures.

Uses of Future in io.vertx.reactivex.ext.mail

Methods in io.vertx.reactivex.ext.mail that return Future

Modifier and Type	Method	Description
Future<Void>	MailClient.close()	Close the MailClient
Future<MailResult>	MailClient.sendMail(MailMessage email)	send a single mail via MailClient

Method parameters in io.vertx.reactivex.ext.mail with type arguments of type Future

Modifier and Type	Method	Description
MailClientBuilder	MailClientBuilder.withCredentialsSupplier(Supplier<Future<UsernamePasswordCredentials>> credentialsSupplier)	Set a credentials supplier for the mail client.

Uses of Future in io.vertx.reactivex.ext.mongo

Methods in io.vertx.reactivex.ext.mongo that return Future

Modifier and Type	Method	Description
Future<MongoClientBulkWriteResult>	MongoClient.bulkWrite(String collection, List<BulkOperation> operations)	Execute a bulk operation.
Future<MongoClientBulkWriteResult>	MongoClient.bulkWriteWithOptions(String collection, List<BulkOperation> operations, BulkWriteOptions bulkWriteOptions)	Execute a bulk operation with the specified write options.
Future<Void>	MongoClient.close()	Close the client and release its resources
Future<Long>	MongoClient.count(String collection, JsonObject query)	Count matching documents in a collection.
Future<Long>	MongoClient.countWithOptions(String collection, JsonObject query, CountOptions countOptions)	Count matching documents in a collection.
Future<Void>	MongoClient.createCollection(String collectionName)	Create a new collection
Future<Void>	MongoClient.createCollectionWithOptions(String collectionName, CreateCollectionOptions collectionOptions)	Create a new collection with options
Future<MongoGridFsClient>	MongoClient.createDefaultGridFsBucketService()	Creates a MongoGridFsClient used to interact with Mongo GridFS.
Future<MongoGridFsClient>	MongoClient.createGridFsBucketService(String bucketName)	Creates a MongoGridFsClient used to interact with Mongo GridFS.
Future<Void>	MongoClient.createIndex(String collection, JsonObject key)	Creates an index.
Future<Void>	MongoClient.createIndexes(String collection, List<IndexModel> indexes)	creates an indexes
Future<Void>	MongoClient.createIndexWithOptions(String collection, JsonObject key, IndexOptions options)	Creates an index.
Future<Void>	MongoGridFsClient.delete(String id)	Deletes a file by it's ID
Future<JsonArray>	MongoClient.distinct(String collection, String fieldName, String resultClassname)	Gets the distinct values of the specified field name.
Future<JsonArray>	MongoClient.distinct(String collection, String fieldName, String resultClassname, DistinctOptions distinctOptions)	Gets the distinct values of the specified field name.
Future<JsonArray>	MongoClient.distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query)	Gets the distinct values of the specified field name filtered by specified query.
Future<JsonArray>	MongoClient.distinctWithQuery(String collection, String fieldName, String resultClassname, JsonObject query, DistinctOptions distinctOptions)	Gets the distinct values of the specified field name filtered by specified query.
Future<Long>	MongoGridFsClient.downloadByFileName(WriteStream<Buffer> stream, String fileName)
Future<Long>	MongoGridFsClient.downloadByFileNameWithOptions(WriteStream<Buffer> stream, String fileName, GridFsDownloadOptions options)
Future<Long>	MongoGridFsClient.downloadById(WriteStream<Buffer> stream, String id)
Future<Long>	MongoGridFsClient.downloadFile(String fileName)	Downloads a file.
Future<Long>	MongoGridFsClient.downloadFileAs(String fileName, String newFileName)	Downloads a file and gives it a new name.
Future<Long>	MongoGridFsClient.downloadFileByID(String id, String fileName)	Downloads a file using the ID generated by GridFs.
Future<Void>	MongoGridFsClient.drop()	Drops the entire file bucket with all of its contents
Future<Void>	MongoClient.dropCollection(String collection)	Drop a collection
Future<Void>	MongoClient.dropIndex(String collection, JsonObject key)	Drops the index given the keys used to create it.
Future<Void>	MongoClient.dropIndex(String collection, String indexName)	Drops the index given its name.
Future<List<JsonObject>>	MongoClient.find(String collection, JsonObject query)	Find matching documents in the specified collection
Future<List<String>>	MongoGridFsClient.findAllIds()	Finds all file ids in the bucket
Future<List<String>>	MongoGridFsClient.findIds(JsonObject query)	Finds all file ids that match a query.
Future<JsonObject>	MongoClient.findOne(String collection, JsonObject query, JsonObject fields)	Find a single matching document in the specified collection
Future<JsonObject>	MongoClient.findOneAndDelete(String collection, JsonObject query)	Find a single matching document in the specified collection and delete it.
Future<JsonObject>	MongoClient.findOneAndDeleteWithOptions(String collection, JsonObject query, FindOptions findOptions)	Find a single matching document in the specified collection and delete it.
Future<JsonObject>	MongoClient.findOneAndReplace(String collection, JsonObject query, JsonObject replace)	Find a single matching document in the specified collection and replace it.
Future<JsonObject>	MongoClient.findOneAndReplaceWithOptions(String collection, JsonObject query, JsonObject replace, FindOptions findOptions, UpdateOptions updateOptions)	Find a single matching document in the specified collection and replace it.
Future<JsonObject>	MongoClient.findOneAndUpdate(String collection, JsonObject query, JsonObject update)	Find a single matching document in the specified collection and update it.
Future<JsonObject>	MongoClient.findOneAndUpdateWithOptions(String collection, JsonObject query, JsonObject update, FindOptions findOptions, UpdateOptions updateOptions)	Find a single matching document in the specified collection and update it.
Future<List<JsonObject>>	MongoClient.findWithOptions(String collection, JsonObject query, FindOptions options)	Find matching documents in the specified collection, specifying options
Future<List<String>>	MongoClient.getCollections()	Get a list of all collections in the database.
Future<String>	MongoClient.insert(String collection, JsonObject document)	Insert a document in the specified collection
Future<String>	MongoClient.insertWithOptions(String collection, JsonObject document, WriteOption writeOption)	Insert a document in the specified collection with the specified write option
Future<JsonArray>	MongoClient.listIndexes(String collection)	Get all the indexes in this collection.
Future<MongoClientDeleteResult>	MongoClient.removeDocument(String collection, JsonObject query)	Remove a single matching document from a collection and return the handler with MongoClientDeleteResult result
Future<MongoClientDeleteResult>	MongoClient.removeDocuments(String collection, JsonObject query)	Remove matching documents from a collection and return the handler with MongoClientDeleteResult result
Future<MongoClientDeleteResult>	MongoClient.removeDocumentsWithOptions(String collection, JsonObject query, WriteOption writeOption)	Remove matching documents from a collection with the specified write option and return the handler with MongoClientDeleteResult result
Future<MongoClientDeleteResult>	MongoClient.removeDocumentWithOptions(String collection, JsonObject query, WriteOption writeOption)	Remove a single matching document from a collection with the specified write option and return the handler with MongoClientDeleteResult result
Future<Void>	MongoClient.renameCollection(String oldCollectionName, String newCollectionName)	Rename a collection
Future<Void>	MongoClient.renameCollectionWithOptions(String oldCollectionName, String newCollectionName, RenameCollectionOptions collectionOptions)	Rename a collection
Future<MongoClientUpdateResult>	MongoClient.replaceDocuments(String collection, JsonObject query, JsonObject replace)	Replace matching documents in the specified collection and return the handler with MongoClientUpdateResult result
Future<MongoClientUpdateResult>	MongoClient.replaceDocumentsWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options)	Replace matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
Future<JsonObject>	MongoClient.runCommand(String commandName, JsonObject command)	Run an arbitrary MongoDB command.
Future<String>	MongoClient.save(String collection, JsonObject document)	Save a document in the specified collection
Future<String>	MongoClient.saveWithOptions(String collection, JsonObject document, WriteOption writeOption)	Save a document in the specified collection with the specified write option
Future<MongoClientUpdateResult>	MongoClient.updateCollection(String collection, JsonObject query, JsonArray update)	Use an aggregation pipeline to update documents in the specified collection and return the handler with MongoClientUpdateResult result
Future<MongoClientUpdateResult>	MongoClient.updateCollection(String collection, JsonObject query, JsonObject update)	Update matching documents in the specified collection and return the handler with MongoClientUpdateResult result
Future<MongoClientUpdateResult>	MongoClient.updateCollectionWithOptions(String collection, JsonObject query, JsonArray update, UpdateOptions options)	Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
Future<MongoClientUpdateResult>	MongoClient.updateCollectionWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options)	Update matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
Future<String>	MongoGridFsClient.uploadByFileName(Flowable<Buffer> stream, String fileName)
Future<String>	MongoGridFsClient.uploadByFileName(ReadStream<Buffer> stream, String fileName)
Future<String>	MongoGridFsClient.uploadByFileNameWithOptions(Flowable<Buffer> stream, String fileName, GridFsUploadOptions options)
Future<String>	MongoGridFsClient.uploadByFileNameWithOptions(ReadStream<Buffer> stream, String fileName, GridFsUploadOptions options)
Future<String>	MongoGridFsClient.uploadFile(String fileName)	Upload a file to gridfs
Future<String>	MongoGridFsClient.uploadFileWithOptions(String fileName, GridFsUploadOptions options)	Upload a file to gridfs with options

Uses of Future in io.vertx.reactivex.ext.stomp

Methods in io.vertx.reactivex.ext.stomp that return Future

Modifier and Type	Method	Description
Future<Frame>	StompClientConnection.abort(String id)	Aborts a transaction.
Future<Frame>	StompClientConnection.abort(String id, Map<String,String> headers)	Aborts a transaction.
Future<Frame>	StompClientConnection.ack(String id)	Sends an acknowledgement for a specific message.
Future<Frame>	StompClientConnection.ack(String id, String txId)	Sends an acknowledgement for the given frame.
Future<Frame>	StompClientConnection.beginTX(String id)	Begins a transaction.
Future<Frame>	StompClientConnection.beginTX(String id, Map<String,String> headers)	Begins a transaction.
Future<Void>	StompClient.close()	Closes the client.
Future<Void>	StompServer.close()	Closes the server.
Future<Frame>	StompClientConnection.commit(String id)	Commits a transaction.
Future<Frame>	StompClientConnection.commit(String id, Map<String,String> headers)	Commits a transaction.
Future<StompClientConnection>	StompClient.connect()	Connects to the server using the host and port configured in the client's options.
Future<StompClientConnection>	StompClient.connect(int port, String host)	Connects to the server.
Future<Frame>	StompClientConnection.disconnect()	Disconnects the client.
Future<Frame>	StompClientConnection.disconnect(Frame frame)	Disconnects the client.
Future<StompServer>	StompServer.listen()	Connects the STOMP server default port (61613) and network interface (0.0.0.0).
Future<StompServer>	StompServer.listen(int port)	Connects the STOMP server to the given port.
Future<StompServer>	StompServer.listen(int port, String host)	Connects the STOMP server to the given port / interface.
Future<Frame>	StompClientConnection.nack(String id)	Sends a non-acknowledgement for the given message.
Future<Frame>	StompClientConnection.nack(String id, String txId)	Sends a non-acknowledgement for the given frame.
Future<Boolean>	StompServerHandler.onAuthenticationRequest(StompServerConnection connection, String login, String passcode)	Called when the client connects to a server requiring authentication.
Future<Frame>	StompClientConnection.send(Frame frame)	Sends the given frame to the server.
Future<Frame>	StompClientConnection.send(String destination, Buffer body)	Sends a SEND frame to the server to the given destination.
Future<Frame>	StompClientConnection.send(String destination, Map<String,String> headers, Buffer body)	Sends a SEND frame to the server to the given destination.
Future<Frame>	StompClientConnection.send(Map<String,String> headers, Buffer body)	Sends a SEND frame to the server.
Future<String>	StompClientConnection.subscribe(String destination, Handler<Frame> handler)	Subscribes to the given destination.
Future<String>	StompClientConnection.subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)	Subscribes to the given destination.
Future<Frame>	StompClientConnection.unsubscribe(String destination)	Un-subscribes from the given destination.
Future<Frame>	StompClientConnection.unsubscribe(String destination, Map<String,String> headers)	Un-subscribes from the given destination.

Uses of Future in io.vertx.reactivex.ext.unit.report

Methods in io.vertx.reactivex.ext.unit.report that return Future

Modifier and Type	Method	Description
Future<Void>	TestSuiteReport.pipeTo(WriteStream<TestCaseReport> dst)	Pipe this ReadStream to the WriteStream.

Uses of Future in io.vertx.reactivex.ext.web

Methods in io.vertx.reactivex.ext.web that return Future

Modifier and Type	Method	Description
Future<Void>	FileUpload.delete()	Delete the uploaded file on the disk.
Future<Void>	RoutingContext.end()	Shortcut to the response end.
Future<Void>	RoutingContext.end(Buffer buffer)	Shortcut to the response end.
Future<Void>	RoutingContext.end(String chunk)	Shortcut to the response end.
Future<Void>	UserContext.impersonate()	Impersonates a second identity.
Future<Void>	UserContext.impersonate(String redirectUri)	Impersonates a second identity.
Future<Void>	RoutingContext.json(Object json)	Encode an Object to JSON and end the request.
Future<Void>	UserContext.logout()	Logout can be called from any route handler which needs to terminate a login session.
Future<Void>	UserContext.logout(String redirectUri)	Logout can be called from any route handler which needs to terminate a login session.
Future<Void>	RoutingContext.redirect(String url)	Perform a 302 redirect to url.
Future<Void>	UserContext.refresh()	Forces the current user to re-authenticate.
Future<Void>	UserContext.refresh(String redirectUri)	Forces the current user to re-authenticate.
Future<Void>	UserContext.restore()	Undo a previous call to a impersonation.
Future<Void>	UserContext.restore(String redirectUri)	Undo a previous call to an impersonation.

Method parameters in io.vertx.reactivex.ext.web with type arguments of type Future

Modifier and Type	Method	Description
<T> Route	Route.respond(Function<RoutingContext, Future<T>> function)	Append a function request handler to the route handlers list.

Uses of Future in io.vertx.reactivex.ext.web.client

Methods in io.vertx.reactivex.ext.web.client that return Future

Modifier and Type	Method	Description
Future<HttpResponse<T>>	HttpRequest.send()	Send a request, the handler will receive the response as an HttpResponse.
Future<HttpResponse<T>>	HttpRequest.sendBuffer(Buffer body)	Like HttpRequest.send() but with an HTTP request body buffer.
Future<HttpResponse<T>>	HttpRequest.sendForm(MultiMap body)	Like HttpRequest.send() but with an HTTP request body multimap encoded as form and the content type set to application/x-www-form-urlencoded.
Future<HttpResponse<T>>	HttpRequest.sendForm(MultiMap body, String charset)	Like HttpRequest.send() but with an HTTP request body multimap encoded as form and the content type set to application/x-www-form-urlencoded.
Future<HttpResponse<T>>	HttpRequest.sendJson(Object body)	Like HttpRequest.send() but with an HTTP request body object encoded as json and the content type set to application/json.
Future<HttpResponse<T>>	HttpRequest.sendJsonObject(JsonObject body)	Like HttpRequest.send() but with an HTTP request body object encoded as json and the content type set to application/json.
Future<HttpResponse<T>>	HttpRequest.sendMultipartForm(MultipartForm body)	Like HttpRequest.send() but with an HTTP request body multimap encoded as form and the content type set to multipart/form-data.
Future<HttpResponse<T>>	HttpRequest.sendStream(Flowable<Buffer> body)	Like HttpRequest.send() but with an HTTP request body stream.
Future<HttpResponse<T>>	HttpRequest.sendStream(ReadStream<Buffer> body)	Like HttpRequest.send() but with an HTTP request body stream.
Future<Boolean>	WebClient.updateSSLOptions(ClientSSLOptions options)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.
Future<Boolean>	WebClient.updateSSLOptions(ClientSSLOptions options, boolean force)	Update the client with new SSL options, the update happens if the options object is valid and different from the existing options object.

Uses of Future in io.vertx.reactivex.ext.web.common.template

Methods in io.vertx.reactivex.ext.web.common.template that return Future

Modifier and Type	Method	Description
Future<Buffer>	TemplateEngine.render(JsonObject context, String templateFileName)	Render the template.
Future<Buffer>	TemplateEngine.render(Map<String,Object> context, String templateFileName)	Render the template.

Uses of Future in io.vertx.reactivex.ext.web.handler

Methods in io.vertx.reactivex.ext.web.handler that return Future

Modifier and Type	Method	Description
Future<Void>	SessionHandler.flush(RoutingContext ctx)	Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
Future<Void>	SessionHandler.flush(RoutingContext ctx, boolean ignoreStatus)	Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level.
Future<Void>	SessionHandler.setUser(RoutingContext context, User user)	Set the user for the session

Method parameters in io.vertx.reactivex.ext.web.handler with type arguments of type Future

Modifier and Type	Method	Description
SimpleAuthenticationHandler	SimpleAuthenticationHandler.authenticate(Function<RoutingContext, Future<User>> authenticationFunction)	This function will allow you to perform authentication the way you intended to.
APIKeyHandler	APIKeyHandler.tokenExtractor(Function<String, Future<String>> tokenExtractor)	Transform from user's token format to the AuthenticationHandler's format.

Uses of Future in io.vertx.reactivex.ext.web.handler.graphql.ws

Methods in io.vertx.reactivex.ext.web.handler.graphql.ws that return Future

Modifier and Type	Method	Description
Future<Object>	ConnectionInitEvent.future()

Uses of Future in io.vertx.reactivex.ext.web.handler.sockjs

Methods in io.vertx.reactivex.ext.web.handler.sockjs that return Future

Modifier and Type	Method	Description
Future<Void>	SockJSSocket.end()	Call SockJSSocket.close().
Future<Void>	SockJSSocket.end(Buffer data)	Same as SockJSSocket.end(Buffer) but writes some data to the stream before ending.
Future<Boolean>	BridgeEvent.future()
Future<Void>	SockJSSocket.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	SockJSSocket.write(Buffer data)
Future<Void>	SockJSSocket.write(String data)	Write a String to the socket, encoded in UTF-8.

Uses of Future in io.vertx.reactivex.ext.web.healthchecks

Method parameters in io.vertx.reactivex.ext.web.healthchecks with type arguments of type Future

Modifier and Type	Method	Description
HealthCheckHandler	HealthCheckHandler.resultMapper(Function<CheckResult, Future<CheckResult>> resultMapper)	Sets a function which will be invoked before the gets written to clients.

Uses of Future in io.vertx.reactivex.ext.web.openapi.router

Methods in io.vertx.reactivex.ext.web.openapi.router that return Future

Modifier and Type	Method	Description
Future<ValidatableRequest>	RequestExtractor.extractValidatableRequest(RoutingContext routingContext, Operation operation)	Extracts and transforms the parameters and the body of an incoming request into a that can be validated by the RequestValidator.
Future<RouterBuilder>	Security.openIdConnectHandler(Function<String, Single<OAuth2AuthHandler>> factory)	Configure the to be used when creating the router.
Future<RouterBuilder>	Security.openIdConnectHandler(String callback, Function<String, Single<OAuth2AuthHandler>> factory)	Configure the to be used when creating the router.
Future<RouterBuilder>	Security.openIdConnectHandler(String callback, Function<String, Future<OAuth2AuthHandler>> factory)	Configure the to be used when creating the router.
Future<RouterBuilder>	Security.openIdConnectHandler(Function<String, Future<OAuth2AuthHandler>> factory)	Configure the to be used when creating the router.

Method parameters in io.vertx.reactivex.ext.web.openapi.router with type arguments of type Future

Modifier and Type	Method	Description
Future<RouterBuilder>	Security.openIdConnectHandler(String callback, Function<String, Future<OAuth2AuthHandler>> factory)	Configure the to be used when creating the router.
Future<RouterBuilder>	Security.openIdConnectHandler(Function<String, Future<OAuth2AuthHandler>> factory)	Configure the to be used when creating the router.
Single<RouterBuilder>	Security.rxOpenIdConnectHandler(String callback, Function<String, Future<OAuth2AuthHandler>> factory)	Configure the to be used when creating the router.
Single<RouterBuilder>	Security.rxOpenIdConnectHandler(Function<String, Future<OAuth2AuthHandler>> factory)	Configure the to be used when creating the router.

Uses of Future in io.vertx.reactivex.ext.web.sstore

Methods in io.vertx.reactivex.ext.web.sstore that return Future

Modifier and Type	Method	Description
Future<Void>	SessionStore.clear()	Remove all sessions from the store.
Future<Void>	SessionStore.delete(String id)	Delete the session with the specified ID.
Future<Session>	SessionStore.get(String cookieValue)	Get the session with the specified ID.
Future<Void>	SessionStore.put(Session session)	Add a session with the specified ID.
Future<Integer>	SessionStore.size()	Get the number of sessions in the store.

Uses of Future in io.vertx.reactivex.grpc.client

Methods in io.vertx.reactivex.grpc.client that return Future

Modifier and Type	Method	Description
Future<Void>	GrpcClient.close()	Close this client.
Future<Void>	GrpcClientRequest.end()	Ends the stream.
Future<Void>	GrpcClientRequest.end(Req data)	Same as WriteStream.end() but writes some data to the stream before ending.
<Req,Resp> Future<GrpcClientRequest<Req,Resp>>	ServiceInvoker.invoker(ServiceMethod<Resp,Req> method)	Create a request for the given service method.
Future<Resp>	GrpcClientResponse.last()
Future<Void>	GrpcClientResponse.pipeTo(WriteStream<Resp> dst)	Pipe this ReadStream to the WriteStream.
Future<GrpcClientRequest<Buffer,Buffer>>	GrpcClient.request()	Like GrpcClient.request(Address) with the default remote server.
Future<GrpcClientRequest<Buffer,Buffer>>	GrpcClient.request(Address server)	Connect to the remote server and create a request for any hosted gRPC service.
<Req,Resp> Future<GrpcClientRequest<Req,Resp>>	GrpcClient.request(Address server, ServiceMethod<Resp,Req> method)	Connect to the remote server and create a request for any hosted gRPC service.
<Req,Resp> Future<GrpcClientRequest<Req,Resp>>	GrpcClient.request(ServiceMethod<Resp,Req> method)	Like GrpcClient.request(Address) with the default remote server.
Future<GrpcClientResponse<Req,Resp>>	GrpcClientRequest.response()
Future<GrpcClientResponse<Req,Resp>>	GrpcClientRequest.send(Flowable<Req> body)
Future<GrpcClientResponse<Req,Resp>>	GrpcClientRequest.send(ReadStream<Req> body)
Future<GrpcClientResponse<Req,Resp>>	GrpcClientRequest.send(Req item)
Future<Void>	GrpcClientRequest.write(Req data)	Write some data to the stream.

Uses of Future in io.vertx.reactivex.grpc.common

Methods in io.vertx.reactivex.grpc.common that return Future

Modifier and Type	Method	Description
Future<Void>	GrpcReadStream.end()
Future<Void>	GrpcWriteStream.end()	Ends the stream.
Future<Void>	GrpcWriteStream.end(T data)	Same as WriteStream.end() but writes some data to the stream before ending.
Future<Void>	GrpcWriteStream.endMessage(GrpcMessage message)	End the stream with an encoded gRPC message.
Future<T>	GrpcReadStream.last()
Future<Void>	GrpcReadStream.pipeTo(WriteStream<T> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	GrpcWriteStream.write(T data)	Write some data to the stream.
Future<Void>	GrpcWriteStream.writeMessage(GrpcMessage message)	Write an encoded gRPC message.

Uses of Future in io.vertx.reactivex.grpc.server

Methods in io.vertx.reactivex.grpc.server that return Future

Modifier and Type	Method	Description
Future<Void>	GrpcServerResponse.end()	Ends the stream.
Future<Void>	GrpcServerResponse.end(Resp data)	Same as WriteStream.end() but writes some data to the stream before ending.
Future<Req>	GrpcServerRequest.last()
Future<Void>	GrpcServerRequest.pipeTo(WriteStream<Req> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	GrpcServerResponse.send(Flowable<Resp> body)
Future<Void>	GrpcServerResponse.send(ReadStream<Resp> body)
Future<Void>	GrpcServerResponse.send(Resp item)
Future<Void>	GrpcServerResponse.write(Resp data)	Write some data to the stream.
Future<Void>	GrpcServerResponse.writeHead()	Send the response headers.

Uses of Future in io.vertx.reactivex.jdbcclient

Methods in io.vertx.reactivex.jdbcclient that return Future

Modifier and Type	Method	Description
Future<Integer>	JDBCConnection.getTransactionIsolation()
Future<Void>	JDBCConnection.setTransactionIsolation(int isolationLevel)

Uses of Future in io.vertx.reactivex.kafka.admin

Methods in io.vertx.reactivex.kafka.admin that return Future

Modifier and Type	Method	Description
Future<Void>	KafkaAdminClient.close()	Close the admin client
Future<Void>	KafkaAdminClient.close(long timeout)	Close the admin client
Future<List<org.apache.kafka.common.acl.AclBinding>>	KafkaAdminClient.createAcls(List<org.apache.kafka.common.acl.AclBinding> aclBindings)	Create the ACL rules.
Future<Void>	KafkaAdminClient.createPartitions(Map<String, NewPartitions> partitions)	Creates a batch of new partitions in the Kafka topic
Future<Void>	KafkaAdminClient.createTopics(List<NewTopic> topics)	Creates a batch of new Kafka topics
Future<List<org.apache.kafka.common.acl.AclBinding>>	KafkaAdminClient.deleteAcls(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings)	Delete the ACL rules.
Future<Void>	KafkaAdminClient.deleteConsumerGroupOffsets(String groupId, Set<TopicPartition> partitions)	Delete committed offsets for a set of partitions in a consumer group.
Future<Void>	KafkaAdminClient.deleteConsumerGroups(List<String> groupIds)	Delete consumer groups from the cluster.
Future<Void>	KafkaAdminClient.deleteTopics(List<String> topicNames)	Deletes a batch of Kafka topics
Future<List<org.apache.kafka.common.acl.AclBinding>>	KafkaAdminClient.describeAcls(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter)	Describe the ACL rules.
Future<ClusterDescription>	KafkaAdminClient.describeCluster()	Describe the nodes in the cluster with the default options
Future<ClusterDescription>	KafkaAdminClient.describeCluster(DescribeClusterOptions options)	Like KafkaAdminClient.describeCluster() but allows customized options.
Future<Map<String, ConsumerGroupDescription>>	KafkaAdminClient.describeConsumerGroups(List<String> groupIds)	Describe some group ids in the cluster, with the default options
Future<Map<String, ConsumerGroupDescription>>	KafkaAdminClient.describeConsumerGroups(List<String> groupIds, DescribeConsumerGroupsOptions options)	Like KafkaAdminClient.describeConsumerGroups(List) but allows customized options
Future<Map<String, TopicDescription>>	KafkaAdminClient.describeTopics(List<String> topicNames)	Describe some topics in the cluster, with the default options.
Future<Map<String, TopicDescription>>	KafkaAdminClient.describeTopics(List<String> topicNames, DescribeTopicsOptions options)	Like KafkaAdminClient.describeTopics(List) but allows for customised otions
Future<List<ConsumerGroupListing>>	KafkaAdminClient.listConsumerGroups()	Get the the consumer groups available in the cluster with the default options
Future<Set<String>>	KafkaAdminClient.listTopics()	List the topics available in the cluster with the default options.

Uses of Future in io.vertx.reactivex.kafka.client.consumer

Methods in io.vertx.reactivex.kafka.client.consumer that return Future

Modifier and Type	Method	Description
Future<Void>	KafkaConsumer.assign(TopicPartition topicPartition)	Manually assign a partition to this consumer.
Future<Void>	KafkaConsumer.assign(Set<TopicPartition> topicPartitions)	Manually assign a list of partition to this consumer.
Future<Set<TopicPartition>>	KafkaConsumer.assignment()	Get the set of partitions currently assigned to this consumer.
Future<Long>	KafkaConsumer.beginningOffsets(TopicPartition topicPartition)	Get the first offset for the given partitions.
Future<Void>	KafkaConsumer.close()	Close the consumer
Future<Void>	KafkaConsumer.commit()	Commit current offsets for all the subscribed list of topics and partition.
Future<OffsetAndMetadata>	KafkaConsumer.committed(TopicPartition topicPartition)	Get the last committed offset for the given partition (whether the commit happened by this process or another).
Future<Long>	KafkaConsumer.endOffsets(TopicPartition topicPartition)	Get the last offset for the given partition.
Future<OffsetAndTimestamp>	KafkaConsumer.offsetsForTimes(TopicPartition topicPartition, Long timestamp)	Look up the offset for the given partition by timestamp.
Future<List<PartitionInfo>>	KafkaConsumer.partitionsFor(String topic)	Get metadata about the partitions for a given topic.
Future<Void>	KafkaConsumer.pause(TopicPartition topicPartition)	Suspend fetching from the requested partition.
Future<Void>	KafkaConsumer.pause(Set<TopicPartition> topicPartitions)	Suspend fetching from the requested partitions.
Future<Set<TopicPartition>>	KafkaConsumer.paused()	Get the set of partitions that were previously paused by a call to pause(Set).
Future<Void>	KafkaConsumer.pipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst)	Pipe this ReadStream to the WriteStream.
Future<KafkaConsumerRecords<K,V>>	KafkaConsumer.poll(Duration timeout)	Executes a poll for getting messages from Kafka.
Future<Long>	KafkaConsumer.position(TopicPartition partition)	Get the offset of the next record that will be fetched (if a record with that offset exists).
Future<Void>	KafkaConsumer.resume(TopicPartition topicPartition)	Resume specified partition which have been paused with pause.
Future<Void>	KafkaConsumer.resume(Set<TopicPartition> topicPartitions)	Resume specified partitions which have been paused with pause.
Future<Void>	KafkaConsumer.seek(TopicPartition topicPartition, long offset)	Overrides the fetch offsets that the consumer will use on the next poll.
Future<Void>	KafkaConsumer.seek(TopicPartition topicPartition, OffsetAndMetadata offsetAndMetadata)	Overrides the fetch offsets that the consumer will use on the next poll.
Future<Void>	KafkaConsumer.seekToBeginning(TopicPartition topicPartition)	Seek to the first offset for each of the given partition.
Future<Void>	KafkaConsumer.seekToBeginning(Set<TopicPartition> topicPartitions)	Seek to the first offset for each of the given partitions.
Future<Void>	KafkaConsumer.seekToEnd(TopicPartition topicPartition)	Seek to the last offset for each of the given partition.
Future<Void>	KafkaConsumer.seekToEnd(Set<TopicPartition> topicPartitions)	Seek to the last offset for each of the given partitions.
Future<Void>	KafkaConsumer.subscribe(String topic)	Subscribe to the given topic to get dynamically assigned partitions.
Future<Void>	KafkaConsumer.subscribe(Pattern pattern)	Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
Future<Void>	KafkaConsumer.subscribe(Set<String> topics)	Subscribe to the given list of topics to get dynamically assigned partitions.
Future<Set<String>>	KafkaConsumer.subscription()	Get the current subscription.
Future<Void>	KafkaConsumer.unsubscribe()	Unsubscribe from topics currently subscribed with subscribe.

Uses of Future in io.vertx.reactivex.kafka.client.producer

Methods in io.vertx.reactivex.kafka.client.producer that return Future

Modifier and Type	Method	Description
Future<Void>	KafkaProducer.abortTransaction()	Aborts the ongoing transaction.
Future<Void>	KafkaProducer.beginTransaction()	Starts a new kafka transaction.
Future<Void>	KafkaProducer.close()	Close the producer
Future<Void>	KafkaProducer.close(long timeout)	Close the producer
Future<Void>	KafkaProducer.commitTransaction()	Commits the ongoing transaction.
Future<Void>	KafkaProducer.end()	Ends the stream.
Future<Void>	KafkaProducer.end(KafkaProducerRecord<K,V> data)	Same as WriteStream.end() but writes some data to the stream before ending.
Future<Void>	KafkaProducer.flush()	Invoking this method makes all buffered records immediately available to write
Future<Void>	KafkaProducer.initTransactions()	Initializes the underlying kafka transactional producer.
Future<List<PartitionInfo>>	KafkaProducer.partitionsFor(String topic)	Get the partition metadata for the give topic.
Future<RecordMetadata>	KafkaProducer.send(KafkaProducerRecord<K,V> record)	Asynchronously write a record to a topic
Future<Void>	KafkaProducer.write(KafkaProducerRecord<K,V> data)	Write some data to the stream.

Uses of Future in io.vertx.reactivex.mqtt

Methods in io.vertx.reactivex.mqtt that return Future

Modifier and Type	Method	Description
Future<Void>	MqttClient.authenticationExchange(MqttAuthenticationExchangeMessage message)	It is used for Enhanced Authentication and is able to carry an authentication method and authentication data.
Future<Void>	MqttServer.close()	Close the server.
Future<MqttConnAckMessage>	MqttClient.connect(int port, String host)	Connects to an MQTT server calling connectHandler after connection
Future<MqttConnAckMessage>	MqttClient.connect(int port, String host, String serverName)	Connects to an MQTT server calling connectHandler after connection
Future<Void>	MqttClient.disconnect()	Disconnects from the MQTT server
Future<MqttServer>	MqttServer.listen()	Start the server listening for incoming connections using the specified options through the constructor
Future<MqttServer>	MqttServer.listen(int port)	Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
Future<MqttServer>	MqttServer.listen(int port, String host)	Start the server listening for incoming connections on the port and host specified
Future<Integer>	MqttClient.publish(int id, String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain)	Sends the PUBLISH message to the remote MQTT server
Future<Integer>	MqttClient.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain)	Sends the PUBLISH message to the remote MQTT server
Future<Integer>	MqttEndpoint.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain)	Sends the PUBLISH message to the remote MQTT client
Future<Integer>	MqttEndpoint.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId)	Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
Future<Integer>	MqttEndpoint.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, MqttProperties properties)	Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
Future<Void>	MqttClient.publishRelease(int publishMessageId)	Sends the PUBREL message to the remote MQTT server.
Future<Integer>	MqttClient.subscribe(String topic, int qos)	Subscribes to the topic with a specified QoS level
Future<Integer>	MqttClient.subscribe(Map<String,Integer> topics)	Subscribes to the topics with related QoS levels
Future<Integer>	MqttClient.unsubscribe(String topic)	Unsubscribe from receiving messages on given topic
Future<Integer>	MqttClient.unsubscribe(List<String> topics)	Unsubscribe from receiving messages on given list of topic

Uses of Future in io.vertx.reactivex.mssqlclient

Methods in io.vertx.reactivex.mssqlclient that return Future

Modifier and Type	Method	Description
static Future<MSSQLConnection>	MSSQLConnection.connect(Vertx vertx, MSSQLConnectOptions connectOptions)	Create a connection to SQL Server with the given connectOptions.
static Future<MSSQLConnection>	MSSQLConnection.connect(Vertx vertx, String connectionUri)	Like MSSQLConnection.connect(Vertx, MSSQLConnectOptions) with options built from connectionUri.

Uses of Future in io.vertx.reactivex.mysqlclient

Methods in io.vertx.reactivex.mysqlclient that return Future

Modifier and Type	Method	Description
Future<Void>	MySQLConnection.changeUser(MySQLAuthOptions options)	Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
static Future<MySQLConnection>	MySQLConnection.connect(Vertx vertx, MySQLConnectOptions connectOptions)	Create a connection to MySQL server with the given connectOptions.
static Future<MySQLConnection>	MySQLConnection.connect(Vertx vertx, String connectionUri)	Like MySQLConnection.connect(Vertx, MySQLConnectOptions) with options built from connectionUri.
Future<Void>	MySQLConnection.debug()	Send a DEBUG command to dump debug information to the server's stdout.
Future<String>	MySQLConnection.getInternalStatistics()	Send a STATISTICS command to get a human readable string of the server internal status.
Future<Void>	MySQLConnection.ping()	Send a PING command to check if the server is alive.
Future<Void>	MySQLConnection.resetConnection()	Send a RESET_CONNECTION command to reset the session state.
Future<Void>	MySQLConnection.setOption(MySQLSetOption option)	Send a SET_OPTION command to set options for the current connection.
Future<Void>	MySQLConnection.specifySchema(String schemaName)	Send a INIT_DB command to change the default schema of the connection.

Uses of Future in io.vertx.reactivex.openapi.contract

Methods in io.vertx.reactivex.openapi.contract that return Future

Modifier and Type	Method	Description
static Future<OpenAPIContract>	OpenAPIContract.from(Vertx vertx, JsonObject contract)	Resolves / dereferences the passed contract and creates an OpenAPIContract instance.
static Future<OpenAPIContract>	OpenAPIContract.from(Vertx vertx, JsonObject contract, Map<String, JsonObject> additionalContractParts)	Resolves / dereferences the passed contract and creates an OpenAPIContract instance.
static Future<OpenAPIContract>	OpenAPIContract.from(Vertx vertx, String contractPath)	Resolves / dereferences the passed contract and creates an OpenAPIContract instance.
static Future<OpenAPIContract>	OpenAPIContract.from(Vertx vertx, String contractPath, Map<String,String> additionalContractPartPaths)	Resolves / dereferences the passed contract and creates an OpenAPIContract instance.

Uses of Future in io.vertx.reactivex.openapi.validation

Methods in io.vertx.reactivex.openapi.validation that return Future

Modifier and Type	Method	Description
static Future<ValidatableRequest>	ValidatableRequest.of(HttpServerRequest request, Operation operation)	Creates a new ValidatableRequest object based on the passed and .
Future<Void>	ValidatedResponse.send(HttpServerResponse serverResponse)	Add all parameters from the validated response to the passed and send it.
Future<ValidatedRequest>	RequestValidator.validate(HttpServerRequest request)	Like RequestValidator.validate(HttpServerRequest), but the operationId and ValidatableRequest are determined from the passed request.
Future<ValidatedRequest>	RequestValidator.validate(HttpServerRequest request, String operationId)	Like RequestValidator.validate(HttpServerRequest), but ValidatableRequest are directly extracted from the passed request.
Future<ValidatedRequest>	RequestValidator.validate(ValidatableRequest params, String operationId)	Validates the passed request parameters against the operation defined in the related OpenAPI contract.

Uses of Future in io.vertx.reactivex.oracleclient

Methods in io.vertx.reactivex.oracleclient that return Future

Modifier and Type	Method	Description
static Future<OracleConnection>	OracleConnection.connect(Vertx vertx, OracleConnectOptions connectOptions)	Create a connection to Oracle with the given connectOptions.
static Future<OracleConnection>	OracleConnection.connect(Vertx vertx, String connectionUri)	Like OracleConnection.connect(Vertx, OracleConnectOptions) with options built from connectionUri.

Uses of Future in io.vertx.reactivex.pgclient

Methods in io.vertx.reactivex.pgclient that return Future

Modifier and Type	Method	Description
Future<Void>	PgConnection.cancelRequest()	Send a request cancellation message to tell the server to cancel processing request in this connection.
static Future<PgConnection>	PgConnection.connect(Vertx vertx)	Like PgConnection.connect(Vertx, PgConnectOptions) with options build from the environment variables.
static Future<PgConnection>	PgConnection.connect(Vertx vertx, PgConnectOptions options)	Connects to the database and returns the connection if that succeeds.
static Future<PgConnection>	PgConnection.connect(Vertx vertx, String connectionUri)	Like PgConnection.connect(Vertx, PgConnectOptions) with options build from connectionUri.

Uses of Future in io.vertx.reactivex.pgclient.pubsub

Methods in io.vertx.reactivex.pgclient.pubsub that return Future

Modifier and Type	Method	Description
Future<Void>	PgSubscriber.close()	Close the subscriber, the retry policy will not be invoked.
Future<Void>	PgSubscriber.connect()	Connect the subscriber to Postgres.
Future<Void>	PgChannel.pipeTo(WriteStream<String> dst)	Pipe this ReadStream to the WriteStream.

Uses of Future in io.vertx.reactivex.rabbitmq

Methods in io.vertx.reactivex.rabbitmq that return Future

Modifier and Type	Method	Description
Future<ReadStream<RabbitMQConfirmation>>	RabbitMQClient.addConfirmListener(int maxQueueSize)	Add a Confirm Listener to the channel.
Future<Void>	RabbitMQClient.basicAck(long deliveryTag, boolean multiple)	Acknowledge one or several received messages.
Future<RabbitMQConsumer>	RabbitMQClient.basicConsumer(String queue)
Future<RabbitMQConsumer>	RabbitMQClient.basicConsumer(String queue, QueueOptions options)	Create a consumer with the given options.
Future<RabbitMQMessage>	RabbitMQClient.basicGet(String queue, boolean autoAck)	Retrieve a message from a queue using AMQP.Basic.Get
Future<Void>	RabbitMQClient.basicNack(long deliveryTag, boolean multiple, boolean requeue)	Reject one or several received messages.
Future<Void>	RabbitMQClient.basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)	Publish a message.
Future<Void>	RabbitMQClient.basicPublish(String exchange, String routingKey, Buffer body)	Publish a message.
Future<Void>	RabbitMQClient.basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)	Publish a message.
Future<Void>	RabbitMQClient.basicQos(int prefetchCount)	Request a specific prefetchCount "quality of service" settings for this channel.
Future<Void>	RabbitMQClient.basicQos(int prefetchCount, boolean global)	Request a specific prefetchCount "quality of service" settings for this channel.
Future<Void>	RabbitMQClient.basicQos(int prefetchSize, int prefetchCount, boolean global)	Request specific "quality of service" settings.
Future<Void>	RabbitMQConsumer.cancel()	Stop message consumption from a queue.
Future<Void>	RabbitMQClient.confirmSelect()	Enables publisher acknowledgements on this channel.
Future<Void>	RabbitMQClient.exchangeBind(String destination, String source, String routingKey)	Bind an exchange to an exchange.
Future<Void>	RabbitMQClient.exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments)	Bind an exchange to an exchange.
Future<Void>	RabbitMQClient.exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete)	Declare an exchange.
Future<Void>	RabbitMQClient.exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, JsonObject config)	Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
Future<Void>	RabbitMQClient.exchangeDelete(String exchange)	Delete an exchange, without regard for whether it is in use or not.
Future<Void>	RabbitMQClient.exchangeUnbind(String destination, String source, String routingKey)	Unbind an exchange from an exchange.
Future<Void>	RabbitMQClient.exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments)	Unbind an exchange from an exchange.
Future<Long>	RabbitMQClient.messageCount(String queue)	Returns the number of messages in a queue ready to be delivered.
Future<Void>	RabbitMQConsumer.pipeTo(WriteStream<RabbitMQMessage> dst)	Pipe this ReadStream to the WriteStream.
Future<Void>	RabbitMQPublisher.publish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)	Publish a message.
Future<Long>	RabbitMQPublisher.publishConfirm(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)	Publish a message and complete when publish confirm has returned.
Future<Void>	RabbitMQClient.queueBind(String queue, String exchange, String routingKey)	Bind a queue to an exchange
Future<Void>	RabbitMQClient.queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments)	Bind a queue to an exchange
Future<com.rabbitmq.client.AMQP.Queue.DeclareOk>	RabbitMQClient.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete)	Declare a queue
Future<com.rabbitmq.client.AMQP.Queue.DeclareOk>	RabbitMQClient.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, JsonObject config)	Declare a queue with config options
Future<JsonObject>	RabbitMQClient.queueDeclareAuto()	Actively declare a server-named exclusive, autodelete, non-durable queue.
Future<com.rabbitmq.client.AMQP.Queue.DeleteOk>	RabbitMQClient.queueDelete(String queue)	Delete a queue, without regard for whether it is in use or has messages on it
Future<com.rabbitmq.client.AMQP.Queue.DeleteOk>	RabbitMQClient.queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty)	Delete a queue
Future<Void>	RabbitMQClient.queueUnbind(String queue, String exchange, String routingKey)	Unbind a queue from an exchange
Future<Void>	RabbitMQClient.queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments)	Unbind a queue from an exchange
Future<Void>	RabbitMQClient.restartConnect(int attempts)	restart the rabbitMQ connect.
Future<Void>	RabbitMQClient.start()	Start the rabbitMQ client.
Future<Void>	RabbitMQPublisher.start()	Start the rabbitMQ publisher.
Future<Void>	RabbitMQClient.stop()	Stop the rabbitMQ client.
Future<Void>	RabbitMQPublisher.stop()	Stop the rabbitMQ publisher.
Future<Void>	RabbitMQClient.waitForConfirms()	Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
Future<Void>	RabbitMQClient.waitForConfirms(long timeout)	Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

Uses of Future in io.vertx.reactivex.redis.client

Methods in io.vertx.reactivex.redis.client that return Future

Modifier and Type	Method	Description
Future<Response>	RedisAPI.acl(List<String> args)	A container for Access List Control commands.
Future<Response>	ValkeyAPI.acl(List<String> args)	A container for Access List Control commands.
Future<Response>	RedisAPI.append(String arg0, String arg1)	Appends a string to the value of a key.
Future<Response>	ValkeyAPI.append(String arg0, String arg1)	Appends a string to the value of a key.
Future<Response>	RedisAPI.asking()	Signals that a cluster client is following an -ASK redirect.
Future<Response>	ValkeyAPI.asking()	Signals that a cluster client is following an -ASK redirect.
Future<Response>	RedisAPI.auth(List<String> args)	Authenticates the connection.
Future<Response>	ValkeyAPI.auth(List<String> args)	Authenticates the connection.
Future<List<Response>>	Redis.batch(List<Request> commands)	Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
Future<List<Response>>	RedisConnection.batch(List<Request> commands)	Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
Future<Response>	RedisAPI.bfAdd(String arg0, String arg1)	Adds an item to a Bloom Filter.
Future<Response>	RedisAPI.bfAdd(List<String> args)	Adds an item to a Bloom Filter.
Future<Response>	RedisAPI.bfCard(String arg0)	Returns the cardinality of a Bloom filter.
Future<Response>	RedisAPI.bfCard(List<String> args)	Returns the cardinality of a Bloom filter.
Future<Response>	RedisAPI.bfDebug(List<String> args)
Future<Response>	RedisAPI.bfExists(String arg0, String arg1)	Checks whether an item exists in a Bloom Filter.
Future<Response>	RedisAPI.bfExists(List<String> args)	Checks whether an item exists in a Bloom Filter.
Future<Response>	RedisAPI.bfInfo(List<String> args)	Returns information about a Bloom Filter.
Future<Response>	RedisAPI.bfInsert(List<String> args)	Adds one or more items to a Bloom Filter.
Future<Response>	RedisAPI.bfLoadchunk(String arg0, String arg1, String arg2)	Restores a filter previously saved using SCANDUMP.
Future<Response>	RedisAPI.bfLoadchunk(List<String> args)	Restores a filter previously saved using SCANDUMP.
Future<Response>	RedisAPI.bfMadd(List<String> args)	Adds one or more items to a Bloom Filter.
Future<Response>	RedisAPI.bfMexists(List<String> args)	Checks whether one or more items exist in a Bloom Filter.
Future<Response>	RedisAPI.bfReserve(List<String> args)	Creates a new Bloom Filter.
Future<Response>	RedisAPI.bfScandump(String arg0, String arg1)	Begins an incremental save of the bloom filter.
Future<Response>	RedisAPI.bfScandump(List<String> args)	Begins an incremental save of the bloom filter.
Future<Response>	RedisAPI.bgrewriteaof()	Asynchronously rewrites the append-only file to disk.
Future<Response>	ValkeyAPI.bgrewriteaof()	Asynchronously rewrites the append-only file to disk.
Future<Response>	RedisAPI.bgsave(List<String> args)	Asynchronously saves the database(s) to disk.
Future<Response>	ValkeyAPI.bgsave(List<String> args)	Asynchronously saves the database(s) to disk.
Future<Response>	RedisAPI.bitcount(List<String> args)	Counts the number of set bits (population counting) in a string.
Future<Response>	ValkeyAPI.bitcount(List<String> args)	Counts the number of set bits (population counting) in a string.
Future<Response>	RedisAPI.bitfield(List<String> args)	Performs arbitrary bitfield integer operations on strings.
Future<Response>	ValkeyAPI.bitfield(List<String> args)	Performs arbitrary bitfield integer operations on strings.
Future<Response>	RedisAPI.bitfieldRo(List<String> args)	Performs arbitrary read-only bitfield integer operations on strings.
Future<Response>	ValkeyAPI.bitfieldRo(List<String> args)	Performs arbitrary read-only bitfield integer operations on strings.
Future<Response>	RedisAPI.bitop(List<String> args)	Performs bitwise operations on multiple strings, and stores the result.
Future<Response>	ValkeyAPI.bitop(List<String> args)	Performs bitwise operations on multiple strings, and stores the result.
Future<Response>	RedisAPI.bitpos(List<String> args)	Finds the first set (1) or clear (0) bit in a string.
Future<Response>	ValkeyAPI.bitpos(List<String> args)	Finds the first set (1) or clear (0) bit in a string.
Future<Response>	RedisAPI.blmove(String arg0, String arg1, String arg2, String arg3, String arg4)	Pops an element from a list, pushes it to another list and returns it.
Future<Response>	ValkeyAPI.blmove(String arg0, String arg1, String arg2, String arg3, String arg4)	Pops an element from a list, pushes it to another list and returns it.
Future<Response>	RedisAPI.blmpop(List<String> args)	Pops the first element from one of multiple lists.
Future<Response>	ValkeyAPI.blmpop(List<String> args)	Pops the first element from one of multiple lists.
Future<Response>	RedisAPI.blpop(List<String> args)	Removes and returns the first element in a list.
Future<Response>	ValkeyAPI.blpop(List<String> args)	Removes and returns the first element in a list.
Future<Response>	RedisAPI.brpop(List<String> args)	Removes and returns the last element in a list.
Future<Response>	ValkeyAPI.brpop(List<String> args)	Removes and returns the last element in a list.
Future<Response>	RedisAPI.brpoplpush(String arg0, String arg1, String arg2)	Pops an element from a list, pushes it to another list and returns it.
Future<Response>	ValkeyAPI.brpoplpush(String arg0, String arg1, String arg2)	Pops an element from a list, pushes it to another list and returns it.
Future<Response>	RedisAPI.bzmpop(List<String> args)	Removes and returns a member by score from one or more sorted sets.
Future<Response>	ValkeyAPI.bzmpop(List<String> args)	Removes and returns a member by score from one or more sorted sets.
Future<Response>	RedisAPI.bzpopmax(List<String> args)	Removes and returns the member with the highest score from one or more sorted sets.
Future<Response>	ValkeyAPI.bzpopmax(List<String> args)	Removes and returns the member with the highest score from one or more sorted sets.
Future<Response>	RedisAPI.bzpopmin(List<String> args)	Removes and returns the member with the lowest score from one or more sorted sets.
Future<Response>	ValkeyAPI.bzpopmin(List<String> args)	Removes and returns the member with the lowest score from one or more sorted sets.
Future<Response>	RedisAPI.cfAdd(String arg0, String arg1)	Adds an item to a Cuckoo Filter.
Future<Response>	RedisAPI.cfAdd(List<String> args)	Adds an item to a Cuckoo Filter.
Future<Response>	RedisAPI.cfAddnx(String arg0, String arg1)	Adds an item to a Cuckoo Filter if the item did not exist previously.
Future<Response>	RedisAPI.cfAddnx(List<String> args)	Adds an item to a Cuckoo Filter if the item did not exist previously.
Future<Response>	RedisAPI.cfCompact(List<String> args)
Future<Response>	RedisAPI.cfCount(String arg0, String arg1)	Return the number of times an item might be in a Cuckoo Filter.
Future<Response>	RedisAPI.cfCount(List<String> args)	Return the number of times an item might be in a Cuckoo Filter.
Future<Response>	RedisAPI.cfDebug(List<String> args)
Future<Response>	RedisAPI.cfDel(String arg0, String arg1)	Deletes an item from a Cuckoo Filter.
Future<Response>	RedisAPI.cfDel(List<String> args)	Deletes an item from a Cuckoo Filter.
Future<Response>	RedisAPI.cfExists(String arg0, String arg1)	Checks whether one or more items exist in a Cuckoo Filter.
Future<Response>	RedisAPI.cfExists(List<String> args)	Checks whether one or more items exist in a Cuckoo Filter.
Future<Response>	RedisAPI.cfInfo(String arg0)	Returns information about a Cuckoo Filter.
Future<Response>	RedisAPI.cfInfo(List<String> args)	Returns information about a Cuckoo Filter.
Future<Response>	RedisAPI.cfInsert(List<String> args)	Adds one or more items to a Cuckoo Filter.
Future<Response>	RedisAPI.cfInsertnx(List<String> args)	Adds one or more items to a Cuckoo Filter if the items did not exist previously.
Future<Response>	RedisAPI.cfLoadchunk(String arg0, String arg1, String arg2)	Restores a filter previously saved using SCANDUMP.
Future<Response>	RedisAPI.cfLoadchunk(List<String> args)	Restores a filter previously saved using SCANDUMP.
Future<Response>	RedisAPI.cfMexists(List<String> args)	Checks whether one or more items exist in a Cuckoo Filter.
Future<Response>	RedisAPI.cfReserve(List<String> args)	Creates a new Cuckoo Filter.
Future<Response>	RedisAPI.cfScandump(String arg0, String arg1)	Begins an incremental save of the bloom filter.
Future<Response>	RedisAPI.cfScandump(List<String> args)	Begins an incremental save of the bloom filter.
Future<Response>	RedisAPI.client(List<String> args)	A container for client connection commands.
Future<Response>	ValkeyAPI.client(List<String> args)	A container for client connection commands.
Future<Void>	Redis.close()	Closes the client and terminates any connection.
Future<Void>	RedisConnection.close()	Closes the connection or returns to the pool.
Future<Response>	RedisAPI.cluster(List<String> args)	A container for Redis Cluster commands.
Future<Response>	ValkeyAPI.cluster(List<String> args)	A container for Cluster commands.
Future<Response>	RedisAPI.cmsIncrby(List<String> args)	Increases the count of one or more items by increment.
Future<Response>	RedisAPI.cmsInfo(String arg0)	Returns information about a sketch.
Future<Response>	RedisAPI.cmsInfo(List<String> args)	Returns information about a sketch.
Future<Response>	RedisAPI.cmsInitbydim(String arg0, String arg1, String arg2)	Initializes a Count-Min Sketch to dimensions specified by user.
Future<Response>	RedisAPI.cmsInitbydim(List<String> args)	Initializes a Count-Min Sketch to dimensions specified by user.
Future<Response>	RedisAPI.cmsInitbyprob(String arg0, String arg1, String arg2)	Initializes a Count-Min Sketch to accommodate requested tolerances.
Future<Response>	RedisAPI.cmsInitbyprob(List<String> args)	Initializes a Count-Min Sketch to accommodate requested tolerances.
Future<Response>	RedisAPI.cmsMerge(List<String> args)	Merges several sketches into one sketch.
Future<Response>	RedisAPI.cmsQuery(List<String> args)	Returns the count for one or more items in a sketch.
Future<Response>	RedisAPI.command(List<String> args)	Returns detailed information about all commands.
Future<Response>	ValkeyAPI.command(List<String> args)	Returns detailed information about all commands.
Future<Response>	ValkeyAPI.commandlog(List<String> args)	A container for command log commands.
Future<Response>	RedisAPI.config(List<String> args)	A container for server configuration commands.
Future<Response>	ValkeyAPI.config(List<String> args)	A container for server configuration commands.
Future<RedisConnection>	Redis.connect()	Connects to the Redis server.
Future<Response>	RedisAPI.copy(List<String> args)	Copies the value of a key to a new key.
Future<Response>	ValkeyAPI.copy(List<String> args)	Copies the value of a key to a new key.
Future<Response>	RedisAPI.dbsize()	Returns the number of keys in the database.
Future<Response>	ValkeyAPI.dbsize()	Returns the number of keys in the database.
Future<Response>	RedisAPI.debug(List<String> args)	A container for debugging commands.
Future<Response>	ValkeyAPI.debug(List<String> args)	A container for debugging commands.
Future<Response>	RedisAPI.decr(String arg0)	Decrements the integer value of a key by one.
Future<Response>	ValkeyAPI.decr(String arg0)	Decrements the integer value of a key by one.
Future<Response>	RedisAPI.decrby(String arg0, String arg1)	Decrements a number from the integer value of a key.
Future<Response>	ValkeyAPI.decrby(String arg0, String arg1)	Decrements a number from the integer value of a key.
Future<Response>	RedisAPI.del(List<String> args)	Deletes one or more keys.
Future<Response>	ValkeyAPI.del(List<String> args)	Deletes one or more keys.
Future<Response>	RedisAPI.delex(List<String> args)	Conditionally removes the specified key based on value or digest comparison.
Future<Response>	ValkeyAPI.delifeq(String arg0, String arg1)	Delete key if value matches string.
Future<Response>	RedisAPI.digest(String arg0)	Returns the XXH3 hash of a string value.
Future<Response>	RedisAPI.discard()	Discards a transaction.
Future<Response>	ValkeyAPI.discard()	Discards a transaction.
Future<Response>	RedisAPI.dump(String arg0)	Returns a serialized representation of the value stored at a key.
Future<Response>	ValkeyAPI.dump(String arg0)	Returns a serialized representation of the value stored at a key.
Future<Response>	RedisAPI.echo(String arg0)	Returns the given string.
Future<Response>	ValkeyAPI.echo(String arg0)	Returns the given string.
Future<Response>	RedisAPI.eval(List<String> args)	Executes a server-side Lua script.
Future<Response>	ValkeyAPI.eval(List<String> args)	Executes a server-side Lua script.
Future<Response>	RedisAPI.evalRo(List<String> args)	Executes a read-only server-side Lua script.
Future<Response>	ValkeyAPI.evalRo(List<String> args)	Executes a read-only server-side Lua script.
Future<Response>	RedisAPI.evalsha(List<String> args)	Executes a server-side Lua script by SHA1 digest.
Future<Response>	ValkeyAPI.evalsha(List<String> args)	Executes a server-side Lua script by SHA1 digest.
Future<Response>	RedisAPI.evalshaRo(List<String> args)	Executes a read-only server-side Lua script by SHA1 digest.
Future<Response>	ValkeyAPI.evalshaRo(List<String> args)	Executes a read-only server-side Lua script by SHA1 digest.
Future<Response>	RedisAPI.exec()	Executes all commands in a transaction.
Future<Response>	ValkeyAPI.exec()	Executes all commands in a transaction.
Future<Response>	RedisAPI.exists(List<String> args)	Determines whether one or more keys exist.
Future<Response>	ValkeyAPI.exists(List<String> args)	Determines whether one or more keys exist.
Future<Response>	RedisAPI.expire(List<String> args)	Sets the expiration time of a key in seconds.
Future<Response>	ValkeyAPI.expire(List<String> args)	Sets the expiration time of a key in seconds.
Future<Response>	RedisAPI.expireat(List<String> args)	Sets the expiration time of a key to a Unix timestamp.
Future<Response>	ValkeyAPI.expireat(List<String> args)	Sets the expiration time of a key to a Unix timestamp.
Future<Response>	RedisAPI.expiretime(String arg0)	Returns the expiration time of a key as a Unix timestamp.
Future<Response>	ValkeyAPI.expiretime(String arg0)	Returns the expiration time of a key as a Unix timestamp.
Future<Response>	RedisAPI.failover(List<String> args)	Starts a coordinated failover from a server to one of its replicas.
Future<Response>	ValkeyAPI.failover(List<String> args)	Starts a coordinated failover from a server to one of its replicas.
Future<Response>	RedisAPI.fcall(List<String> args)	Invokes a function.
Future<Response>	ValkeyAPI.fcall(List<String> args)	Invokes a function.
Future<Response>	RedisAPI.fcallRo(List<String> args)	Invokes a read-only function.
Future<Response>	ValkeyAPI.fcallRo(List<String> args)	Invokes a read-only function.
Future<Response>	RedisAPI.flushall(List<String> args)	Removes all keys from all databases.
Future<Response>	ValkeyAPI.flushall(List<String> args)	Removes all keys from all databases.
Future<Response>	RedisAPI.flushdb(List<String> args)	Remove all keys from the current database.
Future<Response>	ValkeyAPI.flushdb(List<String> args)	Remove all keys from the current database.
Future<Response>	RedisAPI.ftAdd(List<String> args)
Future<Response>	RedisAPI.ftAggregate(List<String> args)	Run a search query on an index and perform aggregate transformations on the results.
Future<Response>	RedisAPI.ftAliasadd(List<String> args)	Adds an alias to the index.
Future<Response>	RedisAPI.ftAliasaddifnx(List<String> args)	Adds an alias to the index.
Future<Response>	RedisAPI.ftAliasdel(List<String> args)	Deletes an alias from the index.
Future<Response>	RedisAPI.ftAliasdelifx(List<String> args)	Deletes an alias from the index.
Future<Response>	RedisAPI.ftAliasupdate(List<String> args)	Adds or updates an alias to the index.
Future<Response>	RedisAPI.ftAlter(List<String> args)	Adds a new field to the index.
Future<Response>	RedisAPI.ftAlterifnx(List<String> args)	Adds a new field to the index.
Future<Response>	RedisAPI.ftConfig(List<String> args)
Future<Response>	RedisAPI.ftCreate(List<String> args)	Creates an index with the given spec.
Future<Response>	RedisAPI.ftCreateifnx(List<String> args)	Creates an index with the given spec.
Future<Response>	RedisAPI.ftCursor(List<String> args)
Future<Response>	RedisAPI.ftDebug(List<String> args)
Future<Response>	RedisAPI.ftDel(List<String> args)
Future<Response>	RedisAPI.ftDictadd(List<String> args)	Adds terms to a dictionary.
Future<Response>	RedisAPI.ftDictdel(List<String> args)	Deletes terms from a dictionary.
Future<Response>	RedisAPI.ftDictdump(List<String> args)	Dumps all terms in the given dictionary.
Future<Response>	RedisAPI.ftDrop(List<String> args)
Future<Response>	RedisAPI.ftDropifx(List<String> args)
Future<Response>	RedisAPI.ftDropindex(List<String> args)	Deletes the index.
Future<Response>	RedisAPI.ftDropindexifx(List<String> args)	Deletes the index.
Future<Response>	RedisAPI.ftExplain(List<String> args)	Returns the execution plan for a complex query.
Future<Response>	RedisAPI.ftExplaincli(List<String> args)	Returns the execution plan for a complex query.
Future<Response>	RedisAPI.ftGet(List<String> args)
Future<Response>	RedisAPI.ftHybrid(List<String> args)	Performs hybrid search combining text search and vector similarity search.
Future<Response>	RedisAPI.ftInfo(List<String> args)	Returns information and statistics on the index.
Future<Response>	RedisAPI.ftList(List<String> args)	Returns a list of all existing indexes.
Future<Response>	RedisAPI.ftMget(List<String> args)
Future<Response>	RedisAPI.ftProfile(List<String> args)	Performs a `FT.SEARCH` or `FT.AGGREGATE` command and collects performance information.
Future<Response>	RedisAPI.ftSafeadd(List<String> args)
Future<Response>	RedisAPI.ftSearch(List<String> args)	Searches the index with a textual query, returning either documents or just ids.
Future<Response>	RedisAPI.ftSpellcheck(List<String> args)	Performs spelling correction on a query, returning suggestions for misspelled terms.
Future<Response>	RedisAPI.ftSugadd(List<String> args)	Adds a suggestion string to an auto-complete suggestion dictionary.
Future<Response>	RedisAPI.ftSugdel(List<String> args)	Deletes a string from a suggestion index.
Future<Response>	RedisAPI.ftSugget(List<String> args)	Gets completion suggestions for a prefix.
Future<Response>	RedisAPI.ftSuglen(List<String> args)	Gets the size of an auto-complete suggestion dictionary.
Future<Response>	RedisAPI.ftSynadd(List<String> args)
Future<Response>	RedisAPI.ftSyndump(List<String> args)	Dumps the contents of a synonym group.
Future<Response>	RedisAPI.ftSynupdate(List<String> args)	Creates or updates a synonym group with additional terms.
Future<Response>	RedisAPI.ftTagvals(List<String> args)	Returns the distinct tags indexed in a Tag field.
Future<Response>	RedisAPI.function(List<String> args)	A container for function commands.
Future<Response>	ValkeyAPI.function(List<String> args)	A container for function commands.
Future<Response>	RedisAPI.geoadd(List<String> args)	Adds one or more members to a geospatial index.
Future<Response>	ValkeyAPI.geoadd(List<String> args)	Adds one or more members to a geospatial index.
Future<Response>	RedisAPI.geodist(List<String> args)	Returns the distance between two members of a geospatial index.
Future<Response>	ValkeyAPI.geodist(List<String> args)	Returns the distance between two members of a geospatial index.
Future<Response>	RedisAPI.geohash(List<String> args)	Returns members from a geospatial index as geohash strings.
Future<Response>	ValkeyAPI.geohash(List<String> args)	Returns members from a geospatial index as geohash strings.
Future<Response>	RedisAPI.geopos(List<String> args)	Returns the longitude and latitude of members from a geospatial index.
Future<Response>	ValkeyAPI.geopos(List<String> args)	Returns the longitude and latitude of members from a geospatial index.
Future<Response>	RedisAPI.georadius(List<String> args)	Queries a geospatial index for members within a distance from a coordinate, optionally stores the result.
Future<Response>	ValkeyAPI.georadius(List<String> args)	Queries a geospatial index for members within a distance from a coordinate, optionally stores the result.
Future<Response>	RedisAPI.georadiusbymember(List<String> args)	Queries a geospatial index for members within a distance from a member, optionally stores the result.
Future<Response>	ValkeyAPI.georadiusbymember(List<String> args)	Queries a geospatial index for members within a distance from a member, optionally stores the result.
Future<Response>	RedisAPI.georadiusbymemberRo(List<String> args)	Returns members from a geospatial index that are within a distance from a member.
Future<Response>	ValkeyAPI.georadiusbymemberRo(List<String> args)	Returns members from a geospatial index that are within a distance from a member.
Future<Response>	RedisAPI.georadiusRo(List<String> args)	Returns members from a geospatial index that are within a distance from a coordinate.
Future<Response>	ValkeyAPI.georadiusRo(List<String> args)	Returns members from a geospatial index that are within a distance from a coordinate.
Future<Response>	RedisAPI.geosearch(List<String> args)	Queries a geospatial index for members inside an area of a box or a circle.
Future<Response>	ValkeyAPI.geosearch(List<String> args)	Queries a geospatial index for members inside an area of a box, circle, or a polygon.
Future<Response>	RedisAPI.geosearchstore(List<String> args)	Queries a geospatial index for members inside an area of a box or a circle, optionally stores the result.
Future<Response>	ValkeyAPI.geosearchstore(List<String> args)	Queries a geospatial index for members inside an area of a box, a circle, or a polygon, optionally stores the result.
Future<Response>	RedisAPI.get(String arg0)	Returns the string value of a key.
Future<Response>	ValkeyAPI.get(String arg0)	Returns the string value of a key.
Future<Response>	RedisAPI.getbit(String arg0, String arg1)	Returns a bit value by offset.
Future<Response>	ValkeyAPI.getbit(String arg0, String arg1)	Returns a bit value by offset.
Future<Response>	RedisAPI.getdel(String arg0)	Returns the string value of a key after deleting the key.
Future<Response>	ValkeyAPI.getdel(String arg0)	Returns the string value of a key after deleting the key.
Future<Response>	RedisAPI.getex(List<String> args)	Returns the string value of a key after setting its expiration time.
Future<Response>	ValkeyAPI.getex(List<String> args)	Returns the string value of a key after setting its expiration time.
Future<Response>	RedisAPI.getrange(String arg0, String arg1, String arg2)	Returns a substring of the string stored at a key.
Future<Response>	ValkeyAPI.getrange(String arg0, String arg1, String arg2)	Returns a substring of the string stored at a key.
Future<Response>	RedisAPI.getset(String arg0, String arg1)	Returns the previous string value of a key after setting it to a new value.
Future<Response>	ValkeyAPI.getset(String arg0, String arg1)	Returns the previous string value of a key after setting it to a new value.
Future<Response>	RedisAPI.graphBulk(List<String> args)
Future<Response>	RedisAPI.graphConfig(List<String> args)
Future<Response>	RedisAPI.graphDebug(List<String> args)
Future<Response>	RedisAPI.graphDelete(List<String> args)
Future<Response>	RedisAPI.graphExplain(List<String> args)
Future<Response>	RedisAPI.graphList(List<String> args)
Future<Response>	RedisAPI.graphProfile(List<String> args)
Future<Response>	RedisAPI.graphQuery(List<String> args)
Future<Response>	RedisAPI.graphRoQuery(List<String> args)
Future<Response>	RedisAPI.graphSlowlog(List<String> args)
Future<RequestGrouping>	RedisCluster.groupByNodes(List<Request> requests)	Groups the requests into a RequestGrouping, which contains: keyed requests: requests that include a key and it is therefore possible to determine to which master node they should be sent; all requests in each inner list in the keyed collection are guaranteed to be sent to the same master node; unkeyed requests: requests that do not include a key and it is therefore not possible to determine to which master node they should be sent. If any of the requests includes multiple keys that belong to different master nodes, the resulting future will fail.
Future<Response>	RedisAPI.hdel(List<String> args)	Deletes one or more fields and their values from a hash.
Future<Response>	ValkeyAPI.hdel(List<String> args)	Deletes one or more fields and their values from a hash.
Future<Response>	RedisAPI.hello(List<String> args)	Handshakes with the Redis server.
Future<Response>	ValkeyAPI.hello(List<String> args)	Handshakes with the server.
Future<Response>	RedisAPI.hexists(String arg0, String arg1)	Determines whether a field exists in a hash.
Future<Response>	ValkeyAPI.hexists(String arg0, String arg1)	Determines whether a field exists in a hash.
Future<Response>	RedisAPI.hexpire(List<String> args)	Set expiry for hash field using relative time to expire (seconds).
Future<Response>	ValkeyAPI.hexpire(List<String> args)	Set expiry time on hash fields.
Future<Response>	RedisAPI.hexpireat(List<String> args)	Set expiry for hash field using an absolute Unix timestamp (seconds).
Future<Response>	ValkeyAPI.hexpireat(List<String> args)	Set expiry time on hash fields.
Future<Response>	RedisAPI.hexpiretime(List<String> args)	Returns the expiration time of a hash field as a Unix timestamp, in seconds.
Future<Response>	ValkeyAPI.hexpiretime(List<String> args)	Returns Unix timestamps in seconds since the epoch at which the given key's field(s) will expire.
Future<Response>	RedisAPI.hget(String arg0, String arg1)	Returns the value of a field in a hash.
Future<Response>	ValkeyAPI.hget(String arg0, String arg1)	Returns the value of a field in a hash.
Future<Response>	RedisAPI.hgetall(String arg0)	Returns all fields and values in a hash.
Future<Response>	ValkeyAPI.hgetall(String arg0)	Returns all fields and values in a hash.
Future<Response>	RedisAPI.hgetdel(List<String> args)	Returns the value of a field and deletes it from the hash.
Future<Response>	RedisAPI.hgetex(List<String> args)	Get the value of one or more fields of a given hash key, and optionally set their expiration.
Future<Response>	ValkeyAPI.hgetex(List<String> args)	Get the value of one or more fields of a given hash key, and optionally set their expiration time or time-to-live (TTL).
Future<Response>	RedisAPI.hincrby(String arg0, String arg1, String arg2)	Increments the integer value of a field in a hash by a number.
Future<Response>	ValkeyAPI.hincrby(String arg0, String arg1, String arg2)	Increments the integer value of a field in a hash by a number.
Future<Response>	RedisAPI.hincrbyfloat(String arg0, String arg1, String arg2)	Increments the floating point value of a field by a number.
Future<Response>	ValkeyAPI.hincrbyfloat(String arg0, String arg1, String arg2)	Increments the floating point value of a field by a number.
Future<Response>	RedisAPI.hkeys(String arg0)	Returns all fields in a hash.
Future<Response>	ValkeyAPI.hkeys(String arg0)	Returns all fields in a hash.
Future<Response>	RedisAPI.hlen(String arg0)	Returns the number of fields in a hash.
Future<Response>	ValkeyAPI.hlen(String arg0)	Returns the number of fields in a hash.
Future<Response>	RedisAPI.hmget(List<String> args)	Returns the values of all fields in a hash.
Future<Response>	ValkeyAPI.hmget(List<String> args)	Returns the values of all fields in a hash.
Future<Response>	RedisAPI.hmset(List<String> args)	Sets the values of multiple fields.
Future<Response>	ValkeyAPI.hmset(List<String> args)	Sets the values of multiple fields.
Future<Response>	RedisAPI.hotkeys(List<String> args)	A container for hotkeys tracking commands.
Future<Response>	RedisAPI.hpersist(List<String> args)	Removes the expiration time for each specified field.
Future<Response>	ValkeyAPI.hpersist(List<String> args)	Remove the existing expiration on a hash key's field(s).
Future<Response>	RedisAPI.hpexpire(List<String> args)	Set expiry for hash field using relative time to expire (milliseconds).
Future<Response>	ValkeyAPI.hpexpire(List<String> args)	Set expiry time on hash object.
Future<Response>	RedisAPI.hpexpireat(List<String> args)	Set expiry for hash field using an absolute Unix timestamp (milliseconds).
Future<Response>	ValkeyAPI.hpexpireat(List<String> args)	Set expiration time on hash field.
Future<Response>	RedisAPI.hpexpiretime(List<String> args)	Returns the expiration time of a hash field as a Unix timestamp, in msec.
Future<Response>	ValkeyAPI.hpexpiretime(List<String> args)	Returns the Unix timestamp in milliseconds since Unix epoch at which the given key's field(s) will expire.
Future<Response>	RedisAPI.hpttl(List<String> args)	Returns the TTL in milliseconds of a hash field.
Future<Response>	ValkeyAPI.hpttl(List<String> args)	Returns the remaining time to live in milliseconds of a hash key's field(s) that have an associated expiration.
Future<Response>	RedisAPI.hrandfield(List<String> args)	Returns one or more random fields from a hash.
Future<Response>	ValkeyAPI.hrandfield(List<String> args)	Returns one or more random fields from a hash.
Future<Response>	RedisAPI.hscan(List<String> args)	Iterates over fields and values of a hash.
Future<Response>	ValkeyAPI.hscan(List<String> args)	Iterates over fields and values of a hash.
Future<Response>	RedisAPI.hset(List<String> args)	Creates or modifies the value of a field in a hash.
Future<Response>	ValkeyAPI.hset(List<String> args)	Creates or modifies the value of a field in a hash.
Future<Response>	RedisAPI.hsetex(List<String> args)	Set the value of one or more fields of a given hash key, and optionally set their expiration.
Future<Response>	ValkeyAPI.hsetex(List<String> args)	Set the value of one or more fields of a given hash key, and optionally set their expiration time.
Future<Response>	RedisAPI.hsetnx(String arg0, String arg1, String arg2)	Sets the value of a field in a hash only when the field doesn't exist.
Future<Response>	ValkeyAPI.hsetnx(String arg0, String arg1, String arg2)	Sets the value of a field in a hash only when the field doesn't exist.
Future<Response>	RedisAPI.hstrlen(String arg0, String arg1)	Returns the length of the value of a field.
Future<Response>	ValkeyAPI.hstrlen(String arg0, String arg1)	Returns the length of the value of a field.
Future<Response>	RedisAPI.httl(List<String> args)	Returns the TTL in seconds of a hash field.
Future<Response>	ValkeyAPI.httl(List<String> args)	Returns the remaining time to live (in seconds) of a hash key's field(s) that have an associated expiration.
Future<Response>	RedisAPI.hvals(String arg0)	Returns all values in a hash.
Future<Response>	ValkeyAPI.hvals(String arg0)	Returns all values in a hash.
Future<Response>	RedisAPI.incr(String arg0)	Increments the integer value of a key by one.
Future<Response>	ValkeyAPI.incr(String arg0)	Increments the integer value of a key by one.
Future<Response>	RedisAPI.incrby(String arg0, String arg1)	Increments the integer value of a key by a number.
Future<Response>	ValkeyAPI.incrby(String arg0, String arg1)	Increments the integer value of a key by a number.
Future<Response>	RedisAPI.incrbyfloat(String arg0, String arg1)	Increment the floating point value of a key by a number.
Future<Response>	ValkeyAPI.incrbyfloat(String arg0, String arg1)	Increment the floating point value of a key by a number.
Future<Response>	RedisAPI.info(List<String> args)	Returns information and statistics about the server.
Future<Response>	ValkeyAPI.info(List<String> args)	Returns information and statistics about the server.
Future<Response>	RedisAPI.jsonArrappend(List<String> args)	Append the JSON values into the array at path after the last element in it.
Future<Response>	RedisAPI.jsonArrindex(List<String> args)	Search for the first occurrence of a JSON value in an array.
Future<Response>	RedisAPI.jsonArrinsert(List<String> args)	Insert the json values into the array at path before the index (shifts to the right).
Future<Response>	RedisAPI.jsonArrlen(List<String> args)	Report the length of the JSON array at path in key.
Future<Response>	RedisAPI.jsonArrpop(List<String> args)	Remove and return the element at the specified index in the array at path.
Future<Response>	RedisAPI.jsonArrtrim(String arg0, String arg1, String arg2, String arg3)	Trim an array so that it contains only the specified inclusive range of elements.
Future<Response>	RedisAPI.jsonArrtrim(List<String> args)	Trim an array so that it contains only the specified inclusive range of elements.
Future<Response>	RedisAPI.jsonClear(List<String> args)	Clear container values (arrays/objects) and set numeric values to 0.
Future<Response>	RedisAPI.jsonDebug(List<String> args)	This is a container command for debugging related tasks.
Future<Response>	RedisAPI.jsonDel(List<String> args)	Delete a value.
Future<Response>	RedisAPI.jsonForget(List<String> args)	Delete a value.
Future<Response>	RedisAPI.jsonGet(List<String> args)	Get JSON value at path.
Future<Response>	RedisAPI.jsonMerge(List<String> args)	Merge a given JSON value into matching paths.
Future<Response>	RedisAPI.jsonMget(List<String> args)	Return the values at path from multiple key arguments.
Future<Response>	RedisAPI.jsonMset(List<String> args)	Set or update one or more JSON values according to the specified key-path-value triplets.
Future<Response>	RedisAPI.jsonNumincrby(String arg0, String arg1, String arg2)	Increment the number value stored at path by number.
Future<Response>	RedisAPI.jsonNumincrby(List<String> args)	Increment the number value stored at path by number.
Future<Response>	RedisAPI.jsonNummultby(String arg0, String arg1, String arg2)	Multiply the number value stored at path by number.
Future<Response>	RedisAPI.jsonNummultby(List<String> args)	Multiply the number value stored at path by number.
Future<Response>	RedisAPI.jsonNumpowby(String arg0, String arg1, String arg2)	Raise the number value stored at path to the power of number.
Future<Response>	RedisAPI.jsonNumpowby(List<String> args)	Raise the number value stored at path to the power of number.
Future<Response>	RedisAPI.jsonObjkeys(List<String> args)	Return the keys in the object that's referenced by path.
Future<Response>	RedisAPI.jsonObjlen(List<String> args)	Report the number of keys in the JSON object at path in key.
Future<Response>	RedisAPI.jsonResp(List<String> args)	Return the JSON in key in Redis serialization protocol specification form.
Future<Response>	RedisAPI.jsonSet(List<String> args)	Set the JSON value at path in key.
Future<Response>	RedisAPI.jsonStrappend(List<String> args)	Append the json-string values to the string at path.
Future<Response>	RedisAPI.jsonStrlen(List<String> args)	Report the length of the JSON String at path in key.
Future<Response>	RedisAPI.jsonToggle(String arg0, String arg1)	Toggle the boolean value stored at path.
Future<Response>	RedisAPI.jsonToggle(List<String> args)	Toggle the boolean value stored at path.
Future<Response>	RedisAPI.jsonType(List<String> args)	Report the type of JSON value at path.
Future<Response>	RedisAPI.keys(String arg0)	Returns all key names that match a pattern.
Future<Response>	ValkeyAPI.keys(String arg0)	Returns all key names that match a pattern.
Future<Response>	RedisAPI.lastsave()	Returns the Unix timestamp of the last successful save to disk.
Future<Response>	ValkeyAPI.lastsave()	Returns the Unix timestamp of the last successful save to disk.
Future<Response>	RedisAPI.latency(List<String> args)	A container for latency diagnostics commands.
Future<Response>	ValkeyAPI.latency(List<String> args)	A container for latency diagnostics commands.
Future<Response>	RedisAPI.lcs(List<String> args)	Finds the longest common substring.
Future<Response>	ValkeyAPI.lcs(List<String> args)	Finds the longest common substring.
Future<Response>	RedisAPI.lindex(String arg0, String arg1)	Returns an element from a list by its index.
Future<Response>	ValkeyAPI.lindex(String arg0, String arg1)	Returns an element from a list by its index.
Future<Response>	RedisAPI.linsert(String arg0, String arg1, String arg2, String arg3)	Inserts an element before or after another element in a list.
Future<Response>	ValkeyAPI.linsert(String arg0, String arg1, String arg2, String arg3)	Inserts an element before or after another element in a list.
Future<Response>	RedisAPI.llen(String arg0)	Returns the length of a list.
Future<Response>	ValkeyAPI.llen(String arg0)	Returns the length of a list.
Future<Response>	RedisAPI.lmove(String arg0, String arg1, String arg2, String arg3)	Returns an element after popping it from one list and pushing it to another.
Future<Response>	ValkeyAPI.lmove(String arg0, String arg1, String arg2, String arg3)	Returns an element after popping it from one list and pushing it to another.
Future<Response>	RedisAPI.lmpop(List<String> args)	Returns multiple elements from a list after removing them.
Future<Response>	ValkeyAPI.lmpop(List<String> args)	Returns multiple elements from a list after removing them.
Future<Response>	RedisAPI.lolwut(List<String> args)	Displays computer art and the Redis version.
Future<Response>	ValkeyAPI.lolwut(List<String> args)	Displays computer art and the server version.
Future<Response>	RedisAPI.lpop(List<String> args)	Returns the first elements in a list after removing it.
Future<Response>	ValkeyAPI.lpop(List<String> args)	Returns and removes one or more elements from the beginning of a list.
Future<Response>	RedisAPI.lpos(List<String> args)	Returns the index of matching elements in a list.
Future<Response>	ValkeyAPI.lpos(List<String> args)	Returns the index of matching elements in a list.
Future<Response>	RedisAPI.lpush(List<String> args)	Prepends one or more elements to a list.
Future<Response>	ValkeyAPI.lpush(List<String> args)	Prepends one or more elements to a list.
Future<Response>	RedisAPI.lpushx(List<String> args)	Prepends one or more elements to a list only when the list exists.
Future<Response>	ValkeyAPI.lpushx(List<String> args)	Prepends one or more elements to a list only when the list exists.
Future<Response>	RedisAPI.lrange(String arg0, String arg1, String arg2)	Returns a range of elements from a list.
Future<Response>	ValkeyAPI.lrange(String arg0, String arg1, String arg2)	Returns a range of elements from a list.
Future<Response>	RedisAPI.lrem(String arg0, String arg1, String arg2)	Removes elements from a list.
Future<Response>	ValkeyAPI.lrem(String arg0, String arg1, String arg2)	Removes elements from a list.
Future<Response>	RedisAPI.lset(String arg0, String arg1, String arg2)	Sets the value of an element in a list by its index.
Future<Response>	ValkeyAPI.lset(String arg0, String arg1, String arg2)	Sets the value of an element in a list by its index.
Future<Response>	RedisAPI.ltrim(String arg0, String arg1, String arg2)	Removes elements from both ends a list.
Future<Response>	ValkeyAPI.ltrim(String arg0, String arg1, String arg2)	Removes elements from both ends a list.
Future<Response>	RedisAPI.memory(List<String> args)	A container for memory diagnostics commands.
Future<Response>	ValkeyAPI.memory(List<String> args)	A container for memory diagnostics commands.
Future<Response>	RedisAPI.mget(List<String> args)	Atomically returns the string values of one or more keys.
Future<Response>	ValkeyAPI.mget(List<String> args)	Atomically returns the string values of one or more keys.
Future<Response>	RedisAPI.migrate(List<String> args)	Atomically transfers a key from one Redis instance to another.
Future<Response>	ValkeyAPI.migrate(List<String> args)	Atomically transfers a key from one instance to another.
Future<Response>	RedisAPI.module(List<String> args)	A container for module commands.
Future<Response>	ValkeyAPI.module(List<String> args)	A container for module commands.
Future<Response>	RedisAPI.monitor()	Listens for all requests received by the server in real-time.
Future<Response>	ValkeyAPI.monitor()	Listens for all requests received by the server in real-time.
Future<Response>	RedisAPI.move(String arg0, String arg1)	Moves a key to another database.
Future<Response>	ValkeyAPI.move(String arg0, String arg1)	Moves a key to another database.
Future<Response>	RedisAPI.mset(List<String> args)	Atomically creates or modifies the string values of one or more keys.
Future<Response>	ValkeyAPI.mset(List<String> args)	Atomically creates or modifies the string values of one or more keys.
Future<Response>	RedisAPI.msetex(List<String> args)	Atomically sets multiple string keys with a shared expiration in a single operation.
Future<Response>	RedisAPI.msetnx(List<String> args)	Atomically modifies the string values of one or more keys only when all keys don't exist.
Future<Response>	ValkeyAPI.msetnx(List<String> args)	Atomically modifies the string values of one or more keys only when all keys don't exist.
Future<Response>	RedisAPI.multi()	Starts a transaction.
Future<Response>	ValkeyAPI.multi()	Starts a transaction.
Future<Response>	RedisAPI.object(List<String> args)	A container for object introspection commands.
Future<Response>	ValkeyAPI.object(List<String> args)	A container for object introspection commands.
Future<List<Response>>	RedisCluster.onAllMasterNodes(Request request)	Runs the request against all master nodes in the cluster.
Future<List<Response>>	RedisCluster.onAllNodes(Request request)	Runs the request against all nodes in the cluster.
Future<Response>	RedisAPI.persist(String arg0)	Removes the expiration time of a key.
Future<Response>	ValkeyAPI.persist(String arg0)	Removes the expiration time of a key.
Future<Response>	RedisAPI.pexpire(List<String> args)	Sets the expiration time of a key in milliseconds.
Future<Response>	ValkeyAPI.pexpire(List<String> args)	Sets the expiration time of a key in milliseconds.
Future<Response>	RedisAPI.pexpireat(List<String> args)	Sets the expiration time of a key to a Unix milliseconds timestamp.
Future<Response>	ValkeyAPI.pexpireat(List<String> args)	Sets the expiration time of a key to a Unix milliseconds timestamp.
Future<Response>	RedisAPI.pexpiretime(String arg0)	Returns the expiration time of a key as a Unix milliseconds timestamp.
Future<Response>	ValkeyAPI.pexpiretime(String arg0)	Returns the expiration time of a key as a Unix milliseconds timestamp.
Future<Response>	RedisAPI.pfadd(List<String> args)	Adds elements to a HyperLogLog key.
Future<Response>	ValkeyAPI.pfadd(List<String> args)	Adds elements to a HyperLogLog key.
Future<Response>	RedisAPI.pfcount(List<String> args)	Returns the approximated cardinality of the set(s) observed by the HyperLogLog key(s).
Future<Response>	ValkeyAPI.pfcount(List<String> args)	Returns the approximated cardinality of the set(s) observed by the HyperLogLog key(s).
Future<Response>	RedisAPI.pfdebug(String arg0, String arg1)	Internal commands for debugging HyperLogLog values.
Future<Response>	ValkeyAPI.pfdebug(String arg0, String arg1)	Internal commands for debugging HyperLogLog values.
Future<Response>	RedisAPI.pfmerge(List<String> args)	Merges one or more HyperLogLog values into a single key.
Future<Response>	ValkeyAPI.pfmerge(List<String> args)	Merges one or more HyperLogLog values into a single key.
Future<Response>	RedisAPI.pfselftest()	An internal command for testing HyperLogLog values.
Future<Response>	ValkeyAPI.pfselftest()	An internal command for testing HyperLogLog values.
Future<Response>	RedisAPI.ping(List<String> args)	Returns the server's liveliness response.
Future<Response>	ValkeyAPI.ping(List<String> args)	Returns the server's liveliness response.
Future<Void>	RedisConnection.pipeTo(WriteStream<Response> dst)	Pipe this ReadStream to the WriteStream.
Future<Response>	RedisAPI.psetex(String arg0, String arg1, String arg2)	Sets both string value and expiration time in milliseconds of a key.
Future<Response>	ValkeyAPI.psetex(String arg0, String arg1, String arg2)	Sets both string value and expiration time in milliseconds of a key.
Future<Response>	RedisAPI.psubscribe(List<String> args)	Listens for messages published to channels that match one or more patterns.
Future<Response>	ValkeyAPI.psubscribe(List<String> args)	Listens for messages published to channels that match one or more patterns.
Future<Response>	RedisAPI.psync(List<String> args)	An internal command used in replication.
Future<Response>	ValkeyAPI.psync(List<String> args)	An internal command used in replication.
Future<Response>	RedisAPI.pttl(String arg0)	Returns the expiration time in milliseconds of a key.
Future<Response>	ValkeyAPI.pttl(String arg0)	Returns the expiration time in milliseconds of a key.
Future<Response>	RedisAPI.publish(String arg0, String arg1)	Posts a message to a channel.
Future<Response>	ValkeyAPI.publish(String arg0, String arg1)	Posts a message to a channel.
Future<Response>	RedisAPI.pubsub(List<String> args)	A container for Pub/Sub commands.
Future<Response>	ValkeyAPI.pubsub(List<String> args)	A container for Pub/Sub commands.
Future<Response>	RedisAPI.punsubscribe(List<String> args)	Stops listening to messages published to channels that match one or more patterns.
Future<Response>	ValkeyAPI.punsubscribe(List<String> args)	Stops listening to messages published to channels that match one or more patterns.
Future<Response>	RedisAPI.quit(List<String> args)	Closes the connection.
Future<Response>	ValkeyAPI.quit(List<String> args)	Closes the connection.
Future<Response>	RedisAPI.randomkey()	Returns a random key name from the database.
Future<Response>	ValkeyAPI.randomkey()	Returns a random key name from the database.
Future<Response>	RedisAPI.readonly()	Enables read-only queries for a connection to a Redis Cluster replica node.
Future<Response>	ValkeyAPI.readonly()	Enables read-only queries for a connection to a Valkey replica node.
Future<Response>	RedisAPI.readwrite()	Enables read-write queries for a connection to a Reids Cluster replica node.
Future<Response>	ValkeyAPI.readwrite()	Enables read-write queries for a connection to a Valkey replica node.
Future<Response>	RedisAPI.rename(String arg0, String arg1)	Renames a key and overwrites the destination.
Future<Response>	ValkeyAPI.rename(String arg0, String arg1)	Renames a key and overwrites the destination.
Future<Response>	RedisAPI.renamenx(String arg0, String arg1)	Renames a key only when the target key name doesn't exist.
Future<Response>	ValkeyAPI.renamenx(String arg0, String arg1)	Renames a key only when the target key name doesn't exist.
Future<Response>	RedisAPI.replconf(List<String> args)	An internal command for configuring the replication stream.
Future<Response>	ValkeyAPI.replconf(List<String> args)	An internal command for configuring the replication stream.
Future<Response>	RedisAPI.replicaof(String arg0, String arg1)	Configures a server as replica of another, or promotes it to a master.
Future<Response>	ValkeyAPI.replicaof(String arg0, String arg1)	Configures a server as replica of another, or promotes it to a primary.
Future<Response>	RedisAPI.reset()	Resets the connection.
Future<Response>	ValkeyAPI.reset()	Resets the connection.
Future<Response>	RedisAPI.restore(List<String> args)	Creates a key from the serialized representation of a value.
Future<Response>	ValkeyAPI.restore(List<String> args)	Creates a key from the serialized representation of a value.
Future<Response>	RedisAPI.restoreAsking(List<String> args)	An internal command for migrating keys in a cluster.
Future<Response>	ValkeyAPI.restoreAsking(List<String> args)	An internal command for migrating keys in a cluster.
Future<Response>	RedisAPI.role()	Returns the replication role.
Future<Response>	ValkeyAPI.role()	Returns the replication role.
Future<Response>	RedisAPI.rpop(List<String> args)	Returns and removes the last elements of a list.
Future<Response>	ValkeyAPI.rpop(List<String> args)	Returns and removes one or more elements from the end of a list.
Future<Response>	RedisAPI.rpoplpush(String arg0, String arg1)	Returns the last element of a list after removing and pushing it to another list.
Future<Response>	ValkeyAPI.rpoplpush(String arg0, String arg1)	Returns the last element of a list after removing and pushing it to another list.
Future<Response>	RedisAPI.rpush(List<String> args)	Appends one or more elements to a list.
Future<Response>	ValkeyAPI.rpush(List<String> args)	Appends one or more elements to a list.
Future<Response>	RedisAPI.rpushx(List<String> args)	Appends an element to a list only when the list exists.
Future<Response>	ValkeyAPI.rpushx(List<String> args)	Appends one or more elements to a list only when the list exists.
Future<Response>	RedisAPI.sadd(List<String> args)	Adds one or more members to a set.
Future<Response>	ValkeyAPI.sadd(List<String> args)	Adds one or more members to a set.
Future<Response>	RedisAPI.save()	Synchronously saves the database(s) to disk.
Future<Response>	ValkeyAPI.save()	Synchronously saves the database(s) to disk.
Future<Response>	RedisAPI.scan(List<String> args)	Iterates over the key names in the database.
Future<Response>	ValkeyAPI.scan(List<String> args)	Iterates over the key names in the database.
Future<Response>	RedisAPI.scard(String arg0)	Returns the number of members in a set.
Future<Response>	ValkeyAPI.scard(String arg0)	Returns the number of members in a set.
Future<Response>	RedisAPI.script(List<String> args)	A container for Lua scripts management commands.
Future<Response>	ValkeyAPI.script(List<String> args)	A container for Lua scripts management commands.
Future<Response>	RedisAPI.sdiff(List<String> args)	Returns the difference of multiple sets.
Future<Response>	ValkeyAPI.sdiff(List<String> args)	Returns the difference of multiple sets.
Future<Response>	RedisAPI.sdiffstore(List<String> args)	Stores the difference of multiple sets in a key.
Future<Response>	ValkeyAPI.sdiffstore(List<String> args)	Stores the difference of multiple sets in a key.
Future<Response>	RedisAPI.searchClusterinfo(List<String> args)
Future<Response>	RedisAPI.searchClusterrefresh(List<String> args)
Future<Response>	RedisAPI.searchClusterset(List<String> args)
Future<Response>	RedisAPI.select(String arg0)	Changes the selected database.
Future<Response>	ValkeyAPI.select(String arg0)	Changes the selected database.
Future<Response>	Redis.send(Request command)	Send the given command to the Redis server or cluster.
Future<Response>	RedisConnection.send(Request command)	Send the given command to the redis server or cluster.
Future<Response>	RedisAPI.set(List<String> args)	Sets the string value of a key, ignoring its type.
Future<Response>	ValkeyAPI.set(List<String> args)	Sets the string value of a key, ignoring its type.
Future<Response>	RedisAPI.setbit(String arg0, String arg1, String arg2)	Sets or clears the bit at offset of the string value.
Future<Response>	ValkeyAPI.setbit(String arg0, String arg1, String arg2)	Sets or clears the bit at offset of the string value.
Future<Response>	RedisAPI.setex(String arg0, String arg1, String arg2)	Sets the string value and expiration time of a key.
Future<Response>	ValkeyAPI.setex(String arg0, String arg1, String arg2)	Sets the string value and expiration time of a key.
Future<Response>	RedisAPI.setnx(String arg0, String arg1)	Set the string value of a key only when the key doesn't exist.
Future<Response>	ValkeyAPI.setnx(String arg0, String arg1)	Set the string value of a key only when the key doesn't exist.
Future<Response>	RedisAPI.setrange(String arg0, String arg1, String arg2)	Overwrites a part of a string value with another by an offset.
Future<Response>	ValkeyAPI.setrange(String arg0, String arg1, String arg2)	Overwrites a part of a string value with another by an offset.
Future<Response>	RedisAPI.shutdown(List<String> args)	Synchronously saves the database(s) to disk and shuts down the Redis server.
Future<Response>	ValkeyAPI.shutdown(List<String> args)	Synchronously saves the database(s) to disk and shuts down the server.
Future<Response>	RedisAPI.sinter(List<String> args)	Returns the intersect of multiple sets.
Future<Response>	ValkeyAPI.sinter(List<String> args)	Returns the intersect of multiple sets.
Future<Response>	RedisAPI.sintercard(List<String> args)	Returns the number of members of the intersect of multiple sets.
Future<Response>	ValkeyAPI.sintercard(List<String> args)	Returns the number of members of the intersect of multiple sets.
Future<Response>	RedisAPI.sinterstore(List<String> args)	Stores the intersect of multiple sets in a key.
Future<Response>	ValkeyAPI.sinterstore(List<String> args)	Stores the intersect of multiple sets in a key.
Future<Response>	RedisAPI.sismember(String arg0, String arg1)	Determines whether a member belongs to a set.
Future<Response>	ValkeyAPI.sismember(String arg0, String arg1)	Determines whether a member belongs to a set.
Future<Response>	RedisAPI.slaveof(String arg0, String arg1)	Sets a Redis server as a replica of another, or promotes it to being a master.
Future<Response>	ValkeyAPI.slaveof(String arg0, String arg1)	Sets a server as a replica of another, or promotes it to being a primary.
Future<Response>	RedisAPI.slowlog(List<String> args)	A container for slow log commands.
Future<Response>	ValkeyAPI.slowlog(List<String> args)	A container for slow log commands.
Future<Response>	RedisAPI.smembers(String arg0)	Returns all members of a set.
Future<Response>	ValkeyAPI.smembers(String arg0)	Returns all members of a set.
Future<Response>	RedisAPI.smismember(List<String> args)	Determines whether multiple members belong to a set.
Future<Response>	ValkeyAPI.smismember(List<String> args)	Determines whether multiple members belong to a set.
Future<Response>	RedisAPI.smove(String arg0, String arg1, String arg2)	Moves a member from one set to another.
Future<Response>	ValkeyAPI.smove(String arg0, String arg1, String arg2)	Moves a member from one set to another.
Future<Response>	RedisAPI.sort(List<String> args)	Sorts the elements in a list, a set, or a sorted set, optionally storing the result.
Future<Response>	ValkeyAPI.sort(List<String> args)	Sorts the elements in a list, a set, or a sorted set, optionally storing the result.
Future<Response>	RedisAPI.sortRo(List<String> args)	Returns the sorted elements of a list, a set, or a sorted set.
Future<Response>	ValkeyAPI.sortRo(List<String> args)	Returns the sorted elements of a list, a set, or a sorted set.
Future<Response>	RedisAPI.spop(List<String> args)	Returns one or more random members from a set after removing them.
Future<Response>	ValkeyAPI.spop(List<String> args)	Returns one or more random members from a set after removing them.
Future<Response>	RedisAPI.spublish(String arg0, String arg1)	Post a message to a shard channel.
Future<Response>	ValkeyAPI.spublish(String arg0, String arg1)	Post a message to a shard channel.
Future<Response>	RedisAPI.srandmember(List<String> args)	Get one or multiple random members from a set.
Future<Response>	ValkeyAPI.srandmember(List<String> args)	Get one or multiple random members from a set.
Future<Response>	RedisAPI.srem(List<String> args)	Removes one or more members from a set.
Future<Response>	ValkeyAPI.srem(List<String> args)	Removes one or more members from a set.
Future<Response>	RedisAPI.sscan(List<String> args)	Iterates over members of a set.
Future<Response>	ValkeyAPI.sscan(List<String> args)	Iterates over members of a set.
Future<Response>	RedisAPI.ssubscribe(List<String> args)	Listens for messages published to shard channels.
Future<Response>	ValkeyAPI.ssubscribe(List<String> args)	Listens for messages published to shard channels.
Future<Response>	RedisAPI.strlen(String arg0)	Returns the length of a string value.
Future<Response>	ValkeyAPI.strlen(String arg0)	Returns the length of a string value.
Future<Response>	RedisAPI.subscribe(List<String> args)	Listens for messages published to channels.
Future<Response>	ValkeyAPI.subscribe(List<String> args)	Listens for messages published to channels.
Future<Response>	RedisAPI.substr(String arg0, String arg1, String arg2)	Returns a substring from a string value.
Future<Response>	ValkeyAPI.substr(String arg0, String arg1, String arg2)	Returns a substring from a string value.
Future<Response>	RedisAPI.sunion(List<String> args)	Returns the union of multiple sets.
Future<Response>	ValkeyAPI.sunion(List<String> args)	Returns the union of multiple sets.
Future<Response>	RedisAPI.sunionstore(List<String> args)	Stores the union of multiple sets in a key.
Future<Response>	ValkeyAPI.sunionstore(List<String> args)	Stores the union of multiple sets in a key.
Future<Response>	RedisAPI.sunsubscribe(List<String> args)	Stops listening to messages posted to shard channels.
Future<Response>	ValkeyAPI.sunsubscribe(List<String> args)	Stops listening to messages posted to shard channels.
Future<Response>	RedisAPI.swapdb(String arg0, String arg1)	Swaps two Redis databases.
Future<Response>	ValkeyAPI.swapdb(String arg0, String arg1)	Swaps two databases.
Future<Response>	RedisAPI.sync()	An internal command used in replication.
Future<Response>	ValkeyAPI.sync()	An internal command used in replication.
Future<Response>	RedisAPI.tdigestAdd(List<String> args)	Adds one or more observations to a t-digest sketch.
Future<Response>	RedisAPI.tdigestByrank(List<String> args)	Returns, for each input rank, an estimation of the value (floating-point) with that rank.
Future<Response>	RedisAPI.tdigestByrevrank(List<String> args)	Returns, for each input reverse rank, an estimation of the value (floating-point) with that reverse rank.
Future<Response>	RedisAPI.tdigestCdf(List<String> args)	Returns, for each input value, an estimation of the floating-point fraction of (observations smaller than the given value + half the observations equal to the given value).
Future<Response>	RedisAPI.tdigestCreate(List<String> args)	Allocates memory and initializes a new t-digest sketch.
Future<Response>	RedisAPI.tdigestInfo(String arg0)	Returns information and statistics about a t-digest sketch.
Future<Response>	RedisAPI.tdigestInfo(List<String> args)	Returns information and statistics about a t-digest sketch.
Future<Response>	RedisAPI.tdigestMax(String arg0)	Returns the maximum observation value from a t-digest sketch.
Future<Response>	RedisAPI.tdigestMax(List<String> args)	Returns the maximum observation value from a t-digest sketch.
Future<Response>	RedisAPI.tdigestMerge(List<String> args)	Merges multiple t-digest sketches into a single sketch.
Future<Response>	RedisAPI.tdigestMin(String arg0)	Returns the minimum observation value from a t-digest sketch.
Future<Response>	RedisAPI.tdigestMin(List<String> args)	Returns the minimum observation value from a t-digest sketch.
Future<Response>	RedisAPI.tdigestQuantile(List<String> args)	Returns, for each input fraction, an estimation of the value (floating point) that is smaller than the given fraction of observations.
Future<Response>	RedisAPI.tdigestRank(List<String> args)	Returns, for each input value (floating-point), the estimated rank of the value (the number of observations in the sketch that are smaller than the value + half the number of observations that are equal to the value).
Future<Response>	RedisAPI.tdigestReset(String arg0)	Resets a t-digest sketch: empty the sketch and re-initializes it.
Future<Response>	RedisAPI.tdigestReset(List<String> args)	Resets a t-digest sketch: empty the sketch and re-initializes it.
Future<Response>	RedisAPI.tdigestRevrank(List<String> args)	Returns, for each input value (floating-point), the estimated reverse rank of the value (the number of observations in the sketch that are larger than the value + half the number of observations that are equal to the value).
Future<Response>	RedisAPI.tdigestTrimmedMean(String arg0, String arg1, String arg2)	Returns an estimation of the mean value from the sketch, excluding observation values outside the low and high cutoff quantiles.
Future<Response>	RedisAPI.tdigestTrimmedMean(List<String> args)	Returns an estimation of the mean value from the sketch, excluding observation values outside the low and high cutoff quantiles.
Future<Response>	RedisAPI.time()	Returns the server time.
Future<Response>	ValkeyAPI.time()	Returns the server time.
Future<Response>	RedisAPI.timeseriesClusterset(List<String> args)
Future<Response>	RedisAPI.timeseriesClustersetfromshard(List<String> args)
Future<Response>	RedisAPI.timeseriesHello(List<String> args)
Future<Response>	RedisAPI.timeseriesInfocluster(List<String> args)
Future<Response>	RedisAPI.timeseriesInnercommunication(List<String> args)
Future<Response>	RedisAPI.timeseriesNetworktest(List<String> args)
Future<Response>	RedisAPI.timeseriesRefreshcluster(List<String> args)
Future<Response>	RedisAPI.topkAdd(List<String> args)	Adds an item to a Top-k sketch.
Future<Response>	RedisAPI.topkCount(List<String> args)	Return the count for one or more items are in a sketch.
Future<Response>	RedisAPI.topkIncrby(List<String> args)	Increases the count of one or more items by increment.
Future<Response>	RedisAPI.topkInfo(String arg0)	Returns information about a sketch.
Future<Response>	RedisAPI.topkInfo(List<String> args)	Returns information about a sketch.
Future<Response>	RedisAPI.topkList(List<String> args)	Return the full list of items in Top-K sketch.
Future<Response>	RedisAPI.topkQuery(List<String> args)	Checks whether one or more items are in a sketch.
Future<Response>	RedisAPI.topkReserve(List<String> args)	Initializes a Top-K sketch with specified parameters.
Future<Response>	RedisAPI.touch(List<String> args)	Returns the number of existing keys out of those specified after updating the time they were last accessed.
Future<Response>	ValkeyAPI.touch(List<String> args)	Returns the number of existing keys out of those specified after updating the time they were last accessed.
Future<Response>	RedisAPI.trimslots(List<String> args)	Trim the keys that belong to specified slots.
Future<Response>	RedisAPI.tsAdd(List<String> args)	Append a sample to a time series.
Future<Response>	RedisAPI.tsAlter(List<String> args)	Update the retention, chunk size, duplicate policy, and labels of an existing time series.
Future<Response>	RedisAPI.tsCreate(List<String> args)	Create a new time series.
Future<Response>	RedisAPI.tsCreaterule(List<String> args)	Create a compaction rule.
Future<Response>	RedisAPI.tsDecrby(List<String> args)	Decrease the value of the latest sample.
Future<Response>	RedisAPI.tsDel(String arg0, String arg1, String arg2)	Delete all samples between two timestamps for a given time series.
Future<Response>	RedisAPI.tsDel(List<String> args)	Delete all samples between two timestamps for a given time series.
Future<Response>	RedisAPI.tsDeleterule(String arg0, String arg1)	Delete a compaction rule.
Future<Response>	RedisAPI.tsDeleterule(List<String> args)	Delete a compaction rule.
Future<Response>	RedisAPI.tsGet(List<String> args)	Get the sample with the highest timestamp from a given time series.
Future<Response>	RedisAPI.tsIncrby(List<String> args)	Increase the value of the latest sample.
Future<Response>	RedisAPI.tsInfo(List<String> args)	Returns information and statistics for a time series.
Future<Response>	RedisAPI.tsMadd(List<String> args)	Append new samples to one or more time series.
Future<Response>	RedisAPI.tsMget(List<String> args)	Get the sample with the highest timestamp from each time series matching a specific filter.
Future<Response>	RedisAPI.tsMrange(List<String> args)	Query a range across multiple time series by filters in forward direction.
Future<Response>	RedisAPI.tsMrevrange(List<String> args)	Query a range across multiple time series by filters in reverse direction.
Future<Response>	RedisAPI.tsQueryindex(List<String> args)	Get all time series keys matching a filter list.
Future<Response>	RedisAPI.tsRange(List<String> args)	Query a range in forward direction.
Future<Response>	RedisAPI.tsRevrange(List<String> args)	Query a range in reverse direction.
Future<Response>	RedisAPI.ttl(String arg0)	Returns the expiration time in seconds of a key.
Future<Response>	ValkeyAPI.ttl(String arg0)	Returns the expiration time in seconds of a key.
Future<Response>	RedisAPI.type(String arg0)	Determines the type of value stored at a key.
Future<Response>	ValkeyAPI.type(String arg0)	Determines the type of value stored at a key.
Future<Response>	RedisAPI.unlink(List<String> args)	Asynchronously deletes one or more keys.
Future<Response>	ValkeyAPI.unlink(List<String> args)	Asynchronously deletes one or more keys.
Future<Response>	RedisAPI.unsubscribe(List<String> args)	Stops listening to messages posted to channels.
Future<Response>	ValkeyAPI.unsubscribe(List<String> args)	Stops listening to messages posted to channels.
Future<Response>	RedisAPI.unwatch()	Forgets about watched keys of a transaction.
Future<Response>	ValkeyAPI.unwatch()	Forgets about watched keys of a transaction.
Future<Response>	RedisAPI.vadd(List<String> args)	Add one or more elements to a vector set, or update its vector if it already exists.
Future<Response>	RedisAPI.vcard(String arg0)	Return the number of elements in a vector set.
Future<Response>	RedisAPI.vdim(String arg0)	Return the dimension of vectors in the vector set.
Future<Response>	RedisAPI.vemb(List<String> args)	Return the vector associated with an element.
Future<Response>	RedisAPI.vgetattr(String arg0, String arg1)	Retrieve the JSON attributes of elements.
Future<Response>	RedisAPI.vinfo(String arg0)	Return information about a vector set.
Future<Response>	RedisAPI.vismember(String arg0, String arg1)	Check if an element exists in a vector set.
Future<Response>	RedisAPI.vlinks(List<String> args)	Return the neighbors of an element at each layer in the HNSW graph.
Future<Response>	RedisAPI.vrandmember(List<String> args)	Return one or multiple random members from a vector set.
Future<Response>	RedisAPI.vrange(List<String> args)	Return vector set elements in a lex range.
Future<Response>	RedisAPI.vrem(String arg0, String arg1)	Remove an element from a vector set.
Future<Response>	RedisAPI.vsetattr(String arg0, String arg1, String arg2)	Associate or remove the JSON attributes of elements.
Future<Response>	RedisAPI.vsim(List<String> args)	Return elements by vector similarity.
Future<Response>	RedisAPI.wait(String arg0, String arg1)	Blocks until the asynchronous replication of all preceding write commands sent by the connection is completed.
Future<Response>	ValkeyAPI.wait(String arg0, String arg1)	Blocks until the asynchronous replication of all preceding write commands sent by the connection is completed.
Future<Response>	RedisAPI.waitaof(String arg0, String arg1, String arg2)	Blocks until all of the preceding write commands sent by the connection are written to the append-only file of the master and/or replicas.
Future<Response>	ValkeyAPI.waitaof(String arg0, String arg1, String arg2)	Blocks until all of the preceding write commands sent by the connection are written to the append-only file of the primary and/or replicas.
Future<Response>	RedisAPI.watch(List<String> args)	Monitors changes to keys to determine the execution of a transaction.
Future<Response>	ValkeyAPI.watch(List<String> args)	Monitors changes to keys to determine the execution of a transaction.
Future<Response>	RedisAPI.xack(List<String> args)	Returns the number of messages that were successfully acknowledged by the consumer group member of a stream.
Future<Response>	ValkeyAPI.xack(List<String> args)	Returns the number of messages that were successfully acknowledged by the consumer group member of a stream.
Future<Response>	RedisAPI.xackdel(List<String> args)	Acknowledges and deletes one or multiple messages for a stream consumer group.
Future<Response>	RedisAPI.xadd(List<String> args)	Appends a new message to a stream.
Future<Response>	ValkeyAPI.xadd(List<String> args)	Appends a new message to a stream.
Future<Response>	RedisAPI.xautoclaim(List<String> args)	Changes, or acquires, ownership of messages in a consumer group, as if the messages were delivered to as consumer group member.
Future<Response>	ValkeyAPI.xautoclaim(List<String> args)	Changes, or acquires, ownership of messages in a consumer group, as if the messages were delivered to as consumer group member.
Future<Response>	RedisAPI.xcfgset(List<String> args)	Sets the IDMP configuration parameters for a stream.
Future<Response>	RedisAPI.xclaim(List<String> args)	Changes, or acquires, ownership of a message in a consumer group, as if the message was delivered a consumer group member.
Future<Response>	ValkeyAPI.xclaim(List<String> args)	Changes, or acquires, ownership of a message in a consumer group, as if the message was delivered a consumer group member.
Future<Response>	RedisAPI.xdel(List<String> args)	Returns the number of messages after removing them from a stream.
Future<Response>	ValkeyAPI.xdel(List<String> args)	Returns the number of messages after removing them from a stream.
Future<Response>	RedisAPI.xdelex(List<String> args)	Deletes one or multiple entries from the stream.
Future<Response>	RedisAPI.xgroup(List<String> args)	A container for consumer groups commands.
Future<Response>	ValkeyAPI.xgroup(List<String> args)	A container for consumer groups commands.
Future<Response>	RedisAPI.xidmprecord(String arg0, String arg1, String arg2, String arg3)	An internal command for setting IDMP metadata on an existing stream message.
Future<Response>	RedisAPI.xinfo(List<String> args)	A container for stream introspection commands.
Future<Response>	ValkeyAPI.xinfo(List<String> args)	A container for stream introspection commands.
Future<Response>	RedisAPI.xlen(String arg0)	Return the number of messages in a stream.
Future<Response>	ValkeyAPI.xlen(String arg0)	Return the number of messages in a stream.
Future<Response>	RedisAPI.xpending(List<String> args)	Returns the information and entries from a stream consumer group's pending entries list.
Future<Response>	ValkeyAPI.xpending(List<String> args)	Returns the information and entries from a stream consumer group's pending entries list.
Future<Response>	RedisAPI.xrange(List<String> args)	Returns the messages from a stream within a range of IDs.
Future<Response>	ValkeyAPI.xrange(List<String> args)	Returns the messages from a stream within a range of IDs.
Future<Response>	RedisAPI.xread(List<String> args)	Returns messages from multiple streams with IDs greater than the ones requested.
Future<Response>	ValkeyAPI.xread(List<String> args)	Returns messages from multiple streams with IDs greater than the ones requested.
Future<Response>	RedisAPI.xreadgroup(List<String> args)	Returns new or historical messages from a stream for a consumer in a group.
Future<Response>	ValkeyAPI.xreadgroup(List<String> args)	Returns new or historical messages from a stream for a consumer in a group.
Future<Response>	RedisAPI.xrevrange(List<String> args)	Returns the messages from a stream within a range of IDs in reverse order.
Future<Response>	ValkeyAPI.xrevrange(List<String> args)	Returns the messages from a stream within a range of IDs in reverse order.
Future<Response>	RedisAPI.xsetid(List<String> args)	An internal command for replicating stream values.
Future<Response>	ValkeyAPI.xsetid(List<String> args)	An internal command for replicating stream values.
Future<Response>	RedisAPI.xtrim(List<String> args)	Deletes messages from the beginning of a stream.
Future<Response>	ValkeyAPI.xtrim(List<String> args)	Deletes messages from the beginning of a stream.
Future<Response>	RedisAPI.zadd(List<String> args)	Adds one or more members to a sorted set, or updates their scores.
Future<Response>	ValkeyAPI.zadd(List<String> args)	Adds one or more members to a sorted set, or updates their scores.
Future<Response>	RedisAPI.zcard(String arg0)	Returns the number of members in a sorted set.
Future<Response>	ValkeyAPI.zcard(String arg0)	Returns the number of members in a sorted set.
Future<Response>	RedisAPI.zcount(String arg0, String arg1, String arg2)	Returns the count of members in a sorted set that have scores within a range.
Future<Response>	ValkeyAPI.zcount(String arg0, String arg1, String arg2)	Returns the count of members in a sorted set that have scores within a range.
Future<Response>	RedisAPI.zdiff(List<String> args)	Returns the difference between multiple sorted sets.
Future<Response>	ValkeyAPI.zdiff(List<String> args)	Returns the difference between multiple sorted sets.
Future<Response>	RedisAPI.zdiffstore(List<String> args)	Stores the difference of multiple sorted sets in a key.
Future<Response>	ValkeyAPI.zdiffstore(List<String> args)	Stores the difference of multiple sorted sets in a key.
Future<Response>	RedisAPI.zincrby(String arg0, String arg1, String arg2)	Increments the score of a member in a sorted set.
Future<Response>	ValkeyAPI.zincrby(String arg0, String arg1, String arg2)	Increments the score of a member in a sorted set.
Future<Response>	RedisAPI.zinter(List<String> args)	Returns the intersect of multiple sorted sets.
Future<Response>	ValkeyAPI.zinter(List<String> args)	Returns the intersect of multiple sorted sets.
Future<Response>	RedisAPI.zintercard(List<String> args)	Returns the number of members of the intersect of multiple sorted sets.
Future<Response>	ValkeyAPI.zintercard(List<String> args)	Returns the number of members of the intersect of multiple sorted sets.
Future<Response>	RedisAPI.zinterstore(List<String> args)	Stores the intersect of multiple sorted sets in a key.
Future<Response>	ValkeyAPI.zinterstore(List<String> args)	Stores the intersect of multiple sorted sets in a key.
Future<Response>	RedisAPI.zlexcount(String arg0, String arg1, String arg2)	Returns the number of members in a sorted set within a lexicographical range.
Future<Response>	ValkeyAPI.zlexcount(String arg0, String arg1, String arg2)	Returns the number of members in a sorted set within a lexicographical range.
Future<Response>	RedisAPI.zmpop(List<String> args)	Returns the highest- or lowest-scoring members from one or more sorted sets after removing them.
Future<Response>	ValkeyAPI.zmpop(List<String> args)	Returns the highest- or lowest-scoring members from one or more sorted sets after removing them.
Future<Response>	RedisAPI.zmscore(List<String> args)	Returns the score of one or more members in a sorted set.
Future<Response>	ValkeyAPI.zmscore(List<String> args)	Returns the score of one or more members in a sorted set.
Future<Response>	RedisAPI.zpopmax(List<String> args)	Returns the highest-scoring members from a sorted set after removing them.
Future<Response>	ValkeyAPI.zpopmax(List<String> args)	Returns the highest-scoring members from a sorted set after removing them.
Future<Response>	RedisAPI.zpopmin(List<String> args)	Returns the lowest-scoring members from a sorted set after removing them.
Future<Response>	ValkeyAPI.zpopmin(List<String> args)	Returns the lowest-scoring members from a sorted set after removing them.
Future<Response>	RedisAPI.zrandmember(List<String> args)	Returns one or more random members from a sorted set.
Future<Response>	ValkeyAPI.zrandmember(List<String> args)	Returns one or more random members from a sorted set.
Future<Response>	RedisAPI.zrange(List<String> args)	Returns members in a sorted set within a range of indexes.
Future<Response>	ValkeyAPI.zrange(List<String> args)	Returns members in a sorted set within a range of indexes.
Future<Response>	RedisAPI.zrangebylex(List<String> args)	Returns members in a sorted set within a lexicographical range.
Future<Response>	ValkeyAPI.zrangebylex(List<String> args)	Returns members in a sorted set within a lexicographical range.
Future<Response>	RedisAPI.zrangebyscore(List<String> args)	Returns members in a sorted set within a range of scores.
Future<Response>	ValkeyAPI.zrangebyscore(List<String> args)	Returns members in a sorted set within a range of scores.
Future<Response>	RedisAPI.zrangestore(List<String> args)	Stores a range of members from sorted set in a key.
Future<Response>	ValkeyAPI.zrangestore(List<String> args)	Stores a range of members from sorted set in a key.
Future<Response>	RedisAPI.zrank(String arg0, String arg1)	Returns the index of a member in a sorted set ordered by ascending scores.
Future<Response>	RedisAPI.zrank(List<String> args)	Returns the index of a member in a sorted set ordered by ascending scores.
Future<Response>	ValkeyAPI.zrank(List<String> args)	Returns the index of a member in a sorted set ordered by ascending scores.
Future<Response>	RedisAPI.zrem(List<String> args)	Removes one or more members from a sorted set.
Future<Response>	ValkeyAPI.zrem(List<String> args)	Removes one or more members from a sorted set.
Future<Response>	RedisAPI.zremrangebylex(String arg0, String arg1, String arg2)	Removes members in a sorted set within a lexicographical range.
Future<Response>	ValkeyAPI.zremrangebylex(String arg0, String arg1, String arg2)	Removes members in a sorted set within a lexicographical range.
Future<Response>	RedisAPI.zremrangebyrank(String arg0, String arg1, String arg2)	Removes members in a sorted set within a range of indexes.
Future<Response>	ValkeyAPI.zremrangebyrank(String arg0, String arg1, String arg2)	Removes members in a sorted set within a range of indexes.
Future<Response>	RedisAPI.zremrangebyscore(String arg0, String arg1, String arg2)	Removes members in a sorted set within a range of scores.
Future<Response>	ValkeyAPI.zremrangebyscore(String arg0, String arg1, String arg2)	Removes members in a sorted set within a range of scores.
Future<Response>	RedisAPI.zrevrange(List<String> args)	Returns members in a sorted set within a range of indexes in reverse order.
Future<Response>	ValkeyAPI.zrevrange(List<String> args)	Returns members in a sorted set within a range of indexes in reverse order.
Future<Response>	RedisAPI.zrevrangebylex(List<String> args)	Returns members in a sorted set within a lexicographical range in reverse order.
Future<Response>	ValkeyAPI.zrevrangebylex(List<String> args)	Returns members in a sorted set within a lexicographical range in reverse order.
Future<Response>	RedisAPI.zrevrangebyscore(List<String> args)	Returns members in a sorted set within a range of scores in reverse order.
Future<Response>	ValkeyAPI.zrevrangebyscore(List<String> args)	Returns members in a sorted set within a range of scores in reverse order.
Future<Response>	RedisAPI.zrevrank(String arg0, String arg1)	Returns the index of a member in a sorted set ordered by descending scores.
Future<Response>	RedisAPI.zrevrank(List<String> args)	Returns the index of a member in a sorted set ordered by descending scores.
Future<Response>	ValkeyAPI.zrevrank(List<String> args)	Returns the index of a member in a sorted set ordered by descending scores.
Future<Response>	RedisAPI.zscan(List<String> args)	Iterates over members and scores of a sorted set.
Future<Response>	ValkeyAPI.zscan(List<String> args)	Iterates over members and scores of a sorted set.
Future<Response>	RedisAPI.zscore(String arg0, String arg1)	Returns the score of a member in a sorted set.
Future<Response>	ValkeyAPI.zscore(String arg0, String arg1)	Returns the score of a member in a sorted set.
Future<Response>	RedisAPI.zunion(List<String> args)	Returns the union of multiple sorted sets.
Future<Response>	ValkeyAPI.zunion(List<String> args)	Returns the union of multiple sorted sets.
Future<Response>	RedisAPI.zunionstore(List<String> args)	Stores the union of multiple sorted sets in a key.
Future<Response>	ValkeyAPI.zunionstore(List<String> args)	Stores the union of multiple sorted sets in a key.

Method parameters in io.vertx.reactivex.redis.client with type arguments of type Future

Modifier and Type	Method	Description
static Redis	Redis.createClusterClient(Vertx vertx, RedisOptions options, Supplier<Future<RedisClusterConnectOptions>> connectOptions)	Creates a new cluster Redis client.
static Redis	Redis.createReplicationClient(Vertx vertx, RedisOptions options, Supplier<Future<RedisReplicationConnectOptions>> connectOptions)	Creates a new replication Redis client.
static Redis	Redis.createSentinelClient(Vertx vertx, RedisOptions options, Supplier<Future<RedisSentinelConnectOptions>> connectOptions)	Creates a new sentinel Redis client.
static Redis	Redis.createStandaloneClient(Vertx vertx, RedisOptions options, Supplier<Future<RedisStandaloneConnectOptions>> connectOptions)	Creates a new standalone Redis client.

Uses of Future in io.vertx.reactivex.servicediscovery

Methods in io.vertx.reactivex.servicediscovery that return Future

Modifier and Type	Method	Description
Future<Record>	ServiceDiscovery.getRecord(JsonObject filter)	Lookups for a single record.
Future<Record>	ServiceDiscovery.getRecord(String id)	Looks up for a single record by its registration id.
Future<Record>	ServiceDiscovery.getRecord(Function<Record,Boolean> filter)	Lookups for a single record.
Future<Record>	ServiceDiscovery.getRecord(Function<Record,Boolean> filter, boolean includeOutOfService)	Lookups for a single record.
Future<List<Record>>	ServiceDiscovery.getRecords(JsonObject filter)	Lookups for a set of records.
Future<List<Record>>	ServiceDiscovery.getRecords(Function<Record,Boolean> filter)	Lookups for a set of records.
Future<List<Record>>	ServiceDiscovery.getRecords(Function<Record,Boolean> filter, boolean includeOutOfService)	Lookups for a set of records.
Future<Record>	ServiceDiscovery.publish(Record record)	Publishes a record.
Future<Void>	ServiceDiscovery.registerServiceExporter(ServiceExporter exporter, JsonObject configuration)	Registers a discovery bridge.
Future<Void>	ServiceDiscovery.registerServiceImporter(ServiceImporter importer, JsonObject configuration)	Registers a discovery service importer.
Future<Void>	ServiceDiscovery.unpublish(String id)	Un-publishes a record.
Future<Record>	ServiceDiscovery.update(Record record)	Updates the given record.

Uses of Future in io.vertx.reactivex.servicediscovery.spi

Methods in io.vertx.reactivex.servicediscovery.spi that return Future

Modifier and Type	Method	Description
Future<Record>	ServicePublisher.publish(Record record)	Publishes a record.
Future<Void>	ServicePublisher.unpublish(String id)	Un-publishes a record.
Future<Record>	ServicePublisher.update(Record record)	Updates an existing record.

Uses of Future in io.vertx.reactivex.servicediscovery.types

Methods in io.vertx.reactivex.servicediscovery.types that return Future

Modifier and Type	Method	Description
static Future<HttpClient>	HttpEndpoint.getClient(ServiceDiscovery discovery, JsonObject filter)	Convenient method that looks for a HTTP endpoint and provides the configured .
static Future<HttpClient>	HttpEndpoint.getClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf)	Convenient method that looks for a HTTP endpoint and provides the configured .
static Future<HttpClient>	HttpEndpoint.getClient(ServiceDiscovery discovery, Function<Record,Boolean> filter)	Convenient method that looks for a HTTP endpoint and provides the configured .
static Future<HttpClient>	HttpEndpoint.getClient(ServiceDiscovery discovery, Function<Record,Boolean> filter, JsonObject conf)	Convenient method that looks for a HTTP endpoint and provides the configured .
static <T> Future<MessageConsumer<T>>	MessageSource.getConsumer(ServiceDiscovery discovery, JsonObject filter)	Convenient method that looks for a message source and provides the configured .
static <T> Future<MessageConsumer<T>>	MessageSource.getConsumer(ServiceDiscovery discovery, Function<Record,Boolean> filter)	Convenient method that looks for a message source and provides the configured .
static Future<MongoClient>	MongoDataSource.getMongoClient(ServiceDiscovery discovery, JsonObject filter)	Convenient method that looks for a Mongo datasource source and provides the configured MongoClient.
static Future<MongoClient>	MongoDataSource.getMongoClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration)	Convenient method that looks for a Mongo datasource source and provides the configured MongoClient.
static Future<MongoClient>	MongoDataSource.getMongoClient(ServiceDiscovery discovery, Function<Record,Boolean> filter)	Convenient method that looks for a Mongo datasource source and provides the configured MongoClient.
static Future<Redis>	RedisDataSource.getRedisClient(ServiceDiscovery discovery, JsonObject filter)	Convenient method that looks for a Redis data source and provides the configured Redis.
static Future<Redis>	RedisDataSource.getRedisClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration)	Convenient method that looks for a Redis data source and provides the configured Redis.
static Future<Redis>	RedisDataSource.getRedisClient(ServiceDiscovery discovery, Function<Record,Boolean> filter)	Convenient method that looks for a Redis data source and provides the configured Redis.
static Future<Redis>	RedisDataSource.getRedisClient(ServiceDiscovery discovery, Function<Record,Boolean> filter, JsonObject consumerConfiguration)	Convenient method that looks for a Redis data source and provides the configured Redis.
static <T> Future<T>	EventBusService.getServiceProxy(ServiceDiscovery discovery, Function<Record,Boolean> filter, Class<T> clientClass)	Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
static <T> Future<T>	EventBusService.getServiceProxy(ServiceDiscovery discovery, Function<Record,Boolean> filter, Class<T> clientClass, JsonObject conf)	Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
static <T> Future<T>	EventBusService.getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass)	Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
static <T> Future<T>	EventBusService.getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, JsonObject conf)	Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
static Future<WebClient>	HttpEndpoint.getWebClient(ServiceDiscovery discovery, JsonObject filter)	Convenient method that looks for a HTTP endpoint and provides the configured .
static Future<WebClient>	HttpEndpoint.getWebClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf)	Convenient method that looks for a HTTP endpoint and provides the configured .
static Future<WebClient>	HttpEndpoint.getWebClient(ServiceDiscovery discovery, Function<Record,Boolean> filter)	Convenient method that looks for a HTTP endpoint and provides the configured .
static Future<WebClient>	HttpEndpoint.getWebClient(ServiceDiscovery discovery, Function<Record,Boolean> filter, JsonObject conf)	Convenient method that looks for a HTTP endpoint and provides the configured .

Uses of Future in io.vertx.reactivex.sqlclient

Methods in io.vertx.reactivex.sqlclient that return Future

Modifier and Type	Method	Description
Future<Transaction>	SqlConnection.begin()	Begin a transaction and returns a Transaction for controlling and tracking this transaction.
Future<Void>	Cursor.close()	Release the cursor.
Future<Void>	PreparedStatement.close()	Close the prepared query and release its resources.
Future<Void>	RowStream.close()	Close the stream and release the resources.
Future<Void>	SqlClient.close()	Close the client and release the associated resources.
Future<Void>	Transaction.commit()	Commit the current transaction.
Future<Void>	Transaction.completion()	Return the transaction completion Future that succeeds when the transaction commits and fails with TransactionRollbackException when the transaction rolls back.
Future<T>	PreparedQuery.execute()	Execute the query.
Future<T>	PreparedQuery.execute(Tuple tuple)	Execute the query.
Future<T>	Query.execute()	Execute the query.
Future<T>	PreparedQuery.executeBatch(List<Tuple> batch)	Execute the query with a batch of tuples.
Future<SqlConnection>	Pool.getConnection()	Get a connection from the pool.
Future<Void>	RowStream.pipeTo(WriteStream<T> dst)	Pipe this ReadStream to the WriteStream.
Future<PreparedStatement>	SqlConnection.prepare(String sql)	Create a prepared statement using the given sql string.
Future<PreparedStatement>	SqlConnection.prepare(String sql, PrepareOptions options)	Create a prepared statement using the given sql string.
Future<RowSet<Row>>	Cursor.read(int count)	Read rows from the cursor, the result is provided asynchronously to the handler.
Future<Void>	Transaction.rollback()	Rollback the transaction and release the associated resources.
<T> Future<T>	Pool.withConnection(Function<SqlConnection, Maybe<T>> function)	Get a connection from the pool and execute the given function.
<T> Future<T>	Pool.withConnection(Function<SqlConnection, Future<T>> function)	Get a connection from the pool and execute the given function.
<T> Future<T>	Pool.withTransaction(Function<SqlConnection, Maybe<T>> function)	Execute the given function within a transaction.
<T> Future<T>	Pool.withTransaction(TransactionPropagation txPropagation, Function<SqlConnection, Maybe<T>> function)	Like Pool.withTransaction(Function) but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
<T> Future<T>	Pool.withTransaction(TransactionPropagation txPropagation, Function<SqlConnection, Future<T>> function)	Like Pool.withTransaction(Function) but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
<T> Future<T>	Pool.withTransaction(Function<SqlConnection, Future<T>> function)	Execute the given function within a transaction.

Method parameters in io.vertx.reactivex.sqlclient with type arguments of type Future

Modifier and Type	Method	Description
ClientBuilder<C>	ClientBuilder.connectingTo(Supplier<Future<SqlConnectOptions>> supplier)	Configure the database the client should connect to.
<T> Maybe<T>	Pool.rxWithConnection(Function<SqlConnection, Future<T>> function)	Get a connection from the pool and execute the given function.
<T> Maybe<T>	Pool.rxWithTransaction(TransactionPropagation txPropagation, Function<SqlConnection, Future<T>> function)	Like Pool.withTransaction(Function) but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
<T> Maybe<T>	Pool.rxWithTransaction(Function<SqlConnection, Future<T>> function)	Execute the given function within a transaction.
<T> Future<T>	Pool.withConnection(Function<SqlConnection, Future<T>> function)	Get a connection from the pool and execute the given function.
<T> Future<T>	Pool.withTransaction(TransactionPropagation txPropagation, Function<SqlConnection, Future<T>> function)	Like Pool.withTransaction(Function) but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
<T> Future<T>	Pool.withTransaction(Function<SqlConnection, Future<T>> function)	Execute the given function within a transaction.

Uses of Future in io.vertx.reactivex.sqlclient.templates

Methods in io.vertx.reactivex.sqlclient.templates that return Future

Modifier and Type	Method	Description
Future<R>	SqlTemplate.execute(I params)	Execute the query with the parameters
Future<R>	SqlTemplate.executeBatch(List<I> batch)	Execute a batch query with the batch.

Uses of Future in io.vertx.redis.client

Methods in io.vertx.redis.client that return Future

Modifier and Type	Method	Description
default Future<Response>	RedisAPI.acl(List<String> args)	A container for Access List Control commands.
default Future<Response>	ValkeyAPI.acl(List<String> args)	A container for Access List Control commands.
default Future<Response>	RedisAPI.append(String arg0, String arg1)	Appends a string to the value of a key.
default Future<Response>	ValkeyAPI.append(String arg0, String arg1)	Appends a string to the value of a key.
default Future<Response>	RedisAPI.asking()	Signals that a cluster client is following an -ASK redirect.
default Future<Response>	ValkeyAPI.asking()	Signals that a cluster client is following an -ASK redirect.
default Future<Response>	RedisAPI.auth(List<String> args)	Authenticates the connection.
default Future<Response>	ValkeyAPI.auth(List<String> args)	Authenticates the connection.
Future<List<Response>>	Redis.batch(List<Request> commands)	Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
Future<List<Response>>	RedisConnection.batch(List<Request> commands)	Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other client users.
default Future<Response>	RedisAPI.bfAdd(String arg0, String arg1)	Adds an item to a Bloom Filter.
default Future<Response>	RedisAPI.bfAdd(List<String> args)	Adds an item to a Bloom Filter.
default Future<Response>	RedisAPI.bfCard(String arg0)	Returns the cardinality of a Bloom filter.
default Future<Response>	RedisAPI.bfCard(List<String> args)	Returns the cardinality of a Bloom filter.
default Future<Response>	RedisAPI.bfDebug(List<String> args)
default Future<Response>	RedisAPI.bfExists(String arg0, String arg1)	Checks whether an item exists in a Bloom Filter.
default Future<Response>	RedisAPI.bfExists(List<String> args)	Checks whether an item exists in a Bloom Filter.
default Future<Response>	RedisAPI.bfInfo(List<String> args)	Returns information about a Bloom Filter.
default Future<Response>	RedisAPI.bfInsert(List<String> args)	Adds one or more items to a Bloom Filter.
default Future<Response>	RedisAPI.bfLoadchunk(String arg0, String arg1, String arg2)	Restores a filter previously saved using SCANDUMP.
default Future<Response>	RedisAPI.bfLoadchunk(List<String> args)	Restores a filter previously saved using SCANDUMP.
default Future<Response>	RedisAPI.bfMadd(List<String> args)	Adds one or more items to a Bloom Filter.
default Future<Response>	RedisAPI.bfMexists(List<String> args)	Checks whether one or more items exist in a Bloom Filter.
default Future<Response>	RedisAPI.bfReserve(List<String> args)	Creates a new Bloom Filter.
default Future<Response>	RedisAPI.bfScandump(String arg0, String arg1)	Begins an incremental save of the bloom filter.
default Future<Response>	RedisAPI.bfScandump(List<String> args)	Begins an incremental save of the bloom filter.
default Future<Response>	RedisAPI.bgrewriteaof()	Asynchronously rewrites the append-only file to disk.
default Future<Response>	ValkeyAPI.bgrewriteaof()	Asynchronously rewrites the append-only file to disk.
default Future<Response>	RedisAPI.bgsave(List<String> args)	Asynchronously saves the database(s) to disk.
default Future<Response>	ValkeyAPI.bgsave(List<String> args)	Asynchronously saves the database(s) to disk.
default Future<Response>	RedisAPI.bitcount(List<String> args)	Counts the number of set bits (population counting) in a string.
default Future<Response>	ValkeyAPI.bitcount(List<String> args)	Counts the number of set bits (population counting) in a string.
default Future<Response>	RedisAPI.bitfield(List<String> args)	Performs arbitrary bitfield integer operations on strings.
default Future<Response>	ValkeyAPI.bitfield(List<String> args)	Performs arbitrary bitfield integer operations on strings.
default Future<Response>	RedisAPI.bitfieldRo(List<String> args)	Performs arbitrary read-only bitfield integer operations on strings.
default Future<Response>	ValkeyAPI.bitfieldRo(List<String> args)	Performs arbitrary read-only bitfield integer operations on strings.
default Future<Response>	RedisAPI.bitop(List<String> args)	Performs bitwise operations on multiple strings, and stores the result.
default Future<Response>	ValkeyAPI.bitop(List<String> args)	Performs bitwise operations on multiple strings, and stores the result.
default Future<Response>	RedisAPI.bitpos(List<String> args)	Finds the first set (1) or clear (0) bit in a string.
default Future<Response>	ValkeyAPI.bitpos(List<String> args)	Finds the first set (1) or clear (0) bit in a string.
default Future<Response>	RedisAPI.blmove(String arg0, String arg1, String arg2, String arg3, String arg4)	Pops an element from a list, pushes it to another list and returns it.
default Future<Response>	ValkeyAPI.blmove(String arg0, String arg1, String arg2, String arg3, String arg4)	Pops an element from a list, pushes it to another list and returns it.
default Future<Response>	RedisAPI.blmpop(List<String> args)	Pops the first element from one of multiple lists.
default Future<Response>	ValkeyAPI.blmpop(List<String> args)	Pops the first element from one of multiple lists.
default Future<Response>	RedisAPI.blpop(List<String> args)	Removes and returns the first element in a list.
default Future<Response>	ValkeyAPI.blpop(List<String> args)	Removes and returns the first element in a list.
default Future<Response>	RedisAPI.brpop(List<String> args)	Removes and returns the last element in a list.
default Future<Response>	ValkeyAPI.brpop(List<String> args)	Removes and returns the last element in a list.
default Future<Response>	RedisAPI.brpoplpush(String arg0, String arg1, String arg2)	Deprecated. since Redis 6.2.0, replaced by: BLMOVE with the RIGHT and LEFT arguments
default Future<Response>	ValkeyAPI.brpoplpush(String arg0, String arg1, String arg2)	Pops an element from a list, pushes it to another list and returns it.
default Future<Response>	RedisAPI.bzmpop(List<String> args)	Removes and returns a member by score from one or more sorted sets.
default Future<Response>	ValkeyAPI.bzmpop(List<String> args)	Removes and returns a member by score from one or more sorted sets.
default Future<Response>	RedisAPI.bzpopmax(List<String> args)	Removes and returns the member with the highest score from one or more sorted sets.
default Future<Response>	ValkeyAPI.bzpopmax(List<String> args)	Removes and returns the member with the highest score from one or more sorted sets.
default Future<Response>	RedisAPI.bzpopmin(List<String> args)	Removes and returns the member with the lowest score from one or more sorted sets.
default Future<Response>	ValkeyAPI.bzpopmin(List<String> args)	Removes and returns the member with the lowest score from one or more sorted sets.
default Future<Response>	RedisAPI.cfAdd(String arg0, String arg1)	Adds an item to a Cuckoo Filter.
default Future<Response>	RedisAPI.cfAdd(List<String> args)	Adds an item to a Cuckoo Filter.
default Future<Response>	RedisAPI.cfAddnx(String arg0, String arg1)	Adds an item to a Cuckoo Filter if the item did not exist previously.
default Future<Response>	RedisAPI.cfAddnx(List<String> args)	Adds an item to a Cuckoo Filter if the item did not exist previously.
default Future<Response>	RedisAPI.cfCompact(List<String> args)
default Future<Response>	RedisAPI.cfCount(String arg0, String arg1)	Return the number of times an item might be in a Cuckoo Filter.
default Future<Response>	RedisAPI.cfCount(List<String> args)	Return the number of times an item might be in a Cuckoo Filter.
default Future<Response>	RedisAPI.cfDebug(List<String> args)
default Future<Response>	RedisAPI.cfDel(String arg0, String arg1)	Deletes an item from a Cuckoo Filter.
default Future<Response>	RedisAPI.cfDel(List<String> args)	Deletes an item from a Cuckoo Filter.
default Future<Response>	RedisAPI.cfExists(String arg0, String arg1)	Checks whether one or more items exist in a Cuckoo Filter.
default Future<Response>	RedisAPI.cfExists(List<String> args)	Checks whether one or more items exist in a Cuckoo Filter.
default Future<Response>	RedisAPI.cfInfo(String arg0)	Returns information about a Cuckoo Filter.
default Future<Response>	RedisAPI.cfInfo(List<String> args)	Returns information about a Cuckoo Filter.
default Future<Response>	RedisAPI.cfInsert(List<String> args)	Adds one or more items to a Cuckoo Filter.
default Future<Response>	RedisAPI.cfInsertnx(List<String> args)	Adds one or more items to a Cuckoo Filter if the items did not exist previously.
default Future<Response>	RedisAPI.cfLoadchunk(String arg0, String arg1, String arg2)	Restores a filter previously saved using SCANDUMP.
default Future<Response>	RedisAPI.cfLoadchunk(List<String> args)	Restores a filter previously saved using SCANDUMP.
default Future<Response>	RedisAPI.cfMexists(List<String> args)	Checks whether one or more items exist in a Cuckoo Filter.
default Future<Response>	RedisAPI.cfReserve(List<String> args)	Creates a new Cuckoo Filter.
default Future<Response>	RedisAPI.cfScandump(String arg0, String arg1)	Begins an incremental save of the bloom filter.
default Future<Response>	RedisAPI.cfScandump(List<String> args)	Begins an incremental save of the bloom filter.
default Future<Response>	RedisAPI.client(List<String> args)	A container for client connection commands.
default Future<Response>	ValkeyAPI.client(List<String> args)	A container for client connection commands.
Future<Void>	Redis.close()	Closes the client and terminates any connection.
Future<Void>	RedisConnection.close()	Closes the connection or returns to the pool.
default Future<Response>	RedisAPI.cluster(List<String> args)	A container for Redis Cluster commands.
default Future<Response>	ValkeyAPI.cluster(List<String> args)	A container for Cluster commands.
default Future<Response>	RedisAPI.cmsIncrby(List<String> args)	Increases the count of one or more items by increment.
default Future<Response>	RedisAPI.cmsInfo(String arg0)	Returns information about a sketch.
default Future<Response>	RedisAPI.cmsInfo(List<String> args)	Returns information about a sketch.
default Future<Response>	RedisAPI.cmsInitbydim(String arg0, String arg1, String arg2)	Initializes a Count-Min Sketch to dimensions specified by user.
default Future<Response>	RedisAPI.cmsInitbydim(List<String> args)	Initializes a Count-Min Sketch to dimensions specified by user.
default Future<Response>	RedisAPI.cmsInitbyprob(String arg0, String arg1, String arg2)	Initializes a Count-Min Sketch to accommodate requested tolerances.
default Future<Response>	RedisAPI.cmsInitbyprob(List<String> args)	Initializes a Count-Min Sketch to accommodate requested tolerances.
default Future<Response>	RedisAPI.cmsMerge(List<String> args)	Merges several sketches into one sketch.
default Future<Response>	RedisAPI.cmsQuery(List<String> args)	Returns the count for one or more items in a sketch.
default Future<Response>	RedisAPI.command(List<String> args)	Returns detailed information about all commands.
default Future<Response>	ValkeyAPI.command(List<String> args)	Returns detailed information about all commands.
default Future<Response>	ValkeyAPI.commandlog(List<String> args)	A container for command log commands.
default Future<Response>	RedisAPI.config(List<String> args)	A container for server configuration commands.
default Future<Response>	ValkeyAPI.config(List<String> args)	A container for server configuration commands.
Future<RedisConnection>	Redis.connect()	Connects to the Redis server.
default Future<Response>	RedisAPI.copy(List<String> args)	Copies the value of a key to a new key.
default Future<Response>	ValkeyAPI.copy(List<String> args)	Copies the value of a key to a new key.
default Future<Response>	RedisAPI.dbsize()	Returns the number of keys in the database.
default Future<Response>	ValkeyAPI.dbsize()	Returns the number of keys in the database.
default Future<Response>	RedisAPI.debug(List<String> args)	A container for debugging commands.
default Future<Response>	ValkeyAPI.debug(List<String> args)	A container for debugging commands.
default Future<Response>	RedisAPI.decr(String arg0)	Decrements the integer value of a key by one.
default Future<Response>	ValkeyAPI.decr(String arg0)	Decrements the integer value of a key by one.
default Future<Response>	RedisAPI.decrby(String arg0, String arg1)	Decrements a number from the integer value of a key.
default Future<Response>	ValkeyAPI.decrby(String arg0, String arg1)	Decrements a number from the integer value of a key.
default Future<Response>	RedisAPI.del(List<String> args)	Deletes one or more keys.
default Future<Response>	ValkeyAPI.del(List<String> args)	Deletes one or more keys.
default Future<Response>	RedisAPI.delex(List<String> args)	Conditionally removes the specified key based on value or digest comparison.
default Future<Response>	ValkeyAPI.delifeq(String arg0, String arg1)	Delete key if value matches string.
default Future<Response>	RedisAPI.digest(String arg0)	Returns the XXH3 hash of a string value.
default Future<Response>	RedisAPI.discard()	Discards a transaction.
default Future<Response>	ValkeyAPI.discard()	Discards a transaction.
default Future<Response>	RedisAPI.dump(String arg0)	Returns a serialized representation of the value stored at a key.
default Future<Response>	ValkeyAPI.dump(String arg0)	Returns a serialized representation of the value stored at a key.
default Future<Response>	RedisAPI.echo(String arg0)	Returns the given string.
default Future<Response>	ValkeyAPI.echo(String arg0)	Returns the given string.
default Future<Response>	RedisAPI.eval(List<String> args)	Executes a server-side Lua script.
default Future<Response>	ValkeyAPI.eval(List<String> args)	Executes a server-side Lua script.
default Future<Response>	RedisAPI.evalRo(List<String> args)	Executes a read-only server-side Lua script.
default Future<Response>	ValkeyAPI.evalRo(List<String> args)	Executes a read-only server-side Lua script.
default Future<Response>	RedisAPI.evalsha(List<String> args)	Executes a server-side Lua script by SHA1 digest.
default Future<Response>	ValkeyAPI.evalsha(List<String> args)	Executes a server-side Lua script by SHA1 digest.
default Future<Response>	RedisAPI.evalshaRo(List<String> args)	Executes a read-only server-side Lua script by SHA1 digest.
default Future<Response>	ValkeyAPI.evalshaRo(List<String> args)	Executes a read-only server-side Lua script by SHA1 digest.
default Future<Response>	RedisAPI.exec()	Executes all commands in a transaction.
default Future<Response>	ValkeyAPI.exec()	Executes all commands in a transaction.
default Future<Response>	RedisAPI.exists(List<String> args)	Determines whether one or more keys exist.
default Future<Response>	ValkeyAPI.exists(List<String> args)	Determines whether one or more keys exist.
default Future<Response>	RedisAPI.expire(List<String> args)	Sets the expiration time of a key in seconds.
default Future<Response>	ValkeyAPI.expire(List<String> args)	Sets the expiration time of a key in seconds.
default Future<Response>	RedisAPI.expireat(List<String> args)	Sets the expiration time of a key to a Unix timestamp.
default Future<Response>	ValkeyAPI.expireat(List<String> args)	Sets the expiration time of a key to a Unix timestamp.
default Future<Response>	RedisAPI.expiretime(String arg0)	Returns the expiration time of a key as a Unix timestamp.
default Future<Response>	ValkeyAPI.expiretime(String arg0)	Returns the expiration time of a key as a Unix timestamp.
default Future<Response>	RedisAPI.failover(List<String> args)	Starts a coordinated failover from a server to one of its replicas.
default Future<Response>	ValkeyAPI.failover(List<String> args)	Starts a coordinated failover from a server to one of its replicas.
default Future<Response>	RedisAPI.fcall(List<String> args)	Invokes a function.
default Future<Response>	ValkeyAPI.fcall(List<String> args)	Invokes a function.
default Future<Response>	RedisAPI.fcallRo(List<String> args)	Invokes a read-only function.
default Future<Response>	ValkeyAPI.fcallRo(List<String> args)	Invokes a read-only function.
default Future<Response>	RedisAPI.flushall(List<String> args)	Removes all keys from all databases.
default Future<Response>	ValkeyAPI.flushall(List<String> args)	Removes all keys from all databases.
default Future<Response>	RedisAPI.flushdb(List<String> args)	Remove all keys from the current database.
default Future<Response>	ValkeyAPI.flushdb(List<String> args)	Remove all keys from the current database.
default Future<Response>	RedisAPI.ftAdd(List<String> args)
default Future<Response>	RedisAPI.ftAggregate(List<String> args)	Run a search query on an index and perform aggregate transformations on the results.
default Future<Response>	RedisAPI.ftAliasadd(List<String> args)	Adds an alias to the index.
default Future<Response>	RedisAPI.ftAliasaddifnx(List<String> args)	Adds an alias to the index.
default Future<Response>	RedisAPI.ftAliasdel(List<String> args)	Deletes an alias from the index.
default Future<Response>	RedisAPI.ftAliasdelifx(List<String> args)	Deletes an alias from the index.
default Future<Response>	RedisAPI.ftAliasupdate(List<String> args)	Adds or updates an alias to the index.
default Future<Response>	RedisAPI.ftAlter(List<String> args)	Adds a new field to the index.
default Future<Response>	RedisAPI.ftAlterifnx(List<String> args)	Adds a new field to the index.
default Future<Response>	RedisAPI.ftConfig(List<String> args)
default Future<Response>	RedisAPI.ftCreate(List<String> args)	Creates an index with the given spec.
default Future<Response>	RedisAPI.ftCreateifnx(List<String> args)	Creates an index with the given spec.
default Future<Response>	RedisAPI.ftCursor(List<String> args)
default Future<Response>	RedisAPI.ftDebug(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.ftDel(List<String> args)
default Future<Response>	RedisAPI.ftDictadd(List<String> args)	Adds terms to a dictionary.
default Future<Response>	RedisAPI.ftDictdel(List<String> args)	Deletes terms from a dictionary.
default Future<Response>	RedisAPI.ftDictdump(List<String> args)	Dumps all terms in the given dictionary.
default Future<Response>	RedisAPI.ftDrop(List<String> args)
default Future<Response>	RedisAPI.ftDropifx(List<String> args)
default Future<Response>	RedisAPI.ftDropindex(List<String> args)	Deletes the index.
default Future<Response>	RedisAPI.ftDropindexifx(List<String> args)	Deletes the index.
default Future<Response>	RedisAPI.ftExplain(List<String> args)	Returns the execution plan for a complex query.
default Future<Response>	RedisAPI.ftExplaincli(List<String> args)	Returns the execution plan for a complex query.
default Future<Response>	RedisAPI.ftGet(List<String> args)
default Future<Response>	RedisAPI.ftHybrid(List<String> args)	Performs hybrid search combining text search and vector similarity search.
default Future<Response>	RedisAPI.ftInfo(List<String> args)	Returns information and statistics on the index.
default Future<Response>	RedisAPI.ftList(List<String> args)	Returns a list of all existing indexes.
default Future<Response>	RedisAPI.ftMget(List<String> args)
default Future<Response>	RedisAPI.ftProfile(List<String> args)	Performs a `FT.SEARCH` or `FT.AGGREGATE` command and collects performance information.
default Future<Response>	RedisAPI.ftSafeadd(List<String> args)
default Future<Response>	RedisAPI.ftSearch(List<String> args)	Searches the index with a textual query, returning either documents or just ids.
default Future<Response>	RedisAPI.ftSpellcheck(List<String> args)	Performs spelling correction on a query, returning suggestions for misspelled terms.
default Future<Response>	RedisAPI.ftSugadd(List<String> args)	Adds a suggestion string to an auto-complete suggestion dictionary.
default Future<Response>	RedisAPI.ftSugdel(List<String> args)	Deletes a string from a suggestion index.
default Future<Response>	RedisAPI.ftSugget(List<String> args)	Gets completion suggestions for a prefix.
default Future<Response>	RedisAPI.ftSuglen(List<String> args)	Gets the size of an auto-complete suggestion dictionary.
default Future<Response>	RedisAPI.ftSynadd(List<String> args)
default Future<Response>	RedisAPI.ftSyndump(List<String> args)	Dumps the contents of a synonym group.
default Future<Response>	RedisAPI.ftSynupdate(List<String> args)	Creates or updates a synonym group with additional terms.
default Future<Response>	RedisAPI.ftTagvals(List<String> args)	Returns the distinct tags indexed in a Tag field.
default Future<Response>	RedisAPI.function(List<String> args)	A container for function commands.
default Future<Response>	ValkeyAPI.function(List<String> args)	A container for function commands.
default Future<Response>	RedisAPI.geoadd(List<String> args)	Adds one or more members to a geospatial index.
default Future<Response>	ValkeyAPI.geoadd(List<String> args)	Adds one or more members to a geospatial index.
default Future<Response>	RedisAPI.geodist(List<String> args)	Returns the distance between two members of a geospatial index.
default Future<Response>	ValkeyAPI.geodist(List<String> args)	Returns the distance between two members of a geospatial index.
default Future<Response>	RedisAPI.geohash(List<String> args)	Returns members from a geospatial index as geohash strings.
default Future<Response>	ValkeyAPI.geohash(List<String> args)	Returns members from a geospatial index as geohash strings.
default Future<Response>	RedisAPI.geopos(List<String> args)	Returns the longitude and latitude of members from a geospatial index.
default Future<Response>	ValkeyAPI.geopos(List<String> args)	Returns the longitude and latitude of members from a geospatial index.
default Future<Response>	RedisAPI.georadius(List<String> args)	Deprecated. since Redis 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS argument
default Future<Response>	ValkeyAPI.georadius(List<String> args)	Queries a geospatial index for members within a distance from a coordinate, optionally stores the result.
default Future<Response>	RedisAPI.georadiusbymember(List<String> args)	Deprecated. since Redis 6.2.0, replaced by: GEOSEARCH and GEOSEARCHSTORE with the BYRADIUS and FROMMEMBER arguments
default Future<Response>	ValkeyAPI.georadiusbymember(List<String> args)	Queries a geospatial index for members within a distance from a member, optionally stores the result.
default Future<Response>	RedisAPI.georadiusbymemberRo(List<String> args)	Deprecated. since Redis 6.2.0, replaced by: GEOSEARCH with the BYRADIUS and FROMMEMBER arguments
default Future<Response>	ValkeyAPI.georadiusbymemberRo(List<String> args)	Returns members from a geospatial index that are within a distance from a member.
default Future<Response>	RedisAPI.georadiusRo(List<String> args)	Deprecated. since Redis 6.2.0, replaced by: GEOSEARCH with the BYRADIUS argument
default Future<Response>	ValkeyAPI.georadiusRo(List<String> args)	Returns members from a geospatial index that are within a distance from a coordinate.
default Future<Response>	RedisAPI.geosearch(List<String> args)	Queries a geospatial index for members inside an area of a box or a circle.
default Future<Response>	ValkeyAPI.geosearch(List<String> args)	Queries a geospatial index for members inside an area of a box, circle, or a polygon.
default Future<Response>	RedisAPI.geosearchstore(List<String> args)	Queries a geospatial index for members inside an area of a box or a circle, optionally stores the result.
default Future<Response>	ValkeyAPI.geosearchstore(List<String> args)	Queries a geospatial index for members inside an area of a box, a circle, or a polygon, optionally stores the result.
default Future<Response>	RedisAPI.get(String arg0)	Returns the string value of a key.
default Future<Response>	ValkeyAPI.get(String arg0)	Returns the string value of a key.
default Future<Response>	RedisAPI.getbit(String arg0, String arg1)	Returns a bit value by offset.
default Future<Response>	ValkeyAPI.getbit(String arg0, String arg1)	Returns a bit value by offset.
default Future<Response>	RedisAPI.getdel(String arg0)	Returns the string value of a key after deleting the key.
default Future<Response>	ValkeyAPI.getdel(String arg0)	Returns the string value of a key after deleting the key.
default Future<Response>	RedisAPI.getex(List<String> args)	Returns the string value of a key after setting its expiration time.
default Future<Response>	ValkeyAPI.getex(List<String> args)	Returns the string value of a key after setting its expiration time.
default Future<Response>	RedisAPI.getrange(String arg0, String arg1, String arg2)	Returns a substring of the string stored at a key.
default Future<Response>	ValkeyAPI.getrange(String arg0, String arg1, String arg2)	Returns a substring of the string stored at a key.
default Future<Response>	RedisAPI.getset(String arg0, String arg1)	Deprecated. since Redis 6.2.0, replaced by: SET with the !GET argument
default Future<Response>	ValkeyAPI.getset(String arg0, String arg1)	Returns the previous string value of a key after setting it to a new value.
default Future<Response>	RedisAPI.graphBulk(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.graphConfig(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.graphDebug(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.graphDelete(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.graphExplain(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.graphList(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.graphProfile(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.graphQuery(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.graphRoQuery(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.graphSlowlog(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
Future<RequestGrouping>	RedisCluster.groupByNodes(List<Request> requests)	Groups the requests into a RequestGrouping, which contains: keyed requests: requests that include a key and it is therefore possible to determine to which master node they should be sent; all requests in each inner list in the keyed collection are guaranteed to be sent to the same master node; unkeyed requests: requests that do not include a key and it is therefore not possible to determine to which master node they should be sent. If any of the requests includes multiple keys that belong to different master nodes, the resulting future will fail.
default Future<Response>	RedisAPI.hdel(List<String> args)	Deletes one or more fields and their values from a hash.
default Future<Response>	ValkeyAPI.hdel(List<String> args)	Deletes one or more fields and their values from a hash.
default Future<Response>	RedisAPI.hello(List<String> args)	Handshakes with the Redis server.
default Future<Response>	ValkeyAPI.hello(List<String> args)	Handshakes with the server.
default Future<Response>	RedisAPI.hexists(String arg0, String arg1)	Determines whether a field exists in a hash.
default Future<Response>	ValkeyAPI.hexists(String arg0, String arg1)	Determines whether a field exists in a hash.
default Future<Response>	RedisAPI.hexpire(List<String> args)	Set expiry for hash field using relative time to expire (seconds).
default Future<Response>	ValkeyAPI.hexpire(List<String> args)	Set expiry time on hash fields.
default Future<Response>	RedisAPI.hexpireat(List<String> args)	Set expiry for hash field using an absolute Unix timestamp (seconds).
default Future<Response>	ValkeyAPI.hexpireat(List<String> args)	Set expiry time on hash fields.
default Future<Response>	RedisAPI.hexpiretime(List<String> args)	Returns the expiration time of a hash field as a Unix timestamp, in seconds.
default Future<Response>	ValkeyAPI.hexpiretime(List<String> args)	Returns Unix timestamps in seconds since the epoch at which the given key's field(s) will expire.
default Future<Response>	RedisAPI.hget(String arg0, String arg1)	Returns the value of a field in a hash.
default Future<Response>	ValkeyAPI.hget(String arg0, String arg1)	Returns the value of a field in a hash.
default Future<Response>	RedisAPI.hgetall(String arg0)	Returns all fields and values in a hash.
default Future<Response>	ValkeyAPI.hgetall(String arg0)	Returns all fields and values in a hash.
default Future<Response>	RedisAPI.hgetdel(List<String> args)	Returns the value of a field and deletes it from the hash.
default Future<Response>	RedisAPI.hgetex(List<String> args)	Get the value of one or more fields of a given hash key, and optionally set their expiration.
default Future<Response>	ValkeyAPI.hgetex(List<String> args)	Get the value of one or more fields of a given hash key, and optionally set their expiration time or time-to-live (TTL).
default Future<Response>	RedisAPI.hincrby(String arg0, String arg1, String arg2)	Increments the integer value of a field in a hash by a number.
default Future<Response>	ValkeyAPI.hincrby(String arg0, String arg1, String arg2)	Increments the integer value of a field in a hash by a number.
default Future<Response>	RedisAPI.hincrbyfloat(String arg0, String arg1, String arg2)	Increments the floating point value of a field by a number.
default Future<Response>	ValkeyAPI.hincrbyfloat(String arg0, String arg1, String arg2)	Increments the floating point value of a field by a number.
default Future<Response>	RedisAPI.hkeys(String arg0)	Returns all fields in a hash.
default Future<Response>	ValkeyAPI.hkeys(String arg0)	Returns all fields in a hash.
default Future<Response>	RedisAPI.hlen(String arg0)	Returns the number of fields in a hash.
default Future<Response>	ValkeyAPI.hlen(String arg0)	Returns the number of fields in a hash.
default Future<Response>	RedisAPI.hmget(List<String> args)	Returns the values of all fields in a hash.
default Future<Response>	ValkeyAPI.hmget(List<String> args)	Returns the values of all fields in a hash.
default Future<Response>	RedisAPI.hmset(List<String> args)	Deprecated. since Redis 4.0.0, replaced by: HSET with multiple field-value pairs
default Future<Response>	ValkeyAPI.hmset(List<String> args)	Sets the values of multiple fields.
default Future<Response>	RedisAPI.hotkeys(List<String> args)	A container for hotkeys tracking commands.
default Future<Response>	RedisAPI.hpersist(List<String> args)	Removes the expiration time for each specified field.
default Future<Response>	ValkeyAPI.hpersist(List<String> args)	Remove the existing expiration on a hash key's field(s).
default Future<Response>	RedisAPI.hpexpire(List<String> args)	Set expiry for hash field using relative time to expire (milliseconds).
default Future<Response>	ValkeyAPI.hpexpire(List<String> args)	Set expiry time on hash object.
default Future<Response>	RedisAPI.hpexpireat(List<String> args)	Set expiry for hash field using an absolute Unix timestamp (milliseconds).
default Future<Response>	ValkeyAPI.hpexpireat(List<String> args)	Set expiration time on hash field.
default Future<Response>	RedisAPI.hpexpiretime(List<String> args)	Returns the expiration time of a hash field as a Unix timestamp, in msec.
default Future<Response>	ValkeyAPI.hpexpiretime(List<String> args)	Returns the Unix timestamp in milliseconds since Unix epoch at which the given key's field(s) will expire.
default Future<Response>	RedisAPI.hpttl(List<String> args)	Returns the TTL in milliseconds of a hash field.
default Future<Response>	ValkeyAPI.hpttl(List<String> args)	Returns the remaining time to live in milliseconds of a hash key's field(s) that have an associated expiration.
default Future<Response>	RedisAPI.hrandfield(List<String> args)	Returns one or more random fields from a hash.
default Future<Response>	ValkeyAPI.hrandfield(List<String> args)	Returns one or more random fields from a hash.
default Future<Response>	RedisAPI.hscan(List<String> args)	Iterates over fields and values of a hash.
default Future<Response>	ValkeyAPI.hscan(List<String> args)	Iterates over fields and values of a hash.
default Future<Response>	RedisAPI.hset(List<String> args)	Creates or modifies the value of a field in a hash.
default Future<Response>	ValkeyAPI.hset(List<String> args)	Creates or modifies the value of a field in a hash.
default Future<Response>	RedisAPI.hsetex(List<String> args)	Set the value of one or more fields of a given hash key, and optionally set their expiration.
default Future<Response>	ValkeyAPI.hsetex(List<String> args)	Set the value of one or more fields of a given hash key, and optionally set their expiration time.
default Future<Response>	RedisAPI.hsetnx(String arg0, String arg1, String arg2)	Sets the value of a field in a hash only when the field doesn't exist.
default Future<Response>	ValkeyAPI.hsetnx(String arg0, String arg1, String arg2)	Sets the value of a field in a hash only when the field doesn't exist.
default Future<Response>	RedisAPI.hstrlen(String arg0, String arg1)	Returns the length of the value of a field.
default Future<Response>	ValkeyAPI.hstrlen(String arg0, String arg1)	Returns the length of the value of a field.
default Future<Response>	RedisAPI.httl(List<String> args)	Returns the TTL in seconds of a hash field.
default Future<Response>	ValkeyAPI.httl(List<String> args)	Returns the remaining time to live (in seconds) of a hash key's field(s) that have an associated expiration.
default Future<Response>	RedisAPI.hvals(String arg0)	Returns all values in a hash.
default Future<Response>	ValkeyAPI.hvals(String arg0)	Returns all values in a hash.
default Future<Response>	RedisAPI.incr(String arg0)	Increments the integer value of a key by one.
default Future<Response>	ValkeyAPI.incr(String arg0)	Increments the integer value of a key by one.
default Future<Response>	RedisAPI.incrby(String arg0, String arg1)	Increments the integer value of a key by a number.
default Future<Response>	ValkeyAPI.incrby(String arg0, String arg1)	Increments the integer value of a key by a number.
default Future<Response>	RedisAPI.incrbyfloat(String arg0, String arg1)	Increment the floating point value of a key by a number.
default Future<Response>	ValkeyAPI.incrbyfloat(String arg0, String arg1)	Increment the floating point value of a key by a number.
default Future<Response>	RedisAPI.info(List<String> args)	Returns information and statistics about the server.
default Future<Response>	ValkeyAPI.info(List<String> args)	Returns information and statistics about the server.
default Future<Response>	RedisAPI.jsonArrappend(List<String> args)	Append the JSON values into the array at path after the last element in it.
default Future<Response>	RedisAPI.jsonArrindex(List<String> args)	Search for the first occurrence of a JSON value in an array.
default Future<Response>	RedisAPI.jsonArrinsert(List<String> args)	Insert the json values into the array at path before the index (shifts to the right).
default Future<Response>	RedisAPI.jsonArrlen(List<String> args)	Report the length of the JSON array at path in key.
default Future<Response>	RedisAPI.jsonArrpop(List<String> args)	Remove and return the element at the specified index in the array at path.
default Future<Response>	RedisAPI.jsonArrtrim(String arg0, String arg1, String arg2, String arg3)	Trim an array so that it contains only the specified inclusive range of elements.
default Future<Response>	RedisAPI.jsonArrtrim(List<String> args)	Trim an array so that it contains only the specified inclusive range of elements.
default Future<Response>	RedisAPI.jsonClear(List<String> args)	Clear container values (arrays/objects) and set numeric values to 0.
default Future<Response>	RedisAPI.jsonDebug(List<String> args)	This is a container command for debugging related tasks.
default Future<Response>	RedisAPI.jsonDel(List<String> args)	Delete a value.
default Future<Response>	RedisAPI.jsonForget(List<String> args)	Delete a value.
default Future<Response>	RedisAPI.jsonGet(List<String> args)	Get JSON value at path.
default Future<Response>	RedisAPI.jsonMerge(List<String> args)	Merge a given JSON value into matching paths.
default Future<Response>	RedisAPI.jsonMget(List<String> args)	Return the values at path from multiple key arguments.
default Future<Response>	RedisAPI.jsonMset(List<String> args)	Set or update one or more JSON values according to the specified key-path-value triplets.
default Future<Response>	RedisAPI.jsonNumincrby(String arg0, String arg1, String arg2)	Increment the number value stored at path by number.
default Future<Response>	RedisAPI.jsonNumincrby(List<String> args)	Increment the number value stored at path by number.
default Future<Response>	RedisAPI.jsonNummultby(String arg0, String arg1, String arg2)	Multiply the number value stored at path by number.
default Future<Response>	RedisAPI.jsonNummultby(List<String> args)	Multiply the number value stored at path by number.
default Future<Response>	RedisAPI.jsonNumpowby(String arg0, String arg1, String arg2)	Raise the number value stored at path to the power of number.
default Future<Response>	RedisAPI.jsonNumpowby(List<String> args)	Raise the number value stored at path to the power of number.
default Future<Response>	RedisAPI.jsonObjkeys(List<String> args)	Return the keys in the object that's referenced by path.
default Future<Response>	RedisAPI.jsonObjlen(List<String> args)	Report the number of keys in the JSON object at path in key.
default Future<Response>	RedisAPI.jsonResp(List<String> args)	Return the JSON in key in Redis serialization protocol specification form.
default Future<Response>	RedisAPI.jsonSet(List<String> args)	Set the JSON value at path in key.
default Future<Response>	RedisAPI.jsonStrappend(List<String> args)	Append the json-string values to the string at path.
default Future<Response>	RedisAPI.jsonStrlen(List<String> args)	Report the length of the JSON String at path in key.
default Future<Response>	RedisAPI.jsonToggle(String arg0, String arg1)	Toggle the boolean value stored at path.
default Future<Response>	RedisAPI.jsonToggle(List<String> args)	Toggle the boolean value stored at path.
default Future<Response>	RedisAPI.jsonType(List<String> args)	Report the type of JSON value at path.
default Future<Response>	RedisAPI.keys(String arg0)	Returns all key names that match a pattern.
default Future<Response>	ValkeyAPI.keys(String arg0)	Returns all key names that match a pattern.
default Future<Response>	RedisAPI.lastsave()	Returns the Unix timestamp of the last successful save to disk.
default Future<Response>	ValkeyAPI.lastsave()	Returns the Unix timestamp of the last successful save to disk.
default Future<Response>	RedisAPI.latency(List<String> args)	A container for latency diagnostics commands.
default Future<Response>	ValkeyAPI.latency(List<String> args)	A container for latency diagnostics commands.
default Future<Response>	RedisAPI.lcs(List<String> args)	Finds the longest common substring.
default Future<Response>	ValkeyAPI.lcs(List<String> args)	Finds the longest common substring.
default Future<Response>	RedisAPI.lindex(String arg0, String arg1)	Returns an element from a list by its index.
default Future<Response>	ValkeyAPI.lindex(String arg0, String arg1)	Returns an element from a list by its index.
default Future<Response>	RedisAPI.linsert(String arg0, String arg1, String arg2, String arg3)	Inserts an element before or after another element in a list.
default Future<Response>	ValkeyAPI.linsert(String arg0, String arg1, String arg2, String arg3)	Inserts an element before or after another element in a list.
default Future<Response>	RedisAPI.llen(String arg0)	Returns the length of a list.
default Future<Response>	ValkeyAPI.llen(String arg0)	Returns the length of a list.
default Future<Response>	RedisAPI.lmove(String arg0, String arg1, String arg2, String arg3)	Returns an element after popping it from one list and pushing it to another.
default Future<Response>	ValkeyAPI.lmove(String arg0, String arg1, String arg2, String arg3)	Returns an element after popping it from one list and pushing it to another.
default Future<Response>	RedisAPI.lmpop(List<String> args)	Returns multiple elements from a list after removing them.
default Future<Response>	ValkeyAPI.lmpop(List<String> args)	Returns multiple elements from a list after removing them.
default Future<Response>	RedisAPI.lolwut(List<String> args)	Displays computer art and the Redis version.
default Future<Response>	ValkeyAPI.lolwut(List<String> args)	Displays computer art and the server version.
default Future<Response>	RedisAPI.lpop(List<String> args)	Returns the first elements in a list after removing it.
default Future<Response>	ValkeyAPI.lpop(List<String> args)	Returns and removes one or more elements from the beginning of a list.
default Future<Response>	RedisAPI.lpos(List<String> args)	Returns the index of matching elements in a list.
default Future<Response>	ValkeyAPI.lpos(List<String> args)	Returns the index of matching elements in a list.
default Future<Response>	RedisAPI.lpush(List<String> args)	Prepends one or more elements to a list.
default Future<Response>	ValkeyAPI.lpush(List<String> args)	Prepends one or more elements to a list.
default Future<Response>	RedisAPI.lpushx(List<String> args)	Prepends one or more elements to a list only when the list exists.
default Future<Response>	ValkeyAPI.lpushx(List<String> args)	Prepends one or more elements to a list only when the list exists.
default Future<Response>	RedisAPI.lrange(String arg0, String arg1, String arg2)	Returns a range of elements from a list.
default Future<Response>	ValkeyAPI.lrange(String arg0, String arg1, String arg2)	Returns a range of elements from a list.
default Future<Response>	RedisAPI.lrem(String arg0, String arg1, String arg2)	Removes elements from a list.
default Future<Response>	ValkeyAPI.lrem(String arg0, String arg1, String arg2)	Removes elements from a list.
default Future<Response>	RedisAPI.lset(String arg0, String arg1, String arg2)	Sets the value of an element in a list by its index.
default Future<Response>	ValkeyAPI.lset(String arg0, String arg1, String arg2)	Sets the value of an element in a list by its index.
default Future<Response>	RedisAPI.ltrim(String arg0, String arg1, String arg2)	Removes elements from both ends a list.
default Future<Response>	ValkeyAPI.ltrim(String arg0, String arg1, String arg2)	Removes elements from both ends a list.
default Future<Response>	RedisAPI.memory(List<String> args)	A container for memory diagnostics commands.
default Future<Response>	ValkeyAPI.memory(List<String> args)	A container for memory diagnostics commands.
default Future<Response>	RedisAPI.mget(List<String> args)	Atomically returns the string values of one or more keys.
default Future<Response>	ValkeyAPI.mget(List<String> args)	Atomically returns the string values of one or more keys.
default Future<Response>	RedisAPI.migrate(List<String> args)	Atomically transfers a key from one Redis instance to another.
default Future<Response>	ValkeyAPI.migrate(List<String> args)	Atomically transfers a key from one instance to another.
default Future<Response>	RedisAPI.module(List<String> args)	A container for module commands.
default Future<Response>	ValkeyAPI.module(List<String> args)	A container for module commands.
default Future<Response>	RedisAPI.monitor()	Listens for all requests received by the server in real-time.
default Future<Response>	ValkeyAPI.monitor()	Listens for all requests received by the server in real-time.
default Future<Response>	RedisAPI.move(String arg0, String arg1)	Moves a key to another database.
default Future<Response>	ValkeyAPI.move(String arg0, String arg1)	Moves a key to another database.
default Future<Response>	RedisAPI.mset(List<String> args)	Atomically creates or modifies the string values of one or more keys.
default Future<Response>	ValkeyAPI.mset(List<String> args)	Atomically creates or modifies the string values of one or more keys.
default Future<Response>	RedisAPI.msetex(List<String> args)	Atomically sets multiple string keys with a shared expiration in a single operation.
default Future<Response>	RedisAPI.msetnx(List<String> args)	Atomically modifies the string values of one or more keys only when all keys don't exist.
default Future<Response>	ValkeyAPI.msetnx(List<String> args)	Atomically modifies the string values of one or more keys only when all keys don't exist.
default Future<Response>	RedisAPI.multi()	Starts a transaction.
default Future<Response>	ValkeyAPI.multi()	Starts a transaction.
default Future<Response>	RedisAPI.object(List<String> args)	A container for object introspection commands.
default Future<Response>	ValkeyAPI.object(List<String> args)	A container for object introspection commands.
Future<List<Response>>	RedisCluster.onAllMasterNodes(Request request)	Runs the request against all master nodes in the cluster.
Future<List<Response>>	RedisCluster.onAllNodes(Request request)	Runs the request against all nodes in the cluster.
default Future<Response>	RedisAPI.persist(String arg0)	Removes the expiration time of a key.
default Future<Response>	ValkeyAPI.persist(String arg0)	Removes the expiration time of a key.
default Future<Response>	RedisAPI.pexpire(List<String> args)	Sets the expiration time of a key in milliseconds.
default Future<Response>	ValkeyAPI.pexpire(List<String> args)	Sets the expiration time of a key in milliseconds.
default Future<Response>	RedisAPI.pexpireat(List<String> args)	Sets the expiration time of a key to a Unix milliseconds timestamp.
default Future<Response>	ValkeyAPI.pexpireat(List<String> args)	Sets the expiration time of a key to a Unix milliseconds timestamp.
default Future<Response>	RedisAPI.pexpiretime(String arg0)	Returns the expiration time of a key as a Unix milliseconds timestamp.
default Future<Response>	ValkeyAPI.pexpiretime(String arg0)	Returns the expiration time of a key as a Unix milliseconds timestamp.
default Future<Response>	RedisAPI.pfadd(List<String> args)	Adds elements to a HyperLogLog key.
default Future<Response>	ValkeyAPI.pfadd(List<String> args)	Adds elements to a HyperLogLog key.
default Future<Response>	RedisAPI.pfcount(List<String> args)	Returns the approximated cardinality of the set(s) observed by the HyperLogLog key(s).
default Future<Response>	ValkeyAPI.pfcount(List<String> args)	Returns the approximated cardinality of the set(s) observed by the HyperLogLog key(s).
default Future<Response>	RedisAPI.pfdebug(String arg0, String arg1)	Internal commands for debugging HyperLogLog values.
default Future<Response>	ValkeyAPI.pfdebug(String arg0, String arg1)	Internal commands for debugging HyperLogLog values.
default Future<Response>	RedisAPI.pfmerge(List<String> args)	Merges one or more HyperLogLog values into a single key.
default Future<Response>	ValkeyAPI.pfmerge(List<String> args)	Merges one or more HyperLogLog values into a single key.
default Future<Response>	RedisAPI.pfselftest()	An internal command for testing HyperLogLog values.
default Future<Response>	ValkeyAPI.pfselftest()	An internal command for testing HyperLogLog values.
default Future<Response>	RedisAPI.ping(List<String> args)	Returns the server's liveliness response.
default Future<Response>	ValkeyAPI.ping(List<String> args)	Returns the server's liveliness response.
default Future<Response>	RedisAPI.psetex(String arg0, String arg1, String arg2)	Deprecated. since Redis 2.6.12, replaced by: SET with the PX argument
default Future<Response>	ValkeyAPI.psetex(String arg0, String arg1, String arg2)	Sets both string value and expiration time in milliseconds of a key.
default Future<Response>	RedisAPI.psubscribe(List<String> args)	Listens for messages published to channels that match one or more patterns.
default Future<Response>	ValkeyAPI.psubscribe(List<String> args)	Listens for messages published to channels that match one or more patterns.
default Future<Response>	RedisAPI.psync(List<String> args)	An internal command used in replication.
default Future<Response>	ValkeyAPI.psync(List<String> args)	An internal command used in replication.
default Future<Response>	RedisAPI.pttl(String arg0)	Returns the expiration time in milliseconds of a key.
default Future<Response>	ValkeyAPI.pttl(String arg0)	Returns the expiration time in milliseconds of a key.
default Future<Response>	RedisAPI.publish(String arg0, String arg1)	Posts a message to a channel.
default Future<Response>	ValkeyAPI.publish(String arg0, String arg1)	Posts a message to a channel.
default Future<Response>	RedisAPI.pubsub(List<String> args)	A container for Pub/Sub commands.
default Future<Response>	ValkeyAPI.pubsub(List<String> args)	A container for Pub/Sub commands.
default Future<Response>	RedisAPI.punsubscribe(List<String> args)	Stops listening to messages published to channels that match one or more patterns.
default Future<Response>	ValkeyAPI.punsubscribe(List<String> args)	Stops listening to messages published to channels that match one or more patterns.
default Future<Response>	RedisAPI.quit(List<String> args)	Deprecated. since Redis 7.2.0, replaced by: just closing the connection
default Future<Response>	ValkeyAPI.quit(List<String> args)	Closes the connection.
default Future<Response>	RedisAPI.randomkey()	Returns a random key name from the database.
default Future<Response>	ValkeyAPI.randomkey()	Returns a random key name from the database.
default Future<Response>	RedisAPI.readonly()	Enables read-only queries for a connection to a Redis Cluster replica node.
default Future<Response>	ValkeyAPI.readonly()	Enables read-only queries for a connection to a Valkey replica node.
default Future<Response>	RedisAPI.readwrite()	Enables read-write queries for a connection to a Reids Cluster replica node.
default Future<Response>	ValkeyAPI.readwrite()	Enables read-write queries for a connection to a Valkey replica node.
default Future<Response>	RedisAPI.rename(String arg0, String arg1)	Renames a key and overwrites the destination.
default Future<Response>	ValkeyAPI.rename(String arg0, String arg1)	Renames a key and overwrites the destination.
default Future<Response>	RedisAPI.renamenx(String arg0, String arg1)	Renames a key only when the target key name doesn't exist.
default Future<Response>	ValkeyAPI.renamenx(String arg0, String arg1)	Renames a key only when the target key name doesn't exist.
default Future<Response>	RedisAPI.replconf(List<String> args)	An internal command for configuring the replication stream.
default Future<Response>	ValkeyAPI.replconf(List<String> args)	An internal command for configuring the replication stream.
default Future<Response>	RedisAPI.replicaof(String arg0, String arg1)	Configures a server as replica of another, or promotes it to a master.
default Future<Response>	ValkeyAPI.replicaof(String arg0, String arg1)	Configures a server as replica of another, or promotes it to a primary.
default Future<Response>	RedisAPI.reset()	Resets the connection.
default Future<Response>	ValkeyAPI.reset()	Resets the connection.
default Future<Response>	RedisAPI.restore(List<String> args)	Creates a key from the serialized representation of a value.
default Future<Response>	ValkeyAPI.restore(List<String> args)	Creates a key from the serialized representation of a value.
default Future<Response>	RedisAPI.restoreAsking(List<String> args)	An internal command for migrating keys in a cluster.
default Future<Response>	ValkeyAPI.restoreAsking(List<String> args)	An internal command for migrating keys in a cluster.
default Future<Response>	RedisAPI.role()	Returns the replication role.
default Future<Response>	ValkeyAPI.role()	Returns the replication role.
default Future<Response>	RedisAPI.rpop(List<String> args)	Returns and removes the last elements of a list.
default Future<Response>	ValkeyAPI.rpop(List<String> args)	Returns and removes one or more elements from the end of a list.
default Future<Response>	RedisAPI.rpoplpush(String arg0, String arg1)	Deprecated. since Redis 6.2.0, replaced by: LMOVE with the RIGHT and LEFT arguments
default Future<Response>	ValkeyAPI.rpoplpush(String arg0, String arg1)	Returns the last element of a list after removing and pushing it to another list.
default Future<Response>	RedisAPI.rpush(List<String> args)	Appends one or more elements to a list.
default Future<Response>	ValkeyAPI.rpush(List<String> args)	Appends one or more elements to a list.
default Future<Response>	RedisAPI.rpushx(List<String> args)	Appends an element to a list only when the list exists.
default Future<Response>	ValkeyAPI.rpushx(List<String> args)	Appends one or more elements to a list only when the list exists.
default Future<Response>	RedisAPI.sadd(List<String> args)	Adds one or more members to a set.
default Future<Response>	ValkeyAPI.sadd(List<String> args)	Adds one or more members to a set.
default Future<Response>	RedisAPI.save()	Synchronously saves the database(s) to disk.
default Future<Response>	ValkeyAPI.save()	Synchronously saves the database(s) to disk.
default Future<Response>	RedisAPI.scan(List<String> args)	Iterates over the key names in the database.
default Future<Response>	ValkeyAPI.scan(List<String> args)	Iterates over the key names in the database.
default Future<Response>	RedisAPI.scard(String arg0)	Returns the number of members in a set.
default Future<Response>	ValkeyAPI.scard(String arg0)	Returns the number of members in a set.
default Future<Response>	RedisAPI.script(List<String> args)	A container for Lua scripts management commands.
default Future<Response>	ValkeyAPI.script(List<String> args)	A container for Lua scripts management commands.
default Future<Response>	RedisAPI.sdiff(List<String> args)	Returns the difference of multiple sets.
default Future<Response>	ValkeyAPI.sdiff(List<String> args)	Returns the difference of multiple sets.
default Future<Response>	RedisAPI.sdiffstore(List<String> args)	Stores the difference of multiple sets in a key.
default Future<Response>	ValkeyAPI.sdiffstore(List<String> args)	Stores the difference of multiple sets in a key.
default Future<Response>	RedisAPI.searchClusterinfo(List<String> args)
default Future<Response>	RedisAPI.searchClusterrefresh(List<String> args)
default Future<Response>	RedisAPI.searchClusterset(List<String> args)
default Future<Response>	RedisAPI.select(String arg0)	Changes the selected database.
default Future<Response>	ValkeyAPI.select(String arg0)	Changes the selected database.
Future<Response>	Redis.send(Request command)	Send the given command to the Redis server or cluster.
Future<Response>	RedisAPI.send(Command cmd, String... args)	Send untyped command to Redis.
Future<Response>	RedisConnection.send(Request command)	Send the given command to the redis server or cluster.
Future<Response>	ValkeyAPI.send(Command cmd, String... args)	Send untyped command to Valkey.
default Future<Response>	RedisAPI.set(List<String> args)	Sets the string value of a key, ignoring its type.
default Future<Response>	ValkeyAPI.set(List<String> args)	Sets the string value of a key, ignoring its type.
default Future<Response>	RedisAPI.setbit(String arg0, String arg1, String arg2)	Sets or clears the bit at offset of the string value.
default Future<Response>	ValkeyAPI.setbit(String arg0, String arg1, String arg2)	Sets or clears the bit at offset of the string value.
default Future<Response>	RedisAPI.setex(String arg0, String arg1, String arg2)	Deprecated. since Redis 2.6.12, replaced by: SET with the EX argument
default Future<Response>	ValkeyAPI.setex(String arg0, String arg1, String arg2)	Sets the string value and expiration time of a key.
default Future<Response>	RedisAPI.setnx(String arg0, String arg1)	Deprecated. since Redis 2.6.12, replaced by: SET with the NX argument
default Future<Response>	ValkeyAPI.setnx(String arg0, String arg1)	Set the string value of a key only when the key doesn't exist.
default Future<Response>	RedisAPI.setrange(String arg0, String arg1, String arg2)	Overwrites a part of a string value with another by an offset.
default Future<Response>	ValkeyAPI.setrange(String arg0, String arg1, String arg2)	Overwrites a part of a string value with another by an offset.
default Future<Response>	RedisAPI.shutdown(List<String> args)	Synchronously saves the database(s) to disk and shuts down the Redis server.
default Future<Response>	ValkeyAPI.shutdown(List<String> args)	Synchronously saves the database(s) to disk and shuts down the server.
default Future<Response>	RedisAPI.sinter(List<String> args)	Returns the intersect of multiple sets.
default Future<Response>	ValkeyAPI.sinter(List<String> args)	Returns the intersect of multiple sets.
default Future<Response>	RedisAPI.sintercard(List<String> args)	Returns the number of members of the intersect of multiple sets.
default Future<Response>	ValkeyAPI.sintercard(List<String> args)	Returns the number of members of the intersect of multiple sets.
default Future<Response>	RedisAPI.sinterstore(List<String> args)	Stores the intersect of multiple sets in a key.
default Future<Response>	ValkeyAPI.sinterstore(List<String> args)	Stores the intersect of multiple sets in a key.
default Future<Response>	RedisAPI.sismember(String arg0, String arg1)	Determines whether a member belongs to a set.
default Future<Response>	ValkeyAPI.sismember(String arg0, String arg1)	Determines whether a member belongs to a set.
default Future<Response>	RedisAPI.slaveof(String arg0, String arg1)	Deprecated. since Redis 5.0.0, replaced by: REPLICAOF
default Future<Response>	ValkeyAPI.slaveof(String arg0, String arg1)	Deprecated. since Redis 5.0.0, replaced by: REPLICAOF
default Future<Response>	RedisAPI.slowlog(List<String> args)	A container for slow log commands.
default Future<Response>	ValkeyAPI.slowlog(List<String> args)	A container for slow log commands.
default Future<Response>	RedisAPI.smembers(String arg0)	Returns all members of a set.
default Future<Response>	ValkeyAPI.smembers(String arg0)	Returns all members of a set.
default Future<Response>	RedisAPI.smismember(List<String> args)	Determines whether multiple members belong to a set.
default Future<Response>	ValkeyAPI.smismember(List<String> args)	Determines whether multiple members belong to a set.
default Future<Response>	RedisAPI.smove(String arg0, String arg1, String arg2)	Moves a member from one set to another.
default Future<Response>	ValkeyAPI.smove(String arg0, String arg1, String arg2)	Moves a member from one set to another.
default Future<Response>	RedisAPI.sort(List<String> args)	Sorts the elements in a list, a set, or a sorted set, optionally storing the result.
default Future<Response>	ValkeyAPI.sort(List<String> args)	Sorts the elements in a list, a set, or a sorted set, optionally storing the result.
default Future<Response>	RedisAPI.sortRo(List<String> args)	Returns the sorted elements of a list, a set, or a sorted set.
default Future<Response>	ValkeyAPI.sortRo(List<String> args)	Returns the sorted elements of a list, a set, or a sorted set.
default Future<Response>	RedisAPI.spop(List<String> args)	Returns one or more random members from a set after removing them.
default Future<Response>	ValkeyAPI.spop(List<String> args)	Returns one or more random members from a set after removing them.
default Future<Response>	RedisAPI.spublish(String arg0, String arg1)	Post a message to a shard channel.
default Future<Response>	ValkeyAPI.spublish(String arg0, String arg1)	Post a message to a shard channel.
default Future<Response>	RedisAPI.srandmember(List<String> args)	Get one or multiple random members from a set.
default Future<Response>	ValkeyAPI.srandmember(List<String> args)	Get one or multiple random members from a set.
default Future<Response>	RedisAPI.srem(List<String> args)	Removes one or more members from a set.
default Future<Response>	ValkeyAPI.srem(List<String> args)	Removes one or more members from a set.
default Future<Response>	RedisAPI.sscan(List<String> args)	Iterates over members of a set.
default Future<Response>	ValkeyAPI.sscan(List<String> args)	Iterates over members of a set.
default Future<Response>	RedisAPI.ssubscribe(List<String> args)	Listens for messages published to shard channels.
default Future<Response>	ValkeyAPI.ssubscribe(List<String> args)	Listens for messages published to shard channels.
default Future<Response>	RedisAPI.strlen(String arg0)	Returns the length of a string value.
default Future<Response>	ValkeyAPI.strlen(String arg0)	Returns the length of a string value.
default Future<Response>	RedisAPI.subscribe(List<String> args)	Listens for messages published to channels.
default Future<Response>	ValkeyAPI.subscribe(List<String> args)	Listens for messages published to channels.
default Future<Response>	RedisAPI.substr(String arg0, String arg1, String arg2)	Deprecated. since Redis 2.0.0, replaced by: GETRANGE
default Future<Response>	ValkeyAPI.substr(String arg0, String arg1, String arg2)	Returns a substring from a string value.
default Future<Response>	RedisAPI.sunion(List<String> args)	Returns the union of multiple sets.
default Future<Response>	ValkeyAPI.sunion(List<String> args)	Returns the union of multiple sets.
default Future<Response>	RedisAPI.sunionstore(List<String> args)	Stores the union of multiple sets in a key.
default Future<Response>	ValkeyAPI.sunionstore(List<String> args)	Stores the union of multiple sets in a key.
default Future<Response>	RedisAPI.sunsubscribe(List<String> args)	Stops listening to messages posted to shard channels.
default Future<Response>	ValkeyAPI.sunsubscribe(List<String> args)	Stops listening to messages posted to shard channels.
default Future<Response>	RedisAPI.swapdb(String arg0, String arg1)	Swaps two Redis databases.
default Future<Response>	ValkeyAPI.swapdb(String arg0, String arg1)	Swaps two databases.
default Future<Response>	RedisAPI.sync()	An internal command used in replication.
default Future<Response>	ValkeyAPI.sync()	An internal command used in replication.
default Future<Response>	RedisAPI.tdigestAdd(List<String> args)	Adds one or more observations to a t-digest sketch.
default Future<Response>	RedisAPI.tdigestByrank(List<String> args)	Returns, for each input rank, an estimation of the value (floating-point) with that rank.
default Future<Response>	RedisAPI.tdigestByrevrank(List<String> args)	Returns, for each input reverse rank, an estimation of the value (floating-point) with that reverse rank.
default Future<Response>	RedisAPI.tdigestCdf(List<String> args)	Returns, for each input value, an estimation of the floating-point fraction of (observations smaller than the given value + half the observations equal to the given value).
default Future<Response>	RedisAPI.tdigestCreate(List<String> args)	Allocates memory and initializes a new t-digest sketch.
default Future<Response>	RedisAPI.tdigestInfo(String arg0)	Returns information and statistics about a t-digest sketch.
default Future<Response>	RedisAPI.tdigestInfo(List<String> args)	Returns information and statistics about a t-digest sketch.
default Future<Response>	RedisAPI.tdigestMax(String arg0)	Returns the maximum observation value from a t-digest sketch.
default Future<Response>	RedisAPI.tdigestMax(List<String> args)	Returns the maximum observation value from a t-digest sketch.
default Future<Response>	RedisAPI.tdigestMerge(List<String> args)	Merges multiple t-digest sketches into a single sketch.
default Future<Response>	RedisAPI.tdigestMin(String arg0)	Returns the minimum observation value from a t-digest sketch.
default Future<Response>	RedisAPI.tdigestMin(List<String> args)	Returns the minimum observation value from a t-digest sketch.
default Future<Response>	RedisAPI.tdigestQuantile(List<String> args)	Returns, for each input fraction, an estimation of the value (floating point) that is smaller than the given fraction of observations.
default Future<Response>	RedisAPI.tdigestRank(List<String> args)	Returns, for each input value (floating-point), the estimated rank of the value (the number of observations in the sketch that are smaller than the value + half the number of observations that are equal to the value).
default Future<Response>	RedisAPI.tdigestReset(String arg0)	Resets a t-digest sketch: empty the sketch and re-initializes it.
default Future<Response>	RedisAPI.tdigestReset(List<String> args)	Resets a t-digest sketch: empty the sketch and re-initializes it.
default Future<Response>	RedisAPI.tdigestRevrank(List<String> args)	Returns, for each input value (floating-point), the estimated reverse rank of the value (the number of observations in the sketch that are larger than the value + half the number of observations that are equal to the value).
default Future<Response>	RedisAPI.tdigestTrimmedMean(String arg0, String arg1, String arg2)	Returns an estimation of the mean value from the sketch, excluding observation values outside the low and high cutoff quantiles.
default Future<Response>	RedisAPI.tdigestTrimmedMean(List<String> args)	Returns an estimation of the mean value from the sketch, excluding observation values outside the low and high cutoff quantiles.
default Future<Response>	RedisAPI.time()	Returns the server time.
default Future<Response>	ValkeyAPI.time()	Returns the server time.
default Future<Response>	RedisAPI.timeseriesClusterset(List<String> args)
default Future<Response>	RedisAPI.timeseriesClustersetfromshard(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.timeseriesHello(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.timeseriesInfocluster(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.timeseriesInnercommunication(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.timeseriesNetworktest(List<String> args)	Deprecated. this command no longer exists in the latest Redis release
default Future<Response>	RedisAPI.timeseriesRefreshcluster(List<String> args)
default Future<Response>	RedisAPI.topkAdd(List<String> args)	Adds an item to a Top-k sketch.
default Future<Response>	RedisAPI.topkCount(List<String> args)	Return the count for one or more items are in a sketch.
default Future<Response>	RedisAPI.topkIncrby(List<String> args)	Increases the count of one or more items by increment.
default Future<Response>	RedisAPI.topkInfo(String arg0)	Returns information about a sketch.
default Future<Response>	RedisAPI.topkInfo(List<String> args)	Returns information about a sketch.
default Future<Response>	RedisAPI.topkList(List<String> args)	Return the full list of items in Top-K sketch.
default Future<Response>	RedisAPI.topkQuery(List<String> args)	Checks whether one or more items are in a sketch.
default Future<Response>	RedisAPI.topkReserve(List<String> args)	Initializes a Top-K sketch with specified parameters.
default Future<Response>	RedisAPI.touch(List<String> args)	Returns the number of existing keys out of those specified after updating the time they were last accessed.
default Future<Response>	ValkeyAPI.touch(List<String> args)	Returns the number of existing keys out of those specified after updating the time they were last accessed.
default Future<Response>	RedisAPI.trimslots(List<String> args)	Trim the keys that belong to specified slots.
default Future<Response>	RedisAPI.tsAdd(List<String> args)	Append a sample to a time series.
default Future<Response>	RedisAPI.tsAlter(List<String> args)	Update the retention, chunk size, duplicate policy, and labels of an existing time series.
default Future<Response>	RedisAPI.tsCreate(List<String> args)	Create a new time series.
default Future<Response>	RedisAPI.tsCreaterule(List<String> args)	Create a compaction rule.
default Future<Response>	RedisAPI.tsDecrby(List<String> args)	Decrease the value of the latest sample.
default Future<Response>	RedisAPI.tsDel(String arg0, String arg1, String arg2)	Delete all samples between two timestamps for a given time series.
default Future<Response>	RedisAPI.tsDel(List<String> args)	Delete all samples between two timestamps for a given time series.
default Future<Response>	RedisAPI.tsDeleterule(String arg0, String arg1)	Delete a compaction rule.
default Future<Response>	RedisAPI.tsDeleterule(List<String> args)	Delete a compaction rule.
default Future<Response>	RedisAPI.tsGet(List<String> args)	Get the sample with the highest timestamp from a given time series.
default Future<Response>	RedisAPI.tsIncrby(List<String> args)	Increase the value of the latest sample.
default Future<Response>	RedisAPI.tsInfo(List<String> args)	Returns information and statistics for a time series.
default Future<Response>	RedisAPI.tsMadd(List<String> args)	Append new samples to one or more time series.
default Future<Response>	RedisAPI.tsMget(List<String> args)	Get the sample with the highest timestamp from each time series matching a specific filter.
default Future<Response>	RedisAPI.tsMrange(List<String> args)	Query a range across multiple time series by filters in forward direction.
default Future<Response>	RedisAPI.tsMrevrange(List<String> args)	Query a range across multiple time series by filters in reverse direction.
default Future<Response>	RedisAPI.tsQueryindex(List<String> args)	Get all time series keys matching a filter list.
default Future<Response>	RedisAPI.tsRange(List<String> args)	Query a range in forward direction.
default Future<Response>	RedisAPI.tsRevrange(List<String> args)	Query a range in reverse direction.
default Future<Response>	RedisAPI.ttl(String arg0)	Returns the expiration time in seconds of a key.
default Future<Response>	ValkeyAPI.ttl(String arg0)	Returns the expiration time in seconds of a key.
default Future<Response>	RedisAPI.type(String arg0)	Determines the type of value stored at a key.
default Future<Response>	ValkeyAPI.type(String arg0)	Determines the type of value stored at a key.
default Future<Response>	RedisAPI.unlink(List<String> args)	Asynchronously deletes one or more keys.
default Future<Response>	ValkeyAPI.unlink(List<String> args)	Asynchronously deletes one or more keys.
default Future<Response>	RedisAPI.unsubscribe(List<String> args)	Stops listening to messages posted to channels.
default Future<Response>	ValkeyAPI.unsubscribe(List<String> args)	Stops listening to messages posted to channels.
default Future<Response>	RedisAPI.unwatch()	Forgets about watched keys of a transaction.
default Future<Response>	ValkeyAPI.unwatch()	Forgets about watched keys of a transaction.
default Future<Response>	RedisAPI.vadd(List<String> args)	Add one or more elements to a vector set, or update its vector if it already exists.
default Future<Response>	RedisAPI.vcard(String arg0)	Return the number of elements in a vector set.
default Future<Response>	RedisAPI.vdim(String arg0)	Return the dimension of vectors in the vector set.
default Future<Response>	RedisAPI.vemb(List<String> args)	Return the vector associated with an element.
default Future<Response>	RedisAPI.vgetattr(String arg0, String arg1)	Retrieve the JSON attributes of elements.
default Future<Response>	RedisAPI.vinfo(String arg0)	Return information about a vector set.
default Future<Response>	RedisAPI.vismember(String arg0, String arg1)	Check if an element exists in a vector set.
default Future<Response>	RedisAPI.vlinks(List<String> args)	Return the neighbors of an element at each layer in the HNSW graph.
default Future<Response>	RedisAPI.vrandmember(List<String> args)	Return one or multiple random members from a vector set.
default Future<Response>	RedisAPI.vrange(List<String> args)	Return vector set elements in a lex range.
default Future<Response>	RedisAPI.vrem(String arg0, String arg1)	Remove an element from a vector set.
default Future<Response>	RedisAPI.vsetattr(String arg0, String arg1, String arg2)	Associate or remove the JSON attributes of elements.
default Future<Response>	RedisAPI.vsim(List<String> args)	Return elements by vector similarity.
default Future<Response>	RedisAPI.wait(String arg0, String arg1)	Blocks until the asynchronous replication of all preceding write commands sent by the connection is completed.
default Future<Response>	ValkeyAPI.wait(String arg0, String arg1)	Blocks until the asynchronous replication of all preceding write commands sent by the connection is completed.
default Future<Response>	RedisAPI.waitaof(String arg0, String arg1, String arg2)	Blocks until all of the preceding write commands sent by the connection are written to the append-only file of the master and/or replicas.
default Future<Response>	ValkeyAPI.waitaof(String arg0, String arg1, String arg2)	Blocks until all of the preceding write commands sent by the connection are written to the append-only file of the primary and/or replicas.
default Future<Response>	RedisAPI.watch(List<String> args)	Monitors changes to keys to determine the execution of a transaction.
default Future<Response>	ValkeyAPI.watch(List<String> args)	Monitors changes to keys to determine the execution of a transaction.
default Future<Response>	RedisAPI.xack(List<String> args)	Returns the number of messages that were successfully acknowledged by the consumer group member of a stream.
default Future<Response>	ValkeyAPI.xack(List<String> args)	Returns the number of messages that were successfully acknowledged by the consumer group member of a stream.
default Future<Response>	RedisAPI.xackdel(List<String> args)	Acknowledges and deletes one or multiple messages for a stream consumer group.
default Future<Response>	RedisAPI.xadd(List<String> args)	Appends a new message to a stream.
default Future<Response>	ValkeyAPI.xadd(List<String> args)	Appends a new message to a stream.
default Future<Response>	RedisAPI.xautoclaim(List<String> args)	Changes, or acquires, ownership of messages in a consumer group, as if the messages were delivered to as consumer group member.
default Future<Response>	ValkeyAPI.xautoclaim(List<String> args)	Changes, or acquires, ownership of messages in a consumer group, as if the messages were delivered to as consumer group member.
default Future<Response>	RedisAPI.xcfgset(List<String> args)	Sets the IDMP configuration parameters for a stream.
default Future<Response>	RedisAPI.xclaim(List<String> args)	Changes, or acquires, ownership of a message in a consumer group, as if the message was delivered a consumer group member.
default Future<Response>	ValkeyAPI.xclaim(List<String> args)	Changes, or acquires, ownership of a message in a consumer group, as if the message was delivered a consumer group member.
default Future<Response>	RedisAPI.xdel(List<String> args)	Returns the number of messages after removing them from a stream.
default Future<Response>	ValkeyAPI.xdel(List<String> args)	Returns the number of messages after removing them from a stream.
default Future<Response>	RedisAPI.xdelex(List<String> args)	Deletes one or multiple entries from the stream.
default Future<Response>	RedisAPI.xgroup(List<String> args)	A container for consumer groups commands.
default Future<Response>	ValkeyAPI.xgroup(List<String> args)	A container for consumer groups commands.
default Future<Response>	RedisAPI.xidmprecord(String arg0, String arg1, String arg2, String arg3)	An internal command for setting IDMP metadata on an existing stream message.
default Future<Response>	RedisAPI.xinfo(List<String> args)	A container for stream introspection commands.
default Future<Response>	ValkeyAPI.xinfo(List<String> args)	A container for stream introspection commands.
default Future<Response>	RedisAPI.xlen(String arg0)	Return the number of messages in a stream.
default Future<Response>	ValkeyAPI.xlen(String arg0)	Return the number of messages in a stream.
default Future<Response>	RedisAPI.xpending(List<String> args)	Returns the information and entries from a stream consumer group's pending entries list.
default Future<Response>	ValkeyAPI.xpending(List<String> args)	Returns the information and entries from a stream consumer group's pending entries list.
default Future<Response>	RedisAPI.xrange(List<String> args)	Returns the messages from a stream within a range of IDs.
default Future<Response>	ValkeyAPI.xrange(List<String> args)	Returns the messages from a stream within a range of IDs.
default Future<Response>	RedisAPI.xread(List<String> args)	Returns messages from multiple streams with IDs greater than the ones requested.
default Future<Response>	ValkeyAPI.xread(List<String> args)	Returns messages from multiple streams with IDs greater than the ones requested.
default Future<Response>	RedisAPI.xreadgroup(List<String> args)	Returns new or historical messages from a stream for a consumer in a group.
default Future<Response>	ValkeyAPI.xreadgroup(List<String> args)	Returns new or historical messages from a stream for a consumer in a group.
default Future<Response>	RedisAPI.xrevrange(List<String> args)	Returns the messages from a stream within a range of IDs in reverse order.
default Future<Response>	ValkeyAPI.xrevrange(List<String> args)	Returns the messages from a stream within a range of IDs in reverse order.
default Future<Response>	RedisAPI.xsetid(List<String> args)	An internal command for replicating stream values.
default Future<Response>	ValkeyAPI.xsetid(List<String> args)	An internal command for replicating stream values.
default Future<Response>	RedisAPI.xtrim(List<String> args)	Deletes messages from the beginning of a stream.
default Future<Response>	ValkeyAPI.xtrim(List<String> args)	Deletes messages from the beginning of a stream.
default Future<Response>	RedisAPI.zadd(List<String> args)	Adds one or more members to a sorted set, or updates their scores.
default Future<Response>	ValkeyAPI.zadd(List<String> args)	Adds one or more members to a sorted set, or updates their scores.
default Future<Response>	RedisAPI.zcard(String arg0)	Returns the number of members in a sorted set.
default Future<Response>	ValkeyAPI.zcard(String arg0)	Returns the number of members in a sorted set.
default Future<Response>	RedisAPI.zcount(String arg0, String arg1, String arg2)	Returns the count of members in a sorted set that have scores within a range.
default Future<Response>	ValkeyAPI.zcount(String arg0, String arg1, String arg2)	Returns the count of members in a sorted set that have scores within a range.
default Future<Response>	RedisAPI.zdiff(List<String> args)	Returns the difference between multiple sorted sets.
default Future<Response>	ValkeyAPI.zdiff(List<String> args)	Returns the difference between multiple sorted sets.
default Future<Response>	RedisAPI.zdiffstore(List<String> args)	Stores the difference of multiple sorted sets in a key.
default Future<Response>	ValkeyAPI.zdiffstore(List<String> args)	Stores the difference of multiple sorted sets in a key.
default Future<Response>	RedisAPI.zincrby(String arg0, String arg1, String arg2)	Increments the score of a member in a sorted set.
default Future<Response>	ValkeyAPI.zincrby(String arg0, String arg1, String arg2)	Increments the score of a member in a sorted set.
default Future<Response>	RedisAPI.zinter(List<String> args)	Returns the intersect of multiple sorted sets.
default Future<Response>	ValkeyAPI.zinter(List<String> args)	Returns the intersect of multiple sorted sets.
default Future<Response>	RedisAPI.zintercard(List<String> args)	Returns the number of members of the intersect of multiple sorted sets.
default Future<Response>	ValkeyAPI.zintercard(List<String> args)	Returns the number of members of the intersect of multiple sorted sets.
default Future<Response>	RedisAPI.zinterstore(List<String> args)	Stores the intersect of multiple sorted sets in a key.
default Future<Response>	ValkeyAPI.zinterstore(List<String> args)	Stores the intersect of multiple sorted sets in a key.
default Future<Response>	RedisAPI.zlexcount(String arg0, String arg1, String arg2)	Returns the number of members in a sorted set within a lexicographical range.
default Future<Response>	ValkeyAPI.zlexcount(String arg0, String arg1, String arg2)	Returns the number of members in a sorted set within a lexicographical range.
default Future<Response>	RedisAPI.zmpop(List<String> args)	Returns the highest- or lowest-scoring members from one or more sorted sets after removing them.
default Future<Response>	ValkeyAPI.zmpop(List<String> args)	Returns the highest- or lowest-scoring members from one or more sorted sets after removing them.
default Future<Response>	RedisAPI.zmscore(List<String> args)	Returns the score of one or more members in a sorted set.
default Future<Response>	ValkeyAPI.zmscore(List<String> args)	Returns the score of one or more members in a sorted set.
default Future<Response>	RedisAPI.zpopmax(List<String> args)	Returns the highest-scoring members from a sorted set after removing them.
default Future<Response>	ValkeyAPI.zpopmax(List<String> args)	Returns the highest-scoring members from a sorted set after removing them.
default Future<Response>	RedisAPI.zpopmin(List<String> args)	Returns the lowest-scoring members from a sorted set after removing them.
default Future<Response>	ValkeyAPI.zpopmin(List<String> args)	Returns the lowest-scoring members from a sorted set after removing them.
default Future<Response>	RedisAPI.zrandmember(List<String> args)	Returns one or more random members from a sorted set.
default Future<Response>	ValkeyAPI.zrandmember(List<String> args)	Returns one or more random members from a sorted set.
default Future<Response>	RedisAPI.zrange(List<String> args)	Returns members in a sorted set within a range of indexes.
default Future<Response>	ValkeyAPI.zrange(List<String> args)	Returns members in a sorted set within a range of indexes.
default Future<Response>	RedisAPI.zrangebylex(List<String> args)	Deprecated. since Redis 6.2.0, replaced by: ZRANGE with the BYLEX argument
default Future<Response>	ValkeyAPI.zrangebylex(List<String> args)	Returns members in a sorted set within a lexicographical range.
default Future<Response>	RedisAPI.zrangebyscore(List<String> args)	Deprecated. since Redis 6.2.0, replaced by: ZRANGE with the BYSCORE argument
default Future<Response>	ValkeyAPI.zrangebyscore(List<String> args)	Returns members in a sorted set within a range of scores.
default Future<Response>	RedisAPI.zrangestore(List<String> args)	Stores a range of members from sorted set in a key.
default Future<Response>	ValkeyAPI.zrangestore(List<String> args)	Stores a range of members from sorted set in a key.
default Future<Response>	RedisAPI.zrank(String arg0, String arg1)	Returns the index of a member in a sorted set ordered by ascending scores.
default Future<Response>	RedisAPI.zrank(List<String> args)	Returns the index of a member in a sorted set ordered by ascending scores.
default Future<Response>	ValkeyAPI.zrank(List<String> args)	Returns the index of a member in a sorted set ordered by ascending scores.
default Future<Response>	RedisAPI.zrem(List<String> args)	Removes one or more members from a sorted set.
default Future<Response>	ValkeyAPI.zrem(List<String> args)	Removes one or more members from a sorted set.
default Future<Response>	RedisAPI.zremrangebylex(String arg0, String arg1, String arg2)	Removes members in a sorted set within a lexicographical range.
default Future<Response>	ValkeyAPI.zremrangebylex(String arg0, String arg1, String arg2)	Removes members in a sorted set within a lexicographical range.
default Future<Response>	RedisAPI.zremrangebyrank(String arg0, String arg1, String arg2)	Removes members in a sorted set within a range of indexes.
default Future<Response>	ValkeyAPI.zremrangebyrank(String arg0, String arg1, String arg2)	Removes members in a sorted set within a range of indexes.
default Future<Response>	RedisAPI.zremrangebyscore(String arg0, String arg1, String arg2)	Removes members in a sorted set within a range of scores.
default Future<Response>	ValkeyAPI.zremrangebyscore(String arg0, String arg1, String arg2)	Removes members in a sorted set within a range of scores.
default Future<Response>	RedisAPI.zrevrange(List<String> args)	Deprecated. since Redis 6.2.0, replaced by: ZRANGE with the REV argument
default Future<Response>	ValkeyAPI.zrevrange(List<String> args)	Returns members in a sorted set within a range of indexes in reverse order.
default Future<Response>	RedisAPI.zrevrangebylex(List<String> args)	Deprecated. since Redis 6.2.0, replaced by: ZRANGE with the REV and BYLEX arguments
default Future<Response>	ValkeyAPI.zrevrangebylex(List<String> args)	Returns members in a sorted set within a lexicographical range in reverse order.
default Future<Response>	RedisAPI.zrevrangebyscore(List<String> args)	Deprecated. since Redis 6.2.0, replaced by: ZRANGE with the REV and BYSCORE arguments
default Future<Response>	ValkeyAPI.zrevrangebyscore(List<String> args)	Returns members in a sorted set within a range of scores in reverse order.
default Future<Response>	RedisAPI.zrevrank(String arg0, String arg1)	Returns the index of a member in a sorted set ordered by descending scores.
default Future<Response>	RedisAPI.zrevrank(List<String> args)	Returns the index of a member in a sorted set ordered by descending scores.
default Future<Response>	ValkeyAPI.zrevrank(List<String> args)	Returns the index of a member in a sorted set ordered by descending scores.
default Future<Response>	RedisAPI.zscan(List<String> args)	Iterates over members and scores of a sorted set.
default Future<Response>	ValkeyAPI.zscan(List<String> args)	Iterates over members and scores of a sorted set.
default Future<Response>	RedisAPI.zscore(String arg0, String arg1)	Returns the score of a member in a sorted set.
default Future<Response>	ValkeyAPI.zscore(String arg0, String arg1)	Returns the score of a member in a sorted set.
default Future<Response>	RedisAPI.zunion(List<String> args)	Returns the union of multiple sorted sets.
default Future<Response>	ValkeyAPI.zunion(List<String> args)	Returns the union of multiple sorted sets.
default Future<Response>	RedisAPI.zunionstore(List<String> args)	Stores the union of multiple sorted sets in a key.
default Future<Response>	ValkeyAPI.zunionstore(List<String> args)	Stores the union of multiple sorted sets in a key.

Method parameters in io.vertx.redis.client with type arguments of type Future

Modifier and Type	Method	Description
static Redis	Redis.createClusterClient(Vertx vertx, RedisOptions options, Supplier<Future<RedisClusterConnectOptions>> connectOptions)	Creates a new cluster Redis client.
static Redis	Redis.createReplicationClient(Vertx vertx, RedisOptions options, Supplier<Future<RedisReplicationConnectOptions>> connectOptions)	Creates a new replication Redis client.
static Redis	Redis.createSentinelClient(Vertx vertx, RedisOptions options, Supplier<Future<RedisSentinelConnectOptions>> connectOptions)	Creates a new sentinel Redis client.
static Redis	Redis.createStandaloneClient(Vertx vertx, RedisOptions options, Supplier<Future<RedisStandaloneConnectOptions>> connectOptions)	Creates a new standalone Redis client.

Uses of Future in io.vertx.rxjava3

Methods in io.vertx.rxjava3 that return Future

Modifier and Type	Method	Description
static <T> Future<Void>	CompletableHelper.toFuture(Completable maybe)	Adapts an RxJava2 Completable<T> to a Vert.x .
static <T> Future<T>	MaybeHelper.toFuture(Maybe<T> maybe)	Adapts an RxJava2 Maybe<T> to a Vert.x Future<T>.
static <T,U> Future<U>	MaybeHelper.toFuture(Maybe<T> maybe, Function<T,U> adapter)	Like MaybeHelper.toFuture(Maybe) but with an adapter of the result.
static <T> Future<T>	SingleHelper.toFuture(Single<T> single)	Adapts an RxJava2 Single<T> to a Vert.x Future<T>.
static <T,U> Future<U>	SingleHelper.toFuture(Single<T> single, Function<T,U> adapter)	Like SingleHelper.toFuture(Single) but with an adapter of the result.

Method parameters in io.vertx.rxjava3 with type arguments of type Future

Modifier and Type	Method	Description
static <T> Flowable<T>	FlowableHelper.toFlowable(Supplier<Future<ReadStream<T>>> supplier)	Adapts a Vert.x ReadStream<T> to an RxJava Flowable<T>.

Uses of Future in io.vertx.servicediscovery

Methods in io.vertx.servicediscovery that return Future

Modifier and Type	Method	Description
Future<Record>	ServiceDiscovery.getRecord(JsonObject filter)	Lookups for a single record.
Future<Record>	ServiceDiscovery.getRecord(String id)	Looks up for a single record by its registration id.
Future<Record>	ServiceDiscovery.getRecord(Function<Record,Boolean> filter)	Lookups for a single record.
Future<Record>	ServiceDiscovery.getRecord(Function<Record,Boolean> filter, boolean includeOutOfService)	Lookups for a single record.
Future<List<Record>>	ServiceDiscovery.getRecords(JsonObject filter)	Lookups for a set of records.
Future<List<Record>>	ServiceDiscovery.getRecords(Function<Record,Boolean> filter)	Lookups for a set of records.
Future<List<Record>>	ServiceDiscovery.getRecords(Function<Record,Boolean> filter, boolean includeOutOfService)	Lookups for a set of records.
Future<Record>	ServiceDiscovery.publish(Record record)	Publishes a record.
Future<Void>	ServiceDiscovery.registerServiceExporter(ServiceExporter exporter, JsonObject configuration)	Registers a discovery bridge.
Future<Void>	ServiceDiscovery.registerServiceImporter(ServiceImporter importer, JsonObject configuration)	Registers a discovery service importer.
Future<Void>	ServiceDiscovery.unpublish(String id)	Un-publishes a record.
Future<Record>	ServiceDiscovery.update(Record record)	Updates the given record.

Uses of Future in io.vertx.servicediscovery.spi

Methods in io.vertx.servicediscovery.spi that return Future

Modifier and Type	Method	Description
Future<Record>	ServicePublisher.publish(Record record)	Publishes a record.
Future<Void>	ServicePublisher.unpublish(String id)	Un-publishes a record.
Future<Record>	ServicePublisher.update(Record record)	Updates an existing record.

Uses of Future in io.vertx.servicediscovery.types

Methods in io.vertx.servicediscovery.types that return Future

Modifier and Type	Method	Description
static Future<HttpClient>	HttpEndpoint.getClient(ServiceDiscovery discovery, JsonObject filter)	Convenient method that looks for a HTTP endpoint and provides the configured HttpClient.
static Future<HttpClient>	HttpEndpoint.getClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf)	Convenient method that looks for a HTTP endpoint and provides the configured HttpClient.
static Future<HttpClient>	HttpEndpoint.getClient(ServiceDiscovery discovery, Function<Record,Boolean> filter)	Convenient method that looks for a HTTP endpoint and provides the configured HttpClient.
static Future<HttpClient>	HttpEndpoint.getClient(ServiceDiscovery discovery, Function<Record,Boolean> filter, JsonObject conf)	Convenient method that looks for a HTTP endpoint and provides the configured HttpClient.
static <T> Future<MessageConsumer<T>>	MessageSource.getConsumer(ServiceDiscovery discovery, JsonObject filter)	Convenient method that looks for a message source and provides the configured MessageConsumer.
static <T> Future<MessageConsumer<T>>	MessageSource.getConsumer(ServiceDiscovery discovery, Function<Record,Boolean> filter)	Convenient method that looks for a message source and provides the configured MessageConsumer.
static Future<MongoClient>	MongoDataSource.getMongoClient(ServiceDiscovery discovery, JsonObject filter)	Convenient method that looks for a Mongo datasource source and provides the configured MongoClient.
static Future<MongoClient>	MongoDataSource.getMongoClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration)	Convenient method that looks for a Mongo datasource source and provides the configured MongoClient.
static Future<MongoClient>	MongoDataSource.getMongoClient(ServiceDiscovery discovery, Function<Record,Boolean> filter)	Convenient method that looks for a Mongo datasource source and provides the configured MongoClient.
static <T> Future<T>	EventBusService.getProxy(ServiceDiscovery discovery, Class<T> itf)	Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
static <T> Future<T>	EventBusService.getProxy(ServiceDiscovery discovery, Class<T> itf, JsonObject conf)	Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
static Future<Redis>	RedisDataSource.getRedisClient(ServiceDiscovery discovery, JsonObject filter)	Convenient method that looks for a Redis data source and provides the configured Redis.
static Future<Redis>	RedisDataSource.getRedisClient(ServiceDiscovery discovery, JsonObject filter, JsonObject consumerConfiguration)	Convenient method that looks for a Redis data source and provides the configured Redis.
static Future<Redis>	RedisDataSource.getRedisClient(ServiceDiscovery discovery, Function<Record,Boolean> filter)	Convenient method that looks for a Redis data source and provides the configured Redis.
static Future<Redis>	RedisDataSource.getRedisClient(ServiceDiscovery discovery, Function<Record,Boolean> filter, JsonObject consumerConfiguration)	Convenient method that looks for a Redis data source and provides the configured Redis.
static <T> Future<T>	EventBusService.getServiceProxy(ServiceDiscovery discovery, Function<Record,Boolean> filter, Class<T> clientClass)	Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
static <T> Future<T>	EventBusService.getServiceProxy(ServiceDiscovery discovery, Function<Record,Boolean> filter, Class<T> clientClass, JsonObject conf)	Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
static <T> Future<T>	EventBusService.getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass)	Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
static <T> Future<T>	EventBusService.getServiceProxyWithJsonFilter(ServiceDiscovery discovery, JsonObject filter, Class<T> clientClass, JsonObject conf)	Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
static Future<WebClient>	HttpEndpoint.getWebClient(ServiceDiscovery discovery, JsonObject filter)	Convenient method that looks for a HTTP endpoint and provides the configured .
static Future<WebClient>	HttpEndpoint.getWebClient(ServiceDiscovery discovery, JsonObject filter, JsonObject conf)	Convenient method that looks for a HTTP endpoint and provides the configured WebClient.
static Future<WebClient>	HttpEndpoint.getWebClient(ServiceDiscovery discovery, Function<Record,Boolean> filter)	Convenient method that looks for a HTTP endpoint and provides the configured WebClient.
static Future<WebClient>	HttpEndpoint.getWebClient(ServiceDiscovery discovery, Function<Record,Boolean> filter, JsonObject conf)	Convenient method that looks for a HTTP endpoint and provides the configured WebClient.

Uses of Future in io.vertx.serviceproxy

Methods in io.vertx.serviceproxy that return Future

Modifier and Type	Method	Description
static <T> Future<T>	ServiceException.fail(int failureCode, String message)	Create a failed Future containing a ServiceException.
static <T> Future<T>	ServiceException.fail(int failureCode, String message, JsonObject debugInfo)	Create a failed Future containing a ServiceException.
Future<Message<JsonObject>>	ServiceInterceptor.intercept(Vertx vertx, Map<String,Object> interceptorContext, Message<JsonObject> body)	Perform the interceptor handling

Uses of Future in io.vertx.serviceresolver

Methods in io.vertx.serviceresolver that return Future

Modifier and Type	Method	Description
Future<Void>	ServiceResolverClient.close()	Close the client and release the resources.
Future<Endpoint>	ServiceResolverClient.resolveEndpoint(ServiceAddress address)

Uses of Future in io.vertx.sqlclient

Methods in io.vertx.sqlclient that return Future

Modifier and Type	Method	Description
Future<Transaction>	SqlConnection.begin()	Begin a transaction and returns a Transaction for controlling and tracking this transaction.
Future<Void>	Cursor.close()	Release the cursor.
Future<Void>	PreparedStatement.close()	Close the prepared query and release its resources.
Future<Void>	RowStream.close()	Close the stream and release the resources.
Future<Void>	SqlClient.close()	Close the client and release the associated resources.
Future<Void>	Transaction.commit()	Commit the current transaction.
Future<Void>	Transaction.completion()	Return the transaction completion Future that succeeds when the transaction commits and fails with TransactionRollbackException when the transaction rolls back.
Future<T>	PreparedQuery.execute(Tuple tuple)	Execute the query.
Future<T>	Query.execute()	Execute the query.
Future<T>	PreparedQuery.executeBatch(List<Tuple> batch)	Execute the query with a batch of tuples.
Future<SqlConnection>	Pool.getConnection()	Get a connection from the pool.
Future<PreparedStatement>	SqlConnection.prepare(String sql)	Create a prepared statement using the given sql string.
Future<PreparedStatement>	SqlConnection.prepare(String sql, PrepareOptions options)	Create a prepared statement using the given sql string.
Future<RowSet<Row>>	Cursor.read(int count)	Read rows from the cursor, the result is provided asynchronously to the handler.
Future<Void>	Transaction.rollback()	Rollback the transaction and release the associated resources.
default <T> Future<T>	Pool.withConnection(Function<SqlConnection, Future<T>> function)	Get a connection from the pool and execute the given function.
default <T> Future<T>	Pool.withTransaction(TransactionPropagation txPropagation, Function<SqlConnection, Future<T>> function)	Like Pool.withTransaction(Function) but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
default <T> Future<T>	Pool.withTransaction(Function<SqlConnection, Future<T>> function)	Execute the given function within a transaction.

Method parameters in io.vertx.sqlclient with type arguments of type Future

Modifier and Type	Method	Description
ClientBuilder<C>	ClientBuilder.connectingTo(Supplier<Future<SqlConnectOptions>> supplier)	Configure the database the client should connect to.
default <T> Future<T>	Pool.withConnection(Function<SqlConnection, Future<T>> function)	Get a connection from the pool and execute the given function.
default <T> Future<T>	Pool.withTransaction(TransactionPropagation txPropagation, Function<SqlConnection, Future<T>> function)	Like Pool.withTransaction(Function) but allows for setting the mode, defining how the acquired connection is managed during the execution of the function.
default <T> Future<T>	Pool.withTransaction(Function<SqlConnection, Future<T>> function)	Execute the given function within a transaction.

Uses of Future in io.vertx.sqlclient.spi

Method parameters in io.vertx.sqlclient.spi with type arguments of type Future

Modifier and Type	Method	Description
default Pool	Driver.createPool(Vertx vertx, Supplier<Future<C>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler)	Create a connection pool to the database configured with the given connectOptions and poolOptions.
Pool	Driver.newPool(Vertx vertx, Supplier<Future<C>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)	Create a connection pool to the database configured with the given connectOptions and poolOptions.
protected Pool	DriverBase.newPool(io.vertx.core.internal.VertxInternal vertx, Handler<SqlConnection> connectHandler, Supplier<Future<O>> databases, PoolOptions poolOptions, NetClientOptions transportOptions, io.vertx.core.internal.CloseFuture closeFuture)
Pool	DriverBase.newPool(Vertx vertx, Supplier<Future<O>> databases, PoolOptions options, NetClientOptions transportOptions, Handler<SqlConnection> connectHandler, io.vertx.core.internal.CloseFuture closeFuture)

Constructor parameters in io.vertx.sqlclient.spi with type arguments of type Future

Modifier	Constructor	Description
	DriverBase(String discriminant, Function<Connection, Future<Void>> afterAcquire, Function<Connection, Future<Void>> beforeRecycle)

Uses of Future in io.vertx.sqlclient.spi.connection

Methods in io.vertx.sqlclient.spi.connection that return Future

Modifier and Type	Method	Description
Future<Connection>	ConnectionFactory.connect(Context context, C options)	Create a connection using the given context.
default Future<Connection>	ConnectionFactory.connect(Context context, Future<C> fut)

Methods in io.vertx.sqlclient.spi.connection with parameters of type Future

Modifier and Type	Method	Description
default Future<Connection>	ConnectionFactory.connect(Context context, Future<C> fut)

Uses of Future in io.vertx.sqlclient.spi.protocol

Methods in io.vertx.sqlclient.spi.protocol that return Future

Modifier and Type	Method	Description
default <R> Future<R>	CommandScheduler.schedule(io.vertx.core.internal.ContextInternal context, CommandBase<R> cmd)

Uses of Future in io.vertx.sqlclient.templates

Methods in io.vertx.sqlclient.templates that return Future

Modifier and Type	Method	Description
Future<R>	SqlTemplate.execute(I params)	Execute the query with the parameters
Future<R>	SqlTemplate.executeBatch(List<I> batch)	Execute a batch query with the batch.