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

- Packages that use Handler
  Package | Description
  --- | ---
  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.parsetools |
  io.vertx.core.shareddata |
  io.vertx.core.spi |
  io.vertx.core.spi.cluster |
  io.vertx.core.streams |
  io.vertx.ext.auth |
  io.vertx.ext.auth.mongo |
  io.vertx.ext.jdbc |
  io.vertx.ext.mail |
  io.vertx.ext.mongo |
  io.vertx.ext.shell |
  io.vertx.ext.shell.command |
  io.vertx.ext.shell.io |
  io.vertx.ext.shell.registry |
  io.vertx.ext.stomp |
  io.vertx.ext.sync |
  io.vertx.ext.unit |
  io.vertx.ext.unit.collect |
  io.vertx.ext.unit.report |
  io.vertx.ext.web |
  io.vertx.ext.web.handler |
  io.vertx.ext.web.handler.sockjs |
  io.vertx.ext.web.sstore |
  io.vertx.ext.web.templ |
  io.vertx.lang.rxjava |
  io.vertx.redis |
  io.vertx.rx.java |
  io.vertx.rxjava.core |
  io.vertx.rxjava.core.datagram |
  io.vertx.rxjava.core.dns |
  io.vertx.rxjava.core.eventbus |
  io.vertx.rxjava.core.file |
  io.vertx.rxjava.core.http |
  io.vertx.rxjava.core.net |
  io.vertx.rxjava.core.parsetools |
  io.vertx.rxjava.core.shareddata |
  io.vertx.rxjava.core.streams |
  io.vertx.rxjava.ext.auth |
  io.vertx.rxjava.ext.auth.common |
  io.vertx.rxjava.ext.auth.mongo |
  io.vertx.rxjava.ext.jdbc |
  io.vertx.rxjava.ext.mail |
  io.vertx.rxjava.ext.mongo |
  io.vertx.rxjava.ext.shell |
  io.vertx.rxjava.ext.shell.command |
  io.vertx.rxjava.ext.shell.io |
  io.vertx.rxjava.ext.shell.registry |
  io.vertx.rxjava.ext.stomp |
  io.vertx.rxjava.ext.unit |
  io.vertx.rxjava.ext.unit.collect |
  io.vertx.rxjava.ext.unit.report |
  io.vertx.rxjava.ext.web |
  io.vertx.rxjava.ext.web.handler |
  io.vertx.rxjava.ext.web.handler.sockjs |
  io.vertx.rxjava.ext.web.sstore |
  io.vertx.rxjava.ext.web.templ |
  io.vertx.rxjava.redis |
  io.vertx.serviceproxy |
  io.vertx.spi.cluster.hazelcast |

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

    Subinterfaces of Handler in io.vertx.core
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `AsyncResultHandler<T>` Handler for `AsyncResult`

    Classes in io.vertx.core that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `VoidHandler` This class can be used for simple handlers which don't receive any value.

    Methods in io.vertx.core with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Vertx.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Vertx.close()` but the completionHandler will be called when the close is complete
    `static void` | Vertx.`clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)` Creates a clustered instance using the specified options.
    `void` | Vertx.`deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(String, Handler)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(String)` but the completionHandler will be notified when the deployment is complete.
    `void` | Vertx.`deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(Verticle, Handler)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler)` Like `Vertx.deployVerticle(Verticle)` but the completionHandler will be notified when the deployment is complete.
    `TimeoutStream` | TimeoutStream.`endHandler(Handler<Void> endHandler)`
    `TimeoutStream` | TimeoutStream.`exceptionHandler(Handler<Throwable> handler)`
    `<T> void` | Context.`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context.executeBlocking(Handler, boolean, Handler)` with order = true.
    `<T> void` | Context.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context.executeBlocking(Handler, boolean, Handler)` with order = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx.executeBlocking(Handler, boolean, Handler)` called with ordered = true.
    `TimeoutStream` | TimeoutStream.`handler(Handler<Long> handler)`
    `void` | Context.`runOnContext(Handler<Void> action)` Run the specified action asynchronously on the same context, some time after the current execution has completed.
    `void` | Vertx.`runOnContext(Handler<Void> action)` Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
    `void` | Future.`setHandler(Handler<AsyncResult<T>> handler)` Set a handler for the result.
    `long` | Vertx.`setPeriodic(long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setTimer(long delay, Handler<Long> handler)` Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `void` | Vertx.`undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)` Like `Vertx.undeploy(String)` but the completionHandler will be notified when the undeployment is complete.

  - ### Uses of Handler in io.vertx.core.datagram

    Methods in io.vertx.core.datagram with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address and notifies the `Handler` once the operation completes.
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address on the given network interface and notifies the `Handler` once the operation completes.
    `void` | DatagramSocket.`close(Handler<AsyncResult<Void>> handler)` Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `PacketWritestream` | PacketWritestream.`drainHandler(Handler<Void> handler)`
    `DatagramSocket` | DatagramSocket.`endHandler(Handler<Void> endHandler)`
    `DatagramSocket` | DatagramSocket.`exceptionHandler(Handler<Throwable> handler)`
    `PacketWritestream` | PacketWritestream.`exceptionHandler(Handler<Throwable> handler)`
    `DatagramSocket` | DatagramSocket.`handler(Handler<DatagramPacket> handler)`
    `DatagramSocket` | DatagramSocket.`listen(int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Start listening on the given port and host.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it on the given network interface.
    `DatagramSocket` | DatagramSocket.`send(Buffer packet, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `Buffer` to the `SocketAddress`.
    `DatagramSocket` | DatagramSocket.`send(String str, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `DatagramSocket` | DatagramSocket.`send(String str, String enc, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using the given encoding.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it on the given network interface.

  - ### Uses of Handler in io.vertx.core.dns

    Methods in io.vertx.core.dns with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DnsClient` | DnsClient.`lookup(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`lookup4(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) record for the given name.
    `DnsClient` | DnsClient.`lookup6(String name, Handler<AsyncResult<String>> handler)` Try to lookup the AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`resolveA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all A (ipv4) records for the given name.
    `DnsClient` | DnsClient.`resolveAAAA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all AAAA (ipv6) records for the given name.
    `DnsClient` | DnsClient.`resolveCNAME(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the CNAME record for the given name.
    `DnsClient` | DnsClient.`resolveMX(String name, Handler<AsyncResult<List<MxRecord>>> handler)` Try to resolve the MX records for the given name.
    `DnsClient` | DnsClient.`resolveNS(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the NS records for the given name.
    `DnsClient` | DnsClient.`resolvePTR(String name, Handler<AsyncResult<String>> handler)` Try to resolve the PTR record for the given name.
    `DnsClient` | DnsClient.`resolveSRV(String name, Handler<AsyncResult<List<SrvRecord>>> handler)` Try to resolve the SRV records for the given name.
    `DnsClient` | DnsClient.`resolveTXT(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the TXT records for the given name.
    `DnsClient` | DnsClient.`reverseLookup(String ipaddress, Handler<AsyncResult<String>> handler)` Try to do a reverse lookup of an IP address.

  - ### Uses of Handler in io.vertx.core.eventbus

    Methods in io.vertx.core.eventbus with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | EventBus.`close(Handler<AsyncResult<Void>> completionHandler)` Close the event bus and release any resources held
    `void` | MessageConsumer.`completionHandler(Handler<AsyncResult<Void>> completionHandler)` Optional method which can be called to indicate when the registration has been propagated across the cluster.
    `<T> MessageConsumer<T>` | EventBus.`consumer(String address, Handler<Message<T>> handler)` Create a consumer and register it against the specified address.
    `MessageProducer<T>` | MessageProducer.`drainHandler(Handler<Void> handler)`
    `MessageConsumer<T>` | MessageConsumer.`endHandler(Handler<Void> endHandler)`
    `MessageConsumer<T>` | MessageConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageProducer<T>` | MessageProducer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageConsumer<T>` | MessageConsumer.`handler(Handler<Message<T>> handler)`
    `<T> MessageConsumer<T>` | EventBus.`localConsumer(String address, Handler<Message<T>> handler)` Like `EventBus.consumer(String, Handler)` but the address won't be propagated across the cluster.
    `<R> void` | Message.`reply(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler)` The same as `reply(R message, DeliveryOptions)` but you can specify handler for the reply - i.e.
    `<R> void` | Message.`reply(Object message, Handler<AsyncResult<Message<R>>> replyHandler)` The same as `reply(R message)` but you can specify handler for the reply - i.e.
    `<T> EventBus` | EventBus.`send(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Like `EventBus.send(String, Object, DeliveryOptions)` but specifying a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `<T> EventBus` | EventBus.`send(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Like `EventBus.send(String, Object)` but specifying a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `void` | MessageConsumer.`unregister(Handler<AsyncResult<Void>> completionHandler)` Unregisters the handler which created this registration

  - ### Uses of Handler in io.vertx.core.file

    Methods in io.vertx.core.file with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `FileSystem` | FileSystem.`chmod(String path, String perms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chown(String path, String user, String group, Handler<AsyncResult<Void>> handler)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `void` | AsyncFile.`close(Handler<AsyncResult<Void>> handler)` Close the file.
    `FileSystem` | FileSystem.`copy(String from, String to, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, String perms, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `FileSystem` | FileSystem.`delete(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`drainHandler(Handler<Void> handler)`
    `AsyncFile` | AsyncFile.`endHandler(Handler<Void> endHandler)`
    `AsyncFile` | AsyncFile.`exceptionHandler(Handler<Throwable> handler)`
    `FileSystem` | FileSystem.`exists(String path, Handler<AsyncResult<Boolean>> handler)` Determines whether the file as specified by the path `path` exists, asynchronously.
    `AsyncFile` | AsyncFile.`flush(Handler<AsyncResult<Void>> handler)` Same as `AsyncFile.flush()` but the handler will be called when the flush is complete or if an error occurs
    `FileSystem` | FileSystem.`fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler)` Returns properties of the file-system being used by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`handler(Handler<Buffer> handler)`
    `FileSystem` | FileSystem.`link(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a hard link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`lprops(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the link represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler)` Open the file represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`props(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the file represented by `path`, asynchronously.
    `AsyncFile` | AsyncFile.`read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler)` Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a `Buffer`, asynchronously.
    `FileSystem` | FileSystem.`readSymlink(String link, Handler<AsyncResult<String>> handler)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `FileSystem` | FileSystem.`symlink(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`truncate(String path, long len, Handler<AsyncResult<Void>> handler)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `FileSystem` | FileSystem.`unlink(String link, Handler<AsyncResult<Void>> handler)` Unlinks the link on the file system represented by the path `link`, asynchronously.
    `AsyncFile` | AsyncFile.`write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler)` Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.

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

    Methods in io.vertx.core.http that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<HttpServerRequest>` | HttpServer.`requestHandler()`
    `Handler<ServerWebSocket>` | HttpServer.`websocketHandler()`

    Methods in io.vertx.core.http with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `HttpServerResponse` | HttpServerResponse.`bodyEndHandler(Handler<Void> handler)` Provide a handler that will be called just before the last part of the body is written to the wire and the response is ended.
    `HttpClientResponse` | HttpClientResponse.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `HttpServerRequest` | HttpServerRequest.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `void` | HttpServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `HttpServer.close()` but supplying a handler that will be called when the server is actually closed (or has failed).
    `HttpServerResponse` | HttpServerResponse.`closeHandler(Handler<Void> handler)` Set a close handler for the response.
    `ServerWebSocket` | ServerWebSocket.`closeHandler(Handler<Void> handler)`
    `WebSocket` | WebSocket.`closeHandler(Handler<Void> handler)`
    `WebSocketBase` | WebSocketBase.`closeHandler(Handler<Void> handler)` Set a close handler.
    `HttpClientRequest` | HttpClientRequest.`continueHandler(Handler<Void> handler)` If you send an HTTP request with the header `Expect` set to the value `100-continue` and the server responds with an interim HTTP response with a status code of `100` and a continue handler has been set using this method, then the `handler` will be called.
    `HttpClientRequest` | HttpClient.`delete(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`delete(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`delete(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`deleteAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP DELETE request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClientRequest.`drainHandler(Handler<Void> handler)`
    `HttpServerResponse` | HttpServerResponse.`drainHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`drainHandler(Handler<Void> handler)`
    `WebSocket` | WebSocket.`drainHandler(Handler<Void> handler)`
    `WebSocketBase` | WebSocketBase.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`endHandler(Handler<Void> endHandler)`
    `HttpClientResponse` | HttpClientResponse.`endHandler(Handler<Void> endHandler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler(Handler<Void> endHandler)`
    `HttpServerRequest` | HttpServerRequest.`endHandler(Handler<Void> endHandler)`
    `HttpServerRequestStream` | HttpServerRequestStream.`endHandler(Handler<Void> endHandler)`
    `ServerWebSocket` | ServerWebSocket.`endHandler(Handler<Void> endHandler)`
    `ServerWebSocketStream` | ServerWebSocketStream.`endHandler(Handler<Void> endHandler)`
    `WebSocket` | WebSocket.`endHandler(Handler<Void> endHandler)`
    `WebSocketBase` | WebSocketBase.`endHandler(Handler<Void> endHandler)`
    `WebSocketStream` | WebSocketStream.`endHandler(Handler<Void> endHandler)`
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerRequestStream` | HttpServerRequestStream.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocketStream` | ServerWebSocketStream.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocket` | WebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocketBase` | WebSocketBase.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocketStream` | WebSocketStream.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocket` | WebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocketBase` | WebSocketBase.`frameHandler(Handler<WebSocketFrame> handler)` Set a frame handler on the connection.
    `HttpClientRequest` | HttpClient.`get(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP GET request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`get(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP GET request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`get(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP GET request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`getAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`getNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`getNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`getNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientResponse` | HttpClientResponse.`handler(Handler<Buffer> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`handler(Handler<Buffer> handler)`
    `HttpServerRequest` | HttpServerRequest.`handler(Handler<Buffer> handler)`
    `ServerWebSocket` | ServerWebSocket.`handler(Handler<Buffer> handler)`
    `WebSocket` | WebSocket.`handler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`handler(Handler<Buffer> handler)`
    `HttpClientRequest` | HttpClientRequest.`handler(Handler<HttpClientResponse> handler)`
    `HttpServerRequestStream` | HttpServerRequestStream.`handler(Handler<HttpServerRequest> handler)`
    `ServerWebSocketStream` | ServerWebSocketStream.`handler(Handler<ServerWebSocket> handler)`
    `WebSocketStream` | WebSocketStream.`handler(Handler<WebSocket> handler)`
    `HttpClientRequest` | HttpClient.`head(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP HEAD request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`head(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP HEAD request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`head(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP HEAD request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`headAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP HEAD request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler(Handler<Void> handler)` Provide a handler that will be called just before the headers are written to the wire.
    `HttpClient` | HttpClient.`headNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`headNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`headNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpServer` | HttpServer.`listen(Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen(int, String)` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpClientRequest` | HttpClient.`options(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`options(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`options(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`optionsAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP OPTIONS request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`optionsNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP OPTIONS request to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`optionsNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP OPTIONS request to the server at the default host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`optionsNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP OPTIONS request to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`post(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`post(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`post(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`postAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP POST request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`put(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`put(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`put(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`putAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP PUT request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`requestAbs(HttpMethod method, String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpServer` | HttpServer.`requestHandler(Handler<HttpServerRequest> handler)` Set the request handler for the server to `requestHandler`.
    `default HttpServerResponse` | HttpServerResponse.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(String)` but providing a handler which will be notified once the file has been completely written to the wire.
    `default HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(String, long)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(String, long, long)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerRequest` | HttpServerRequest.`uploadHandler(Handler<HttpServerFileUpload> uploadHandler)` Set an upload handler.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified port, host and relative request URI
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect)` Connect a WebSocket at the relative request URI using the default host and port
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Connect a WebSocket at the relative request URI using the default host and port and the specified headers
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port and the specified headers
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port and the specified headers
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the specified version of WebSockets and the specified sub protocols
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the specified version of WebSockets and the specified sub protocols
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the specified version of WebSockets and the specified sub protocols
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect)` Connect a WebSocket to the host and relative request URI and default port
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the host and relative request URI and default port
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the host and relative request URI and default port
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpServer` | HttpServer.`websocketHandler(Handler<ServerWebSocket> handler)` Set the websocket handler for the server to `wsHandler`.

  - ### Uses of Handler in io.vertx.core.net

    Methods in io.vertx.core.net that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<NetSocket>` | NetServer.`connectHandler()`

    Methods in io.vertx.core.net with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `NetServer.close()` but supplying a handler that will be notified when close is complete.
    `NetSocket` | NetSocket.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the NetSocket is closed
    `NetClient` | NetClient.`connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetServer` | NetServer.`connectHandler(Handler<NetSocket> handler)` Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler(Handler<Void> handler)`
    `NetSocket` | NetSocket.`endHandler(Handler<Void> endHandler)`
    `NetSocketStream` | NetSocketStream.`endHandler(Handler<Void> endHandler)`
    `NetSocket` | NetSocket.`exceptionHandler(Handler<Throwable> handler)`
    `NetSocketStream` | NetSocketStream.`exceptionHandler(Handler<Throwable> handler)`
    `NetSocket` | NetSocket.`handler(Handler<Buffer> handler)`
    `NetSocketStream` | NetSocketStream.`handler(Handler<NetSocket> handler)`
    `NetServer` | NetServer.`listen(Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(int)` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen(int, String)` but providing a handler that will be notified when the server is listening, or fails.
    `default NetSocket` | NetSocket.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(String)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `default NetSocket` | NetSocket.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(String, long)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(String, long, long)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`upgradeToSsl(Handler<Void> handler)` Upgrade channel to use SSL/TLS.

  - ### Uses of Handler in io.vertx.core.parsetools

    Subinterfaces of Handler in io.vertx.core.parsetools
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `RecordParser` A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.

    Methods in io.vertx.core.parsetools with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Handler<Buffer> output)` Create a new `RecordParser` instance, initially in delimited mode, and where the delimiter can be represented by the `Buffer` delim.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Handler<Buffer> output)` Create a new `RecordParser` instance, initially in delimited mode, and where the delimiter can be represented by the String delim endcoded in latin-1 .
    `static RecordParser` | RecordParser.`newFixed(int size, Handler<Buffer> output)` Create a new `RecordParser` instance, initially in fixed size mode, and where the record size is specified by the `size` parameter.
    `void` | RecordParser.`setOutput(Handler<Buffer> output)`

  - ### Uses of Handler in io.vertx.core.shareddata

    Methods in io.vertx.core.shareddata with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Counter.`addAndGet(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the new count
    `void` | AsyncMap.`clear(Handler<AsyncResult<Void>> resultHandler)` Clear all entries in the map
    `void` | Counter.`compareAndSet(long expected, long value, Handler<AsyncResult<Boolean>> resultHandler)` Set the counter to the specified value only if the current value is the expectec value.
    `void` | Counter.`decrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Decrement the counter atomically and return the new count
    `void` | Counter.`get(Handler<AsyncResult<Long>> resultHandler)` Get the current value of the counter
    `void` | AsyncMap.`get(K k, Handler<AsyncResult<V>> resultHandler)` Get a value from the map, asynchronously.
    `void` | Counter.`getAndAdd(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the value before the add
    `void` | Counter.`getAndIncrement(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the value before the increment.
    `<K,V> void` | SharedData.`getClusterWideMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the cluster wide map with the specified name.
    `void` | SharedData.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get a cluster wide counter.
    `void` | SharedData.`getLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get a cluster wide lock with the specified name.
    `void` | SharedData.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData.getLock(String, Handler)` but specifying a timeout.
    `void` | Counter.`incrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the new count
    `void` | AsyncMap.`put(K k, V v, Handler<AsyncResult<Void>> completionHandler)` Put a value in the map, asynchronously.
    `void` | AsyncMap.`put(K k, V v, long ttl, Handler<AsyncResult<Void>> completionHandler)` Like `AsyncMap.put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but specifying a timeout.
    `void` | AsyncMap.`putIfAbsent(K k, V v, Handler<AsyncResult<V>> completionHandler)` Put the entry only if there is no entry with the key already present.
    `void` | AsyncMap.`putIfAbsent(K k, V v, long ttl, Handler<AsyncResult<V>> completionHandler)` Link `AsyncMap.putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>)` but specifying a timeout.
    `void` | AsyncMap.`remove(K k, Handler<AsyncResult<V>> resultHandler)` Remove a value from the map, asynchronously.
    `void` | AsyncMap.`removeIfPresent(K k, V v, Handler<AsyncResult<Boolean>> resultHandler)` Remove a value from the map, only if entry already exists with same value.
    `void` | AsyncMap.`replace(K k, V v, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `void` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `void` | AsyncMap.`size(Handler<AsyncResult<Integer>> resultHandler)` Provide the number of entries in the map

  - ### Uses of Handler in io.vertx.core.spi

    Methods in io.vertx.core.spi with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | VertxFactory.`clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)`

  - ### Uses of Handler in io.vertx.core.spi.cluster

    Methods in io.vertx.core.spi.cluster with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AsyncMultiMap.`add(K k, V v, Handler<AsyncResult<Void>> completionHandler)` Add a value to the list of values for that key in the map
    `void` | AsyncMultiMap.`get(K k, Handler<AsyncResult<ChoosableIterable<V>>> resultHandler)` Get a list of values from the map for the key
    `<K,V> void` | ClusterManager.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Return an async map for the given name
    `<K,V> void` | ClusterManager.`getAsyncMultiMap(String name, Handler<AsyncResult<AsyncMultiMap<K,V>>> resultHandler)` Return an async multi-map for the given name
    `void` | ClusterManager.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)`
    `void` | ClusterManager.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)`
    `void` | ClusterManager.`join(Handler<AsyncResult<Void>> resultHandler)` Join the cluster
    `void` | ClusterManager.`leave(Handler<AsyncResult<Void>> resultHandler)` Leave the cluster
    `void` | AsyncMultiMap.`remove(K k, V v, Handler<AsyncResult<Boolean>> completionHandler)` Remove a value from the list of values for that key in the map.
    `void` | AsyncMultiMap.`removeAllForValue(V v, Handler<AsyncResult<Void>> completionHandler)` Remove all the specified values from all keys in the map

  - ### Uses of Handler in io.vertx.core.streams

    Methods in io.vertx.core.streams with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `ReadStream<T>` | ReadStream.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `ReadStream<T>` | ReadStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `StreamBase` | StreamBase.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `WriteStream<T>` | WriteStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `ReadStream<T>` | ReadStream.`handler(Handler<T> handler)` Set a data handler.

  - ### Uses of Handler in io.vertx.ext.auth

    Methods in io.vertx.ext.auth with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AuthProvider.`authenticate(JsonObject authInfo, Handler<AsyncResult<User>> resultHandler)` Authenticate a user.
    `protected abstract void` | AbstractUser.`doIsPermitted(String permission, Handler<AsyncResult<Boolean>> resultHandler)`
    `User` | AbstractUser.`isAuthorised(String authority, Handler<AsyncResult<Boolean>> resultHandler)`
    `User` | User.`isAuthorised(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Is the user authorised to

  - ### Uses of Handler in io.vertx.ext.auth.mongo

    Methods in io.vertx.ext.auth.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MongoAuth.`insertUser(String username, String password, List<String> roles, List<String> permissions, Handler<AsyncResult<String>> resultHandler)` Insert a new user into mongo in the convenient way

  - ### Uses of Handler in io.vertx.ext.jdbc

    Methods in io.vertx.ext.jdbc with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `JDBCClient` | JDBCClient.`getConnection(Handler<AsyncResult<io.vertx.ext.sql.SQLConnection>> handler)` Returns a connection that can be used to perform SQL operations on.

  - ### Uses of Handler in io.vertx.ext.mail

    Classes in io.vertx.ext.mail that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MailServiceVertxProxyHandler`

    Methods in io.vertx.ext.mail with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MailClient` | MailClient.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)` send a single mail via MailClient
    `MailService` | MailService.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)`
    `MailService` | MailServiceVertxEBProxy.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)`

  - ### Uses of Handler in io.vertx.ext.mongo

    Methods in io.vertx.ext.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MongoClient` | MongoClient.`count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoClient` | MongoClient.`createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)` Create a new collection
    `MongoClient` | MongoClient.`dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)` Drop a collection
    `MongoClient` | MongoClient.`find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection
    `MongoClient` | MongoClient.`findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection
    `MongoClient` | MongoClient.`findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection, specifying options
    `MongoClient` | MongoClient.`getCollections(Handler<AsyncResult<List<String>>> resultHandler)` Get a list of all collections in the database.
    `MongoClient` | MongoClient.`insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection
    `MongoClient` | MongoClient.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection with the specified write option
    `MongoClient` | MongoClient.`remove(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Remove matching documents from a collection
    `MongoClient` | MongoClient.`removeOne(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Remove a single matching document from a collection
    `MongoClient` | MongoClient.`removeOneWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Remove a single matching document from a collection with the specified write option
    `MongoClient` | MongoClient.`removeWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Remove matching documents from a collection with the specified write option
    `MongoClient` | MongoClient.`replace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<Void>> resultHandler)` Replace matching documents in the specified collection
    `MongoClient` | MongoClient.`replaceWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Replace matching documents in the specified collection, specifying options
    `MongoClient` | MongoClient.`runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)` Run an arbitrary MongoDB command.
    `MongoClient` | MongoClient.`save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection
    `MongoClient` | MongoClient.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection with the specified write option
    `MongoClient` | MongoClient.`update(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<Void>> resultHandler)` Update matching documents in the specified collection
    `MongoClient` | MongoClient.`updateWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Update matching documents in the specified collection, specifying options

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

    Methods in io.vertx.ext.shell with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ShellService.`start(Handler<AsyncResult<Void>> startHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellService.`stop(Handler<AsyncResult<Void>> stopHandler)` Stop the shell service, this is an asynchronous start.

  - ### Uses of Handler in io.vertx.ext.shell.command

    Methods in io.vertx.ext.shell.command with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CommandBuilder` | CommandBuilder.`completionHandler(Handler<Completion> handler)` Set the command completion handler, the completion handler when the user asks for contextual command line completion, usually hitting the tab key.
    `CommandProcess` | CommandProcess.`eventHandler(EventType eventType, Handler<Void> handler)`
    `CommandBuilder` | CommandBuilder.`processHandler(Handler<CommandProcess> handler)` Set the command process handler, the process handler is called when the command is executed.

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

    Methods in io.vertx.ext.shell.io with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Tty` | Tty.`eventHandler(EventType eventType, Handler<Void> handler)` Set an event handler to be notified by Shell events.
    `static Stream` | Stream.`ofJson(Handler<JsonObject> handler)`
    `static Stream` | Stream.`ofObject(Handler<Object> handler)`
    `static Stream` | Stream.`ofString(Handler<String> handler)`
    `Tty` | Tty.`setStdin(Handler<String> stdin)` Set an handler the standard input to read the data in String format.

  - ### Uses of Handler in io.vertx.ext.shell.registry

    Methods in io.vertx.ext.shell.registry with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | CommandRegistry.`createProcess(List<CliToken> line, Handler<AsyncResult<Process>> handler)` Try to create a process from the command line tokens.
    `void` | CommandRegistry.`createProcess(String line, Handler<AsyncResult<Process>> handler)` Parses a command line and try to create a process.
    `void` | CommandRegistry.`registerCommand(Class<? extends Command> command, Handler<AsyncResult<CommandRegistration>> doneHandler)`
    `void` | CommandRegistry.`registerCommand(Command command, Handler<AsyncResult<CommandRegistration>> doneHandler)`
    `void` | CommandRegistry.`unregisterCommand(String commandName, Handler<AsyncResult<Void>> doneHandler)`

  - ### Uses of Handler in io.vertx.ext.stomp

    Subinterfaces of Handler in io.vertx.ext.stomp
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `StompServerHandler` STOMP server handler implements the behavior of the STOMP server when a specific event occurs.

    Classes in io.vertx.ext.stomp that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DefaultAbortHandler` STOMP compliant actions executed when receiving a `ABORT` frame.
    `class` | `DefaultAckHandler` STOMP compliant actions executed when receiving a `ACK` frame.
    `class` | `DefaultBeginHandler` STOMP compliant actions executed when receiving a `BEGIN` frame.
    `class` | `DefaultCommitHandler` STOMP compliant actions executed when receiving a `COMMIT` frame.
    `class` | `DefaultConnectHandler` STOMP compliant actions executed when receiving a `CONNECT` frame.
    `class` | `DefaultNackHandler` STOMP compliant actions executed when receiving a `NACK` sf.frame().
    `class` | `DefaultSendHandler` STOMP compliant actions executed when receiving a `SEND` sf.frame().
    `class` | `DefaultSubscribeHandler` STOMP compliant actions executed when receiving a `SUBSCRIBE` frame.
    `class` | `DefaultUnsubscribeHandler` STOMP compliant actions executed when receiving a `UNSUBSCRIBE` frame.

    Methods in io.vertx.ext.stomp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `StompClientConnection` | StompClientConnection.`abort(String id, Handler<Frame> receiptHandler)` Aborts a transaction.
    `StompClientConnection` | StompClientConnection.`abort(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Aborts a transaction.
    `StompServerHandler` | StompServerHandler.`abortHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ABORT` frame is received.
    `StompClientConnection` | StompClientConnection.`ack(String id, Handler<Frame> receiptHandler)` Sends an acknowledgement for a specific message.
    `StompClientConnection` | StompClientConnection.`ack(String id, String txId, Handler<Frame> receiptHandler)` Sends an acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`ackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ACK` frame is received.
    `StompServerHandler` | StompServerHandler.`beginHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `BEGIN` frame is received.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Handler<Frame> receiptHandler)` Begins a transaction.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Begins a transaction.
    `void` | StompServer.`close(Handler<AsyncResult<Void>> completionHandler)` Closes the server.
    `StompClientConnection` | StompClientConnection.`closeHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the STOMP connection is closed.
    `StompServerHandler` | StompServerHandler.`closeHandler(Handler<StompServerConnection> handler)` Configures the action to execute when a connection with the client is closed.
    `StompClientConnection` | StompClientConnection.`commit(String id, Handler<Frame> receiptHandler)` Commits a transaction.
    `StompClientConnection` | StompClientConnection.`commit(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Commits a transaction.
    `StompServerHandler` | StompServerHandler.`commitHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `COMMIT` frame is received.
    `void` | StompServerConnection.`configureHeartbeat(long ping, long pong, Handler<StompServerConnection> pingHandler)` Configures the heartbeat.
    `StompClient` | StompClient.`connect(Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server using the host and port configured in the client's options.
    `StompClient` | StompClient.`connect(int port, String host, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(int port, String host, NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompServerHandler` | StompServerHandler.`connectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `CONNECT` frame is received.
    `StompClientConnection` | StompClientConnection.`disconnect(Frame frame, Handler<Frame> receiptHandler)` Disconnects the client.
    `StompClientConnection` | StompClientConnection.`disconnect(Handler<Frame> receiptHandler)` Disconnects the client.
    `StompServerHandler` | StompServerHandler.`disconnectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `DISCONNECT` frame is received.
    `StompClientConnection` | StompClientConnection.`errorHandler(Handler<Frame> handler)` Sets a handler notified when an `ERROR` frame is received by the client.
    `StompServer` | StompServer.`listen(Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server default port (61613) and network interface (`0.0.0.0`).
    `StompServer` | StompServer.`listen(int port, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port.
    `StompServer` | StompServer.`listen(int port, String host, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port / interface.
    `StompClientConnection` | StompClientConnection.`nack(String id, Handler<Frame> receiptHandler)` Sends a non-acknowledgement for the given message.
    `StompClientConnection` | StompClientConnection.`nack(String id, String txId, Handler<Frame> receiptHandler)` Sends a non-acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`nackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `NACK` frame is received.
    `StompServerHandler` | StompServerHandler.`onAckHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are acknowledged.
    `StompServerHandler` | StompServerHandler.`onAuthenticationRequest(StompServer server, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `StompServerHandler` | StompServerHandler.`onNackHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are not acknowledged.
    `StompClientConnection` | StompClientConnection.`pingHandler(Handler<StompClientConnection> handler)` Sets a handler that let customize the behavior when a ping needs to be sent to the server.
    `StompServerHandler` | StompServerHandler.`pingHandler(Handler<StompServerConnection> handler)` Allows customizing the action to do when the server needs to send a `PING` to the client.
    `StompClientConnection` | StompClientConnection.`send(Frame frame, Handler<Frame> receiptHandler)` Sends the given frame to the server.
    `StompClientConnection` | StompClientConnection.`send(Map<String,String> headers, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server.
    `StompClientConnection` | StompClientConnection.`send(String destination, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(String destination, Map<String,String> headers, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompServerHandler` | StompServerHandler.`sendHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SEND` frame is received.
    `StompServerHandler` | StompServerHandler.`stompHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `STOMP` frame is received.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Handler<Frame> receiptHandler)` Un-subscribes from the given destination.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Map<String,String> headers, Handler<Frame> receiptHandler)` Un-subscribes from the given destination.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `UNSUBSCRIBE` frame is received.

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

    Subinterfaces of Handler in io.vertx.ext.sync
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HandlerReceiverAdaptor<T>` Represents an object that is both a handler of a particular event and also a receiver of that event.

    Methods in io.vertx.ext.sync that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Handler<T>` | Sync.`fiberHandler(Handler<T> handler)` Convert a standard handler to a handler which runs on a fiber.

    Methods in io.vertx.ext.sync with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Handler<T>` | Sync.`fiberHandler(Handler<T> handler)` Convert a standard handler to a handler which runs on a fiber.

    Method parameters in io.vertx.ext.sync with type arguments of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <T> T` | Sync.`awaitEvent(java.util.function.Consumer<Handler<T>> consumer)` Receive a single event from a handler synchronously.
    `static <T> T` | Sync.`awaitResult(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer)` Invoke an asynchronous operation and obtain the result synchronous.

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

    Methods in io.vertx.ext.unit that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess()` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it completes the async operation. When the returned handler is called back with a failed result it fails the test with the cause of the failure.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.

    Methods in io.vertx.ext.unit with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestSuite` | TestSuite.`after(Handler<TestContext> callback)` Set a callback executed after the tests.
    `TestSuite` | TestSuite.`afterEach(Handler<TestContext> callback)` Set a callback executed after each test and before the suite `after` callback.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertFailure(Handler<Throwable> causeHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a failed result it completes the async operation. When the returned handler is called back with a succeeded result it fails the test.
    `<T> Handler<AsyncResult<T>>` | TestContext.`asyncAssertSuccess(Handler<T> resultHandler)` Creates and returns a new async handler, the returned handler controls the completion of the test. When the returned handler is called back with a succeeded result it invokes the `resultHandler` argument with the async result.
    `TestSuite` | TestSuite.`before(Handler<TestContext> callback)` Set a callback executed before the tests.
    `TestSuite` | TestSuite.`beforeEach(Handler<TestContext> callback)` Set a callback executed before each test and after the suite `before` callback.
    `static TestCase` | TestCase.`create(String name, Handler<TestContext> testCase)` Create a test case.
    `void` | Completion.`handler(Handler<AsyncResult<T>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `TestSuite` | TestSuite.`test(String name, Handler<TestContext> testCase)` Add a new test case to the suite.

  - ### Uses of Handler in io.vertx.ext.unit.collect

    Methods in io.vertx.ext.unit.collect that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `Handler<Message<JsonObject>>` | EventBusCollector.`asMessageHandler()`

    Methods in io.vertx.ext.unit.collect with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static EventBusCollector` | EventBusCollector.`create(Vertx vertx, Handler<TestSuiteReport> reporter)`

  - ### Uses of Handler in io.vertx.ext.unit.report

    Methods in io.vertx.ext.unit.report with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestCaseReport` | TestCaseReport.`endHandler(Handler<TestResult> handler)` Set a callback for completion, the specified `handler` is invoked when the test exec has completed.
    `TestSuiteReport` | TestSuiteReport.`endHandler(Handler<Void> endHandler)`
    `TestSuiteReport` | TestSuiteReport.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler, the exception handler reports the test suite errors, it can be called mulitple times before the test ends.
    `TestSuiteReport` | TestSuiteReport.`handler(Handler<TestCaseReport> handler)`

  - ### Uses of Handler in io.vertx.ext.web

    Methods in io.vertx.ext.web with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addBodyEndHandler(Handler<Void> handler)` Add a handler that will be called just before the response body has been completely written.
    `int` | RoutingContext.`addHeadersEndHandler(Handler<Void> handler)` Add a handler that will be called just before headers are written to the response.
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler)` Like `Route.blockingHandler(Handler, boolean)` called with ordered = true
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler, boolean ordered)` Specify a blocking request handler for the route.
    `Router` | Router.`exceptionHandler(Handler<Throwable> exceptionHandler)` Specify a handler for any unhandled exceptions on this router.
    `Route` | Route.`failureHandler(Handler<RoutingContext> failureHandler)` Specify a failure handler for the route.
    `Route` | Route.`handler(Handler<RoutingContext> requestHandler)` Specify a request handler for the route.

  - ### Uses of Handler in io.vertx.ext.web.handler

    Subinterfaces of Handler in io.vertx.ext.web.handler
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `AuthHandler` Base interface for auth handlers.
    `interface` | `BasicAuthHandler` An auth handler that provides HTTP Basic Authentication support.
    `interface` | `BodyHandler` A handler which gathers the entire request body and sets it on the `RoutingContext`.
    `interface` | `CookieHandler` A handler which decodes cookies from the request, makes them available in the `RoutingContext` and writes them back in the response.
    `interface` | `CorsHandler` A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
    `interface` | `CSRFHandler` This handler adds a CSRF token to requests which mutate state.
    `interface` | `ErrorHandler` A pretty error handler for rendering error pages.
    `interface` | `FaviconHandler` A handler that serves favicons.
    `interface` | `FormLoginHandler` Handler that handles login from a form on a custom login page.
    `interface` | `JWTAuthHandler` An auth handler that provides JWT Authentication support.
    `interface` | `LoggerHandler` A handler which logs request information to the Vert.x logger.
    `interface` | `RedirectAuthHandler` An auth handler that's used to handle auth by redirecting user to a custom login page.
    `interface` | `ResponseTimeHandler` Handler which adds a header `x-response-time` in the response of matching requests containing the time taken in ms to process the request.
    `interface` | `SessionHandler` A handler that maintains a `Session` for each browser session.
    `interface` | `StaticHandler` A handler for serving static resources from the file system or classpath.
    `interface` | `TemplateHandler` A handler which renders responses using a template engine and where the template name is selected from the URI path.
    `interface` | `TimeoutHandler` Handler that will timeout requests if the response has not been written after a certain time.
    `interface` | `UserSessionHandler` This handler should be used if you want to store the User object in the Session so it's available between different requests, without you having re-authenticate each time.
    `interface` | `VirtualHostHandler` Handler that will filter requests based on the request Host name.

    Methods in io.vertx.ext.web.handler with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static VirtualHostHandler` | VirtualHostHandler.`create(String hostname, Handler<RoutingContext> handler)` Create a handler

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

    Subinterfaces of Handler in io.vertx.ext.web.handler.sockjs
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `SockJSHandler` A handler that allows you to handle SockJS connections from clients.

    Methods in io.vertx.ext.web.handler.sockjs with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SockJSHandler` | SockJSHandler.`bridge(BridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` Like `SockJSHandler.bridge(BridgeOptions)` but specifying a handler that will receive bridge events.
    `SockJSSocket` | SockJSSocket.`drainHandler(Handler<Void> handler)`
    `SockJSSocket` | SockJSSocket.`endHandler(Handler<Void> endHandler)`
    `SockJSSocket` | SockJSSocket.`exceptionHandler(Handler<Throwable> handler)`
    `SockJSSocket` | SockJSSocket.`handler(Handler<Buffer> handler)`
    `SockJSHandler` | SockJSHandler.`socketHandler(Handler<SockJSSocket> handler)` Set a SockJS socket handler.

  - ### Uses of Handler in io.vertx.ext.web.sstore

    Methods in io.vertx.ext.web.sstore with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SessionStore.`clear(Handler<AsyncResult<Boolean>> resultHandler)` Remove all sessions from the store
    `void` | SessionStore.`delete(String id, Handler<AsyncResult<Boolean>> resultHandler)` Delete the session with the specified ID
    `void` | SessionStore.`get(String id, Handler<AsyncResult<Session>> resultHandler)` Get the session with the specified ID
    `void` | SessionStore.`put(Session session, Handler<AsyncResult<Boolean>> resultHandler)` Add a session with the specified ID
    `void` | SessionStore.`size(Handler<AsyncResult<Integer>> resultHandler)` Get the number of sessions in the store

  - ### Uses of Handler in io.vertx.ext.web.templ

    Methods in io.vertx.ext.web.templ with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render

  - ### Uses of Handler in io.vertx.lang.rxjava

    Classes in io.vertx.lang.rxjava that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ReadStreamAdapter<J,R>`

    Methods in io.vertx.lang.rxjava that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <V> Handler<AsyncResult<V>>` | InternalHelper.`asyncResultHandler(CompletableFuture<V> f)`

  - ### Uses of Handler in io.vertx.redis

    Methods in io.vertx.redis with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisClient` | RedisClient.`append(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a key
    `RedisClient` | RedisClient.`auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `RedisClient` | RedisClient.`bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `RedisClient` | RedisClient.`bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `RedisClient` | RedisClient.`bitcount(String key, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisClient` | RedisClient.`bitcountRange(String key, long start, long end, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisClient` | RedisClient.`bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Perform bitwise operations between strings
    `RedisClient` | RedisClient.`bitpos(String key, int bit, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string
    `RedisClient` | RedisClient.`bitposFrom(String key, int bit, int start, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
    `RedisClient` | RedisClient.`bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
    `RedisClient` | RedisClient.`blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisClient` | RedisClient.`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisClient` | RedisClient.`brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler)` Pop a value from a list, push it to another list and return it; or block until one is available
    `RedisClient` | RedisClient.`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `RedisClient` | RedisClient.`clientKill(KillFilter filter, Handler<AsyncResult<Long>> handler)` Kill the connection of a client
    `RedisClient` | RedisClient.`clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `RedisClient` | RedisClient.`clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `RedisClient` | RedisClient.`clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
    `void` | RedisClient.`close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `RedisClient` | RedisClient.`clusterAddslots(List<Long> slots, Handler<AsyncResult<Void>> handler)` Assign new hash slots to receiving node.
    `RedisClient` | RedisClient.`clusterCountFailureReports(String nodeId, Handler<AsyncResult<Long>> handler)` Return the number of failure reports active for a given node.
    `RedisClient` | RedisClient.`clusterCountkeysinslot(long slot, Handler<AsyncResult<Long>> handler)` Return the number of local keys in the specified hash slot.
    `RedisClient` | RedisClient.`clusterDelslots(long slot, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `RedisClient` | RedisClient.`clusterDelslotsMany(List<Long> slots, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `RedisClient` | RedisClient.`clusterFailover(Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisClient` | RedisClient.`clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisClient` | RedisClient.`clusterForget(String nodeId, Handler<AsyncResult<Void>> handler)` Remove a node from the nodes table.
    `RedisClient` | RedisClient.`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Return local key names in the specified hash slot.
    `RedisClient` | RedisClient.`clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Provides info about Redis Cluster node state.
    `RedisClient` | RedisClient.`clusterKeyslot(String key, Handler<AsyncResult<Long>> handler)` Returns the hash slot of the specified key.
    `RedisClient` | RedisClient.`clusterMeet(String ip, long port, Handler<AsyncResult<Void>> handler)` Force a node cluster to handshake with another node.
    `RedisClient` | RedisClient.`clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Get Cluster config for the node.
    `RedisClient` | RedisClient.`clusterReplicate(String nodeId, Handler<AsyncResult<Void>> handler)` Reconfigure a node as a slave of the specified master node.
    `RedisClient` | RedisClient.`clusterReset(Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `RedisClient` | RedisClient.`clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `RedisClient` | RedisClient.`clusterSaveconfig(Handler<AsyncResult<Void>> handler)` Forces the node to save cluster state on disk.
    `RedisClient` | RedisClient.`clusterSetConfigEpoch(long epoch, Handler<AsyncResult<Void>> handler)` Set the configuration epoch in a new node.
    `RedisClient` | RedisClient.`clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` List slave nodes of the specified master node.
    `RedisClient` | RedisClient.`clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
    `RedisClient` | RedisClient.`command(Handler<AsyncResult<JsonArray>> handler)` Get array of Redis command details
    `RedisClient` | RedisClient.`commandCount(Handler<AsyncResult<Long>> handler)` Get total number of Redis commands
    `RedisClient` | RedisClient.`commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
    `RedisClient` | RedisClient.`commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
    `RedisClient` | RedisClient.`configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
    `RedisClient` | RedisClient.`configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `RedisClient` | RedisClient.`configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `RedisClient` | RedisClient.`configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
    `RedisClient` | RedisClient.`dbsize(Handler<AsyncResult<Long>> handler)` Return the number of keys in the selected database
    `RedisClient` | RedisClient.`debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `RedisClient` | RedisClient.`debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `RedisClient` | RedisClient.`decr(String key, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by one
    `RedisClient` | RedisClient.`decrby(String key, long decrement, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by the given number
    `RedisClient` | RedisClient.`del(String key, Handler<AsyncResult<Long>> handler)` Delete a key
    `RedisClient` | RedisClient.`delMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete many keys
    `RedisClient` | RedisClient.`discard(Handler<AsyncResult<String>> handler)` Discard all commands issued after MULTI
    `RedisClient` | RedisClient.`dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisClient` | RedisClient.`echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `RedisClient` | RedisClient.`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`exec(Handler<AsyncResult<JsonArray>> handler)` Execute all commands issued after MULTI
    `RedisClient` | RedisClient.`exists(String key, Handler<AsyncResult<Long>> handler)` Determine if a key exists
    `RedisClient` | RedisClient.`expire(String key, int seconds, Handler<AsyncResult<Long>> handler)` Set a key's time to live in seconds
    `RedisClient` | RedisClient.`expireat(String key, long seconds, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp
    `RedisClient` | RedisClient.`flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `RedisClient` | RedisClient.`flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `RedisClient` | RedisClient.`get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisClient` | RedisClient.`getBinary(String key, Handler<AsyncResult<String>> handler)` Get the value of a key - without decoding as utf-8
    `RedisClient` | RedisClient.`getbit(String key, long offset, Handler<AsyncResult<Long>> handler)` Returns the bit value at offset in the string value stored at key
    `RedisClient` | RedisClient.`getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `RedisClient` | RedisClient.`getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
    `RedisClient` | RedisClient.`hdel(String key, String field, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `RedisClient` | RedisClient.`hdelMany(String key, List<String> fields, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `RedisClient` | RedisClient.`hexists(String key, String field, Handler<AsyncResult<Long>> handler)` Determine if a hash field exists
    `RedisClient` | RedisClient.`hget(String key, String field, Handler<AsyncResult<String>> handler)` Get the value of a hash field
    `RedisClient` | RedisClient.`hgetall(String key, Handler<AsyncResult<JsonObject>> handler)` Get all the fields and values in a hash
    `RedisClient` | RedisClient.`hincrby(String key, String field, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a hash field by the given number
    `RedisClient` | RedisClient.`hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a hash field by the given amount
    `RedisClient` | RedisClient.`hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
    `RedisClient` | RedisClient.`hlen(String key, Handler<AsyncResult<Long>> handler)` Get the number of fields in a hash
    `RedisClient` | RedisClient.`hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given hash fields
    `RedisClient` | RedisClient.`hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `RedisClient` | RedisClient.`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate hash fields and associated values
    `RedisClient` | RedisClient.`hset(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the string value of a hash field
    `RedisClient` | RedisClient.`hsetnx(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the value of a hash field, only if the field does not exist
    `RedisClient` | RedisClient.`hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
    `RedisClient` | RedisClient.`incr(String key, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by one
    `RedisClient` | RedisClient.`incrby(String key, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by the given amount
    `RedisClient` | RedisClient.`incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a key by the given amount
    `RedisClient` | RedisClient.`info(Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisClient` | RedisClient.`infoSection(String section, Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisClient` | RedisClient.`keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
    `RedisClient` | RedisClient.`lastsave(Handler<AsyncResult<Long>> handler)` Get the UNIX time stamp of the last successful save to disk
    `RedisClient` | RedisClient.`lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
    `RedisClient` | RedisClient.`linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<Long>> handler)` Insert an element before or after another element in a list
    `RedisClient` | RedisClient.`llen(String key, Handler<AsyncResult<Long>> handler)` Get the length of a list
    `RedisClient` | RedisClient.`lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `RedisClient` | RedisClient.`lpush(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend one value to a list
    `RedisClient` | RedisClient.`lpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Prepend one or multiple values to a list
    `RedisClient` | RedisClient.`lpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend a value to a list, only if the list exists
    `RedisClient` | RedisClient.`lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Get a range of elements from a list
    `RedisClient` | RedisClient.`lrem(String key, long count, String value, Handler<AsyncResult<Long>> handler)` Remove elements from a list
    `RedisClient` | RedisClient.`lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
    `RedisClient` | RedisClient.`ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
    `RedisClient` | RedisClient.`mget(String key, Handler<AsyncResult<JsonArray>> handler)` Get the value of the given key
    `RedisClient` | RedisClient.`mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given keys
    `RedisClient` | RedisClient.`migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler)` Atomically transfer a key from a Redis instance to another one.
    `RedisClient` | RedisClient.`monitor(Handler<AsyncResult<Void>> handler)` Listen for all requests received by the server in real time
    `RedisClient` | RedisClient.`move(String key, int destdb, Handler<AsyncResult<Long>> handler)` Move a key to another database
    `RedisClient` | RedisClient.`mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisClient` | RedisClient.`msetnx(JsonObject keyvals, Handler<AsyncResult<Long>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `RedisClient` | RedisClient.`multi(Handler<AsyncResult<String>> handler)` Mark the start of a transaction block
    `RedisClient` | RedisClient.`object(String key, ObjectCmd cmd, Handler<AsyncResult<Void>> handler)` Inspect the internals of Redis objects
    `RedisClient` | RedisClient.`persist(String key, Handler<AsyncResult<Long>> handler)` Remove the expiration from a key
    `RedisClient` | RedisClient.`pexpire(String key, long millis, Handler<AsyncResult<Long>> handler)` Set a key's time to live in milliseconds
    `RedisClient` | RedisClient.`pexpireat(String key, long millis, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `RedisClient` | RedisClient.`pfadd(String key, String element, Handler<AsyncResult<Long>> handler)` Adds the specified element to the specified HyperLogLog.
    `RedisClient` | RedisClient.`pfaddMany(String key, List<String> elements, Handler<AsyncResult<Long>> handler)` Adds the specified elements to the specified HyperLogLog.
    `RedisClient` | RedisClient.`pfcount(String key, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisClient` | RedisClient.`pfcountMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisClient` | RedisClient.`pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisClient` | RedisClient.`ping(Handler<AsyncResult<String>> handler)` Ping the server
    `RedisClient` | RedisClient.`psetex(String key, long millis, String value, Handler<AsyncResult<Void>> handler)` Set the value and expiration in milliseconds of a key
    `RedisClient` | RedisClient.`psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given pattern
    `RedisClient` | RedisClient.`psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given patterns
    `RedisClient` | RedisClient.`pttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key in milliseconds
    `RedisClient` | RedisClient.`publish(String channel, String message, Handler<AsyncResult<Long>> handler)` Post a message to a channel
    `RedisClient` | RedisClient.`pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisClient` | RedisClient.`pubsubNumpat(Handler<AsyncResult<Long>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisClient` | RedisClient.`pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisClient` | RedisClient.`punsubscribe(List<String> patterns, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to channels matching the given patterns
    `RedisClient` | RedisClient.`randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `RedisClient` | RedisClient.`rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key
    `RedisClient` | RedisClient.`renamenx(String key, String newkey, Handler<AsyncResult<Long>> handler)` Rename a key, only if the new key does not exist
    `RedisClient` | RedisClient.`restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisClient` | RedisClient.`role(Handler<AsyncResult<JsonArray>> handler)` Return the role of the instance in the context of replication
    `RedisClient` | RedisClient.`rpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list
    `RedisClient` | RedisClient.`rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Remove the last element in a list, append it to another list and return it
    `RedisClient` | RedisClient.`rpush(String key, String value, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `RedisClient` | RedisClient.`rpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `RedisClient` | RedisClient.`rpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a list, only if the list exists
    `RedisClient` | RedisClient.`sadd(String key, String member, Handler<AsyncResult<Long>> handler)` Add a member to a set
    `RedisClient` | RedisClient.`saddMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a set
    `RedisClient` | RedisClient.`save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `RedisClient` | RedisClient.`scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate the keys space
    `RedisClient` | RedisClient.`scard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a set
    `RedisClient` | RedisClient.`scriptExists(String script, Handler<AsyncResult<JsonArray>> handler)` Check existence of script in the script cache.
    `RedisClient` | RedisClient.`scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler)` Check existence of scripts in the script cache.
    `RedisClient` | RedisClient.`scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `RedisClient` | RedisClient.`scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `RedisClient` | RedisClient.`scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `RedisClient` | RedisClient.`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
    `RedisClient` | RedisClient.`sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<Long>> handler)` Subtract multiple sets and store the resulting set in a key
    `RedisClient` | RedisClient.`select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
    `RedisClient` | RedisClient.`set(String key, String value, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`setBinary(String key, String value, Handler<AsyncResult<Void>> handler)` Set the binary string value of a key - without encoding as utf-8
    `RedisClient` | RedisClient.`setbit(String key, long offset, int bit, Handler<AsyncResult<Long>> handler)` Sets or clears the bit at offset in the string value stored at key
    `RedisClient` | RedisClient.`setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
    `RedisClient` | RedisClient.`setnx(String key, String value, Handler<AsyncResult<Long>> handler)` Set the value of a key, only if the key does not exist
    `RedisClient` | RedisClient.`setrange(String key, int offset, String value, Handler<AsyncResult<Long>> handler)` Overwrite part of a string at key starting at the specified offset
    `RedisClient` | RedisClient.`setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
    `RedisClient` | RedisClient.`sinterstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Intersect multiple sets and store the resulting set in a key
    `RedisClient` | RedisClient.`sismember(String key, String member, Handler<AsyncResult<Long>> handler)` Determine if a given value is a member of a set
    `RedisClient` | RedisClient.`slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Make the server a slave of another instance
    `RedisClient` | RedisClient.`slaveofNoone(Handler<AsyncResult<String>> handler)` Make this server a master
    `RedisClient` | RedisClient.`slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
    `RedisClient` | RedisClient.`slowlogLen(Handler<AsyncResult<Long>> handler)` Get the length of the Redis slow queries log
    `RedisClient` | RedisClient.`slowlogReset(Handler<AsyncResult<Void>> handler)` Reset the Redis slow queries log
    `RedisClient` | RedisClient.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`smove(String key, String destkey, String member, Handler<AsyncResult<Long>> handler)` Move a member from one set to another
    `RedisClient` | RedisClient.`sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Sort the elements in a list, set or sorted set
    `RedisClient` | RedisClient.`spop(String key, Handler<AsyncResult<String>> handler)` Remove and return a random member from a set
    `RedisClient` | RedisClient.`spopMany(String key, int count, Handler<AsyncResult<String>> handler)` Remove and return random members from a set
    `RedisClient` | RedisClient.`srandmember(String key, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a set
    `RedisClient` | RedisClient.`sremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a set
    `RedisClient` | RedisClient.`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate Set elements
    `RedisClient` | RedisClient.`strlen(String key, Handler<AsyncResult<Long>> handler)` Get the length of the value stored in a key
    `RedisClient` | RedisClient.`subscribe(String channel, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
    `RedisClient` | RedisClient.`sunionstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Add multiple sets and store the resulting set in a key
    `RedisClient` | RedisClient.`sync(Handler<AsyncResult<Void>> handler)` Internal command used for replication
    `RedisClient` | RedisClient.`time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `RedisClient` | RedisClient.`ttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key
    `RedisClient` | RedisClient.`type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `RedisClient` | RedisClient.`unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to the given channels
    `RedisClient` | RedisClient.`unwatch(Handler<AsyncResult<String>> handler)` Forget about all watched keys
    `RedisClient` | RedisClient.`wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisClient` | RedisClient.`watch(String key, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisClient` | RedisClient.`watchMany(List<String> keys, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisClient` | RedisClient.`zadd(String key, double score, String member, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | RedisClient.`zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | RedisClient.`zcard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a sorted set
    `RedisClient` | RedisClient.`zcount(String key, double min, double max, Handler<AsyncResult<Long>> handler)` Count the members in a sorted set with scores within the given values
    `RedisClient` | RedisClient.`zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
    `RedisClient` | RedisClient.`zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | RedisClient.`zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `RedisClient` | RedisClient.`zlexcount(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Count the number of members in a sorted set between a given lexicographical range
    `RedisClient` | RedisClient.`zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by lexicographical range
    `RedisClient` | RedisClient.`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score
    `RedisClient` | RedisClient.`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set
    `RedisClient` | RedisClient.`zrem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a sorted set
    `RedisClient` | RedisClient.`zremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a sorted set
    `RedisClient` | RedisClient.`zremrangebylex(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set between the given lexicographical range
    `RedisClient` | RedisClient.`zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given indexes
    `RedisClient` | RedisClient.`zremrangebyscore(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given scores
    `RedisClient` | RedisClient.`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `RedisClient` | RedisClient.`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate sorted sets elements and associated scores
    `RedisClient` | RedisClient.`zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
    `RedisClient` | RedisClient.`zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | RedisClient.`zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key

  - ### Uses of Handler in io.vertx.rx.java

    Methods in io.vertx.rx.java that return Handler
    Modifier and Type | Method and Description
    --- | ---
    `static <T> Handler<AsyncResult<T>>` | RxHelper.`toFuture(rx.functions.Action1<T> onNext)` Adapt an item callback as a `Handler<AsyncResult<T>>`.
    `static <T> Handler<AsyncResult<T>>` | RxHelper.`toFuture(rx.functions.Action1<T> onNext, rx.functions.Action1<Throwable> onError)` Adapt an item callback and an error callback as a `Handler<AsyncResult<T>>`.
    `static <T> Handler<AsyncResult<T>>` | RxHelper.`toFuture(rx.functions.Action1<T> onNext, rx.functions.Action1<Throwable> onError, rx.functions.Action0 onComplete)` Adapt an item callback and an error callback as a `Handler<AsyncResult<T>>`.
    `static <T> Handler<AsyncResult<T>>` | RxHelper.`toFuture(rx.Observer<T> observer)` Adapt a `Subscriber` as a `Handler<AsyncResult<T>>;`.
    `Handler<AsyncResult<T>>` | ObservableFuture.`toHandler()`
    `Handler<T>` | ObservableHandler.`toHandler()`
    `static <T> Handler<T>` | RxHelper.`toHandler(rx.functions.Action1<T> onNext)` Adapt an item callback as a `Handler<T>`.
    `static <T> Handler<T>` | RxHelper.`toHandler(rx.Observer<T> observer)` Adapt a `Subscriber` as a `Handler<T>;`. When the event handler completes, the observer will complete immediatly after the event is received, as a single event is expected.
    `static <T> Handler<T>` | RxHelper.`toHandler(rx.Observer<T> observer, boolean multi)` Adapt a `Subscriber` as a `Handler<T>;`. When parameter is false and the event handler completes, the observer will complete immediatly after the event is received, as a single event is expected.

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

    Methods in io.vertx.rxjava.core with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Vertx.`close(Handler<AsyncResult<Void>> completionHandler)` Like `Vertx` but the completionHandler will be called when the close is complete
    `static void` | Vertx.`clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)` Creates a clustered instance using the specified options.
    `void` | Vertx.`deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx` but `DeploymentOptions` are provided to configure the deployment.
    `void` | Vertx.`deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)` Like `Vertx` but the completionHandler will be notified when the deployment is complete.
    `TimeoutStream` | TimeoutStream.`endHandler(Handler<Void> endHandler)`
    `TimeoutStream` | TimeoutStream.`exceptionHandler(Handler<Throwable> handler)`
    `<T> void` | Context.`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Vertx.`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | Context.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context` with order = true.
    `<T> void` | Context.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context` with order = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx` called with ordered = true.
    `<T> void` | Vertx.`executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx` called with ordered = true.
    `<T> rx.Observable<T>` | Context.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)` Invoke `Context` with order = true.
    `<T> rx.Observable<T>` | Vertx.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)` Like `Vertx` called with ordered = true.
    `<T> rx.Observable<T>` | Context.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `<T> rx.Observable<T>` | Vertx.`executeBlockingObservable(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `TimeoutStream` | TimeoutStream.`handler(Handler<Long> handler)`
    `void` | Context.`runOnContext(Handler<Void> action)` Run the specified action asynchronously on the same context, some time after the current execution has completed.
    `void` | Vertx.`runOnContext(Handler<Void> action)` Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
    `void` | Future.`setHandler(Handler<AsyncResult<T>> handler)` Set a handler for the result.
    `long` | Vertx.`setPeriodic(long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `long` | Vertx.`setTimer(long delay, Handler<Long> handler)` Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `void` | Vertx.`undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)` Like `Vertx` but the completionHandler will be notified when the undeployment is complete.

  - ### Uses of Handler in io.vertx.rxjava.core.datagram

    Methods in io.vertx.rxjava.core.datagram with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address and notifies the once the operation completes.
    `DatagramSocket` | DatagramSocket.`blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address on the given network interface and notifies the once the operation completes.
    `void` | DatagramSocket.`close(Handler<AsyncResult<Void>> handler)` Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `PacketWritestream` | PacketWritestream.`drainHandler(Handler<Void> handler)`
    `DatagramSocket` | DatagramSocket.`endHandler(Handler<Void> endHandler)`
    `DatagramSocket` | DatagramSocket.`exceptionHandler(Handler<Throwable> handler)`
    `PacketWritestream` | PacketWritestream.`exceptionHandler(Handler<Throwable> handler)`
    `DatagramSocket` | DatagramSocket.`handler(Handler<DatagramPacket> handler)`
    `DatagramSocket` | DatagramSocket.`listen(int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Start listening on the given port and host.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it.
    `DatagramSocket` | DatagramSocket.`listenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it on the given network interface.
    `DatagramSocket` | DatagramSocket.`send(Buffer packet, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `Buffer` to the `SocketAddress`.
    `DatagramSocket` | DatagramSocket.`send(String str, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `DatagramSocket` | DatagramSocket.`send(String str, String enc, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using the given encoding.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it.
    `DatagramSocket` | DatagramSocket.`unlistenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it on the given network interface.

  - ### Uses of Handler in io.vertx.rxjava.core.dns

    Methods in io.vertx.rxjava.core.dns with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `DnsClient` | DnsClient.`lookup(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`lookup4(String name, Handler<AsyncResult<String>> handler)` Try to lookup the A (ipv4) record for the given name.
    `DnsClient` | DnsClient.`lookup6(String name, Handler<AsyncResult<String>> handler)` Try to lookup the AAAA (ipv6) record for the given name.
    `DnsClient` | DnsClient.`resolveA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all A (ipv4) records for the given name.
    `DnsClient` | DnsClient.`resolveAAAA(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve all AAAA (ipv6) records for the given name.
    `DnsClient` | DnsClient.`resolveCNAME(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the CNAME record for the given name.
    `DnsClient` | DnsClient.`resolveMX(String name, Handler<AsyncResult<List<MxRecord>>> handler)` Try to resolve the MX records for the given name.
    `DnsClient` | DnsClient.`resolveNS(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the NS records for the given name.
    `DnsClient` | DnsClient.`resolvePTR(String name, Handler<AsyncResult<String>> handler)` Try to resolve the PTR record for the given name.
    `DnsClient` | DnsClient.`resolveSRV(String name, Handler<AsyncResult<List<SrvRecord>>> handler)` Try to resolve the SRV records for the given name.
    `DnsClient` | DnsClient.`resolveTXT(String name, Handler<AsyncResult<List<String>>> handler)` Try to resolve the TXT records for the given name.
    `DnsClient` | DnsClient.`reverseLookup(String ipaddress, Handler<AsyncResult<String>> handler)` Try to do a reverse lookup of an IP address.

  - ### Uses of Handler in io.vertx.rxjava.core.eventbus

    Methods in io.vertx.rxjava.core.eventbus with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | EventBus.`close(Handler<AsyncResult<Void>> completionHandler)` Close the event bus and release any resources held
    `void` | MessageConsumer.`completionHandler(Handler<AsyncResult<Void>> completionHandler)` Optional method which can be called to indicate when the registration has been propagated across the cluster.
    `<T> MessageConsumer<T>` | EventBus.`consumer(String address, Handler<Message<T>> handler)` Create a consumer and register it against the specified address.
    `MessageProducer<T>` | MessageProducer.`drainHandler(Handler<Void> handler)`
    `MessageConsumer<T>` | MessageConsumer.`endHandler(Handler<Void> endHandler)`
    `MessageConsumer<T>` | MessageConsumer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageProducer<T>` | MessageProducer.`exceptionHandler(Handler<Throwable> handler)`
    `MessageConsumer<T>` | MessageConsumer.`handler(Handler<Message<T>> handler)`
    `<T> MessageConsumer<T>` | EventBus.`localConsumer(String address, Handler<Message<T>> handler)` Like `EventBus.consumer(java.lang.String)` but the address won't be propagated across the cluster.
    `<R> void` | Message.`reply(Object message, DeliveryOptions options, Handler<AsyncResult<Message<R>>> replyHandler)` The same as `reply(R message, DeliveryOptions)` but you can specify handler for the reply - i.e.
    `<R> void` | Message.`reply(Object message, Handler<AsyncResult<Message<R>>> replyHandler)` The same as `reply(R message)` but you can specify handler for the reply - i.e.
    `<T> EventBus` | EventBus.`send(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Like `EventBus.send(java.lang.String, java.lang.Object)` but specifying a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `<T> EventBus` | EventBus.`send(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Like `EventBus.send(java.lang.String, java.lang.Object)` but specifying a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `void` | MessageConsumer.`unregister(Handler<AsyncResult<Void>> completionHandler)` Unregisters the handler which created this registration

  - ### Uses of Handler in io.vertx.rxjava.core.file

    Methods in io.vertx.rxjava.core.file with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `FileSystem` | FileSystem.`chmod(String path, String perms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chmodRecursive(String path, String perms, String dirPerms, Handler<AsyncResult<Void>> handler)` Change the permissions on the file represented by `path` to `perms`, asynchronously.
    `FileSystem` | FileSystem.`chown(String path, String user, String group, Handler<AsyncResult<Void>> handler)` Change the ownership on the file represented by `path` to `user` and {code group}, asynchronously.
    `void` | AsyncFile.`close(Handler<AsyncResult<Void>> handler)` Close the file.
    `FileSystem` | FileSystem.`copy(String from, String to, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`copyRecursive(String from, String to, boolean recursive, Handler<AsyncResult<Void>> handler)` Copy a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`createFile(String path, String perms, Handler<AsyncResult<Void>> handler)` Creates an empty file with the specified `path` and permissions `perms`, asynchronously.
    `FileSystem` | FileSystem.`delete(String path, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `FileSystem` | FileSystem.`deleteRecursive(String path, boolean recursive, Handler<AsyncResult<Void>> handler)` Deletes the file represented by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`drainHandler(Handler<Void> handler)`
    `AsyncFile` | AsyncFile.`endHandler(Handler<Void> endHandler)`
    `AsyncFile` | AsyncFile.`exceptionHandler(Handler<Throwable> handler)`
    `FileSystem` | FileSystem.`exists(String path, Handler<AsyncResult<Boolean>> handler)` Determines whether the file as specified by the path `path` exists, asynchronously.
    `AsyncFile` | AsyncFile.`flush(Handler<AsyncResult<Void>> handler)` Same as `AsyncFile.flush()` but the handler will be called when the flush is complete or if an error occurs
    `FileSystem` | FileSystem.`fsProps(String path, Handler<AsyncResult<FileSystemProps>> handler)` Returns properties of the file-system being used by the specified `path`, asynchronously.
    `AsyncFile` | AsyncFile.`handler(Handler<Buffer> handler)`
    `FileSystem` | FileSystem.`link(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a hard link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`lprops(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the link represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdir(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`mkdirs(String path, String perms, Handler<AsyncResult<Void>> handler)` Create the directory represented by `path` and any non existent parents, asynchronously.
    `FileSystem` | FileSystem.`move(String from, String to, Handler<AsyncResult<Void>> handler)` Move a file from the path `from` to path `to`, asynchronously.
    `FileSystem` | FileSystem.`open(String path, OpenOptions options, Handler<AsyncResult<AsyncFile>> handler)` Open the file represented by `path`, asynchronously.
    `FileSystem` | FileSystem.`props(String path, Handler<AsyncResult<FileProps>> handler)` Obtain properties for the file represented by `path`, asynchronously.
    `AsyncFile` | AsyncFile.`read(Buffer buffer, int offset, long position, int length, Handler<AsyncResult<Buffer>> handler)` Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readDir(String path, String filter, Handler<AsyncResult<List<String>>> handler)` Read the contents of the directory specified by `path`, asynchronously.
    `FileSystem` | FileSystem.`readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a , asynchronously.
    `FileSystem` | FileSystem.`readSymlink(String link, Handler<AsyncResult<String>> handler)` Returns the path representing the file that the symbolic link specified by `link` points to, asynchronously.
    `FileSystem` | FileSystem.`symlink(String link, String existing, Handler<AsyncResult<Void>> handler)` Create a symbolic link on the file system from `link` to `existing`, asynchronously.
    `FileSystem` | FileSystem.`truncate(String path, long len, Handler<AsyncResult<Void>> handler)` Truncate the file represented by `path` to length `len` in bytes, asynchronously.
    `FileSystem` | FileSystem.`unlink(String link, Handler<AsyncResult<Void>> handler)` Unlinks the link on the file system represented by the path `link`, asynchronously.
    `AsyncFile` | AsyncFile.`write(Buffer buffer, long position, Handler<AsyncResult<Void>> handler)` Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `FileSystem` | FileSystem.`writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.

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

    Methods in io.vertx.rxjava.core.http with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `HttpServerResponse` | HttpServerResponse.`bodyEndHandler(Handler<Void> handler)` Provide a handler that will be called just before the last part of the body is written to the wire and the response is ended.
    `HttpClientResponse` | HttpClientResponse.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `HttpServerRequest` | HttpServerRequest.`bodyHandler(Handler<Buffer> bodyHandler)` Convenience method for receiving the entire request body in one piece.
    `void` | HttpServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `HttpServer` but supplying a handler that will be called when the server is actually closed (or has failed).
    `HttpServerResponse` | HttpServerResponse.`closeHandler(Handler<Void> handler)` Set a close handler for the response.
    `ServerWebSocket` | ServerWebSocket.`closeHandler(Handler<Void> handler)`
    `WebSocket` | WebSocket.`closeHandler(Handler<Void> handler)`
    `WebSocketBase` | WebSocketBase.`closeHandler(Handler<Void> handler)` Set a close handler.
    `HttpClientRequest` | HttpClientRequest.`continueHandler(Handler<Void> handler)` If you send an HTTP request with the header `Expect` set to the value `100-continue` and the server responds with an interim HTTP response with a status code of `100` and a continue handler has been set using this method, then the `handler` will be called.
    `HttpClientRequest` | HttpClient.`delete(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`delete(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`delete(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`deleteAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP DELETE request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClientRequest.`drainHandler(Handler<Void> handler)`
    `HttpServerResponse` | HttpServerResponse.`drainHandler(Handler<Void> handler)`
    `ServerWebSocket` | ServerWebSocket.`drainHandler(Handler<Void> handler)`
    `WebSocket` | WebSocket.`drainHandler(Handler<Void> handler)`
    `WebSocketBase` | WebSocketBase.`drainHandler(Handler<Void> handler)`
    `HttpClientRequest` | HttpClientRequest.`endHandler(Handler<Void> endHandler)`
    `HttpClientResponse` | HttpClientResponse.`endHandler(Handler<Void> endHandler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`endHandler(Handler<Void> endHandler)`
    `HttpServerRequest` | HttpServerRequest.`endHandler(Handler<Void> endHandler)`
    `HttpServerRequestStream` | HttpServerRequestStream.`endHandler(Handler<Void> endHandler)`
    `ServerWebSocket` | ServerWebSocket.`endHandler(Handler<Void> endHandler)`
    `ServerWebSocketStream` | ServerWebSocketStream.`endHandler(Handler<Void> endHandler)`
    `WebSocket` | WebSocket.`endHandler(Handler<Void> endHandler)`
    `WebSocketBase` | WebSocketBase.`endHandler(Handler<Void> endHandler)`
    `WebSocketStream` | WebSocketStream.`endHandler(Handler<Void> endHandler)`
    `HttpClientRequest` | HttpClientRequest.`exceptionHandler(Handler<Throwable> handler)`
    `HttpClientResponse` | HttpClientResponse.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerRequest` | HttpServerRequest.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerRequestStream` | HttpServerRequestStream.`exceptionHandler(Handler<Throwable> handler)`
    `HttpServerResponse` | HttpServerResponse.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocketStream` | ServerWebSocketStream.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocket` | WebSocket.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocketBase` | WebSocketBase.`exceptionHandler(Handler<Throwable> handler)`
    `WebSocketStream` | WebSocketStream.`exceptionHandler(Handler<Throwable> handler)`
    `ServerWebSocket` | ServerWebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocket` | WebSocket.`frameHandler(Handler<WebSocketFrame> handler)`
    `WebSocketBase` | WebSocketBase.`frameHandler(Handler<WebSocketFrame> handler)` Set a frame handler on the connection.
    `HttpClientRequest` | HttpClient.`get(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP GET request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`get(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP GET request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`get(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP GET request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`getAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`getNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`getNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`getNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientResponse` | HttpClientResponse.`handler(Handler<Buffer> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`handler(Handler<Buffer> handler)`
    `HttpServerRequest` | HttpServerRequest.`handler(Handler<Buffer> handler)`
    `ServerWebSocket` | ServerWebSocket.`handler(Handler<Buffer> handler)`
    `WebSocket` | WebSocket.`handler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`handler(Handler<Buffer> handler)`
    `HttpClientRequest` | HttpClientRequest.`handler(Handler<HttpClientResponse> handler)`
    `HttpServerRequestStream` | HttpServerRequestStream.`handler(Handler<HttpServerRequest> handler)`
    `ServerWebSocketStream` | ServerWebSocketStream.`handler(Handler<ServerWebSocket> handler)`
    `WebSocketStream` | WebSocketStream.`handler(Handler<WebSocket> handler)`
    `HttpClientRequest` | HttpClient.`head(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP HEAD request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`head(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP HEAD request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`head(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP HEAD request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`headAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP HEAD request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpServerResponse` | HttpServerResponse.`headersEndHandler(Handler<Void> handler)` Provide a handler that will be called just before the headers are written to the wire.
    `HttpClient` | HttpClient.`headNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`headNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`headNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpServer` | HttpServer.`listen(Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpServer` | HttpServer.`listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler)` Like `HttpServer.listen()` but supplying a handler that will be called when the server is actually listening (or has failed).
    `HttpClientRequest` | HttpClient.`options(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`options(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`options(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`optionsAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP OPTIONS request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`optionsNow(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP OPTIONS request to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`optionsNow(String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP OPTIONS request to the server at the default host and port, specifying a response handler to receive the response
    `HttpClient` | HttpClient.`optionsNow(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Sends an HTTP OPTIONS request to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`post(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`post(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`post(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`postAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP POST request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`put(int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`put(String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`put(String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`putAbs(String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP PUT request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, int port, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`request(HttpMethod method, String host, String requestURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `HttpClientRequest` | HttpClient.`requestAbs(HttpMethod method, String absoluteURI, Handler<HttpClientResponse> responseHandler)` Create an HTTP request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpServer` | HttpServer.`requestHandler(Handler<HttpServerRequest> handler)` Set the request handler for the server to `requestHandler`.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse.sendFile(java.lang.String)` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerResponse` | HttpServerResponse.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Like `HttpServerResponse` but providing a handler which will be notified once the file has been completely written to the wire.
    `HttpServerRequest` | HttpServerRequest.`uploadHandler(Handler<HttpServerFileUpload> uploadHandler)` Set an upload handler.
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified port, host and relative request URI
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpClient` | HttpClient.`websocket(int port, String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect)` Connect a WebSocket at the relative request URI using the default host and port
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port
    `HttpClient` | HttpClient.`websocket(String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Connect a WebSocket at the relative request URI using the default host and port and the specified headers
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port and the specified headers
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port and the specified headers
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the specified version of WebSockets and the specified sub protocols
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the specified version of WebSockets and the specified sub protocols
    `HttpClient` | HttpClient.`websocket(String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the specified version of WebSockets and the specified sub protocols
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect)` Connect a WebSocket to the host and relative request URI and default port
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the host and relative request URI and default port
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the host and relative request URI and default port
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using the specified version of WebSockets
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect)` Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpClient` | HttpClient.`websocket(String host, String requestURI, MultiMap headers, WebsocketVersion version, String subProtocols, Handler<WebSocket> wsConnect, Handler<Throwable> failureHandler)` Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using the specified version of WebSockets, and the specified websocket sub protocols
    `HttpServer` | HttpServer.`websocketHandler(Handler<ServerWebSocket> handler)` Set the websocket handler for the server to `wsHandler`.

  - ### Uses of Handler in io.vertx.rxjava.core.net

    Methods in io.vertx.rxjava.core.net with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetServer.`close(Handler<AsyncResult<Void>> completionHandler)` Like `NetServer` but supplying a handler that will be notified when close is complete.
    `NetSocket` | NetSocket.`closeHandler(Handler<Void> handler)` Set a handler that will be called when the NetSocket is closed
    `NetClient` | NetClient.`connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler)` Open a connection to a server at the specific `port` and `host`.
    `NetServer` | NetServer.`connectHandler(Handler<NetSocket> handler)` Supply a connect handler for this server.
    `NetSocket` | NetSocket.`drainHandler(Handler<Void> handler)`
    `NetSocket` | NetSocket.`endHandler(Handler<Void> endHandler)`
    `NetSocketStream` | NetSocketStream.`endHandler(Handler<Void> endHandler)`
    `NetSocket` | NetSocket.`exceptionHandler(Handler<Throwable> handler)`
    `NetSocketStream` | NetSocketStream.`exceptionHandler(Handler<Throwable> handler)`
    `NetSocket` | NetSocket.`handler(Handler<Buffer> handler)`
    `NetSocketStream` | NetSocketStream.`handler(Handler<NetSocket> handler)`
    `NetServer` | NetServer.`listen(Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `NetServer` | NetServer.`listen(int port, String host, Handler<AsyncResult<NetServer>> listenHandler)` Like `NetServer.listen()` but providing a handler that will be notified when the server is listening, or fails.
    `NetSocket` | NetSocket.`sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket.sendFile(java.lang.String)` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)` Same as `NetSocket` but also takes a handler that will be called when the send has completed or a failure has occurred
    `NetSocket` | NetSocket.`upgradeToSsl(Handler<Void> handler)` Upgrade channel to use SSL/TLS.

  - ### Uses of Handler in io.vertx.rxjava.core.parsetools

    Classes in io.vertx.rxjava.core.parsetools that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `RecordParser` A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.

    Methods in io.vertx.rxjava.core.parsetools with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Handler<Buffer> output)` Create a new `RecordParser` instance, initially in delimited mode, and where the delimiter can be represented by the `Buffer` delim.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Handler<Buffer> output)` Create a new `RecordParser` instance, initially in delimited mode, and where the delimiter can be represented by the String `` delim endcoded in latin-1 .
    `static RecordParser` | RecordParser.`newFixed(int size, Handler<Buffer> output)` Create a new `RecordParser` instance, initially in fixed size mode, and where the record size is specified by the `size` parameter.
    `void` | RecordParser.`setOutput(Handler<Buffer> output)`

  - ### Uses of Handler in io.vertx.rxjava.core.shareddata

    Methods in io.vertx.rxjava.core.shareddata with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | Counter.`addAndGet(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the new count
    `void` | AsyncMap.`clear(Handler<AsyncResult<Void>> resultHandler)` Clear all entries in the map
    `void` | Counter.`compareAndSet(long expected, long value, Handler<AsyncResult<Boolean>> resultHandler)` Set the counter to the specified value only if the current value is the expectec value.
    `void` | Counter.`decrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Decrement the counter atomically and return the new count
    `void` | Counter.`get(Handler<AsyncResult<Long>> resultHandler)` Get the current value of the counter
    `void` | AsyncMap.`get(K k, Handler<AsyncResult<V>> resultHandler)` Get a value from the map, asynchronously.
    `void` | Counter.`getAndAdd(long value, Handler<AsyncResult<Long>> resultHandler)` Add the value to the counter atomically and return the value before the add
    `void` | Counter.`getAndIncrement(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the value before the increment.
    `<K,V> void` | SharedData.`getClusterWideMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the cluster wide map with the specified name.
    `void` | SharedData.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get a cluster wide counter.
    `void` | SharedData.`getLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get a cluster wide lock with the specified name.
    `void` | SharedData.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `SharedData` but specifying a timeout.
    `void` | Counter.`incrementAndGet(Handler<AsyncResult<Long>> resultHandler)` Increment the counter atomically and return the new count
    `void` | AsyncMap.`put(K k, V v, Handler<AsyncResult<Void>> completionHandler)` Put a value in the map, asynchronously.
    `void` | AsyncMap.`put(K k, V v, long ttl, Handler<AsyncResult<Void>> completionHandler)` Like `AsyncMap` but specifying a timeout.
    `void` | AsyncMap.`putIfAbsent(K k, V v, Handler<AsyncResult<V>> completionHandler)` Put the entry only if there is no entry with the key already present.
    `void` | AsyncMap.`putIfAbsent(K k, V v, long ttl, Handler<AsyncResult<V>> completionHandler)` Link `AsyncMap` but specifying a timeout.
    `void` | AsyncMap.`remove(K k, Handler<AsyncResult<V>> resultHandler)` Remove a value from the map, asynchronously.
    `void` | AsyncMap.`removeIfPresent(K k, V v, Handler<AsyncResult<Boolean>> resultHandler)` Remove a value from the map, only if entry already exists with same value.
    `void` | AsyncMap.`replace(K k, V v, Handler<AsyncResult<V>> resultHandler)` Replace the entry only if it is currently mapped to some value
    `void` | AsyncMap.`replaceIfPresent(K k, V oldValue, V newValue, Handler<AsyncResult<Boolean>> resultHandler)` Replace the entry only if it is currently mapped to a specific value
    `void` | AsyncMap.`size(Handler<AsyncResult<Integer>> resultHandler)` Provide the number of entries in the map

  - ### Uses of Handler in io.vertx.rxjava.core.streams

    Methods in io.vertx.rxjava.core.streams with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<T>` | WriteStream.`drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `ReadStream<T>` | ReadStream.`endHandler(Handler<Void> endHandler)` Set an end handler.
    `ReadStream<T>` | ReadStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `StreamBase` | StreamBase.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler.
    `WriteStream<T>` | WriteStream.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the write stream.
    `ReadStream<T>` | ReadStream.`handler(Handler<T> handler)` Set a data handler.

  - ### Uses of Handler in io.vertx.rxjava.ext.auth

    Methods in io.vertx.rxjava.ext.auth with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AuthProvider.`authenticate(JsonObject authInfo, Handler<AsyncResult<User>> resultHandler)` Authenticate a user.
    `User` | User.`isAuthorised(String authority, Handler<AsyncResult<Boolean>> resultHandler)` Is the user authorised to

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.common

    Methods in io.vertx.rxjava.ext.auth.common with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | AuthProvider.`authenticate(JsonObject authInfo, Handler<AsyncResult<User>> resultHandler)` Authenticate a user.
    `User` | User.`hasPermission(String permission, Handler<AsyncResult<Boolean>> resultHandler)` Does the user have the specified permission?
    `User` | User.`hasPermissions(Set<String> permissions, Handler<AsyncResult<Boolean>> resultHandler)` Does the user have all the specified permissions?
    `User` | User.`hasRole(String role, Handler<AsyncResult<Boolean>> resultHandler)` Does the user have the specified role?
    `User` | User.`hasRoles(Set<String> roles, Handler<AsyncResult<Boolean>> resultHandler)` Does the user have all the specified roles?

  - ### Uses of Handler in io.vertx.rxjava.ext.auth.mongo

    Methods in io.vertx.rxjava.ext.auth.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | MongoAuth.`insertUser(String username, String password, List<String> roles, List<String> permissions, Handler<AsyncResult<String>> resultHandler)` Insert a new user into mongo in the convenient way

  - ### Uses of Handler in io.vertx.rxjava.ext.jdbc

    Methods in io.vertx.rxjava.ext.jdbc with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `JDBCClient` | JDBCClient.`getConnection(Handler<AsyncResult<io.vertx.rxjava.ext.sql.SQLConnection>> handler)` Returns a connection that can be used to perform SQL operations on.

  - ### Uses of Handler in io.vertx.rxjava.ext.mail

    Methods in io.vertx.rxjava.ext.mail with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MailClient` | MailClient.`sendMail(MailMessage arg0, Handler<AsyncResult<MailResult>> arg1)`
    `MailService` | MailService.`sendMail(MailMessage email, Handler<AsyncResult<MailResult>> resultHandler)`

  - ### Uses of Handler in io.vertx.rxjava.ext.mongo

    Methods in io.vertx.rxjava.ext.mongo with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `MongoClient` | MongoClient.`count(String collection, JsonObject query, Handler<AsyncResult<Long>> resultHandler)` Count matching documents in a collection.
    `MongoClient` | MongoClient.`createCollection(String collectionName, Handler<AsyncResult<Void>> resultHandler)` Create a new collection
    `MongoClient` | MongoClient.`dropCollection(String collection, Handler<AsyncResult<Void>> resultHandler)` Drop a collection
    `MongoClient` | MongoClient.`find(String collection, JsonObject query, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection
    `MongoClient` | MongoClient.`findOne(String collection, JsonObject query, JsonObject fields, Handler<AsyncResult<JsonObject>> resultHandler)` Find a single matching document in the specified collection
    `MongoClient` | MongoClient.`findWithOptions(String collection, JsonObject query, FindOptions options, Handler<AsyncResult<List<JsonObject>>> resultHandler)` Find matching documents in the specified collection, specifying options
    `MongoClient` | MongoClient.`getCollections(Handler<AsyncResult<List<String>>> resultHandler)` Get a list of all collections in the database.
    `MongoClient` | MongoClient.`insert(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection
    `MongoClient` | MongoClient.`insertWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Insert a document in the specified collection with the specified write option
    `MongoClient` | MongoClient.`remove(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Remove matching documents from a collection
    `MongoClient` | MongoClient.`removeOne(String collection, JsonObject query, Handler<AsyncResult<Void>> resultHandler)` Remove a single matching document from a collection
    `MongoClient` | MongoClient.`removeOneWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Remove a single matching document from a collection with the specified write option
    `MongoClient` | MongoClient.`removeWithOptions(String collection, JsonObject query, WriteOption writeOption, Handler<AsyncResult<Void>> resultHandler)` Remove matching documents from a collection with the specified write option
    `MongoClient` | MongoClient.`replace(String collection, JsonObject query, JsonObject replace, Handler<AsyncResult<Void>> resultHandler)` Replace matching documents in the specified collection
    `MongoClient` | MongoClient.`replaceWithOptions(String collection, JsonObject query, JsonObject replace, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Replace matching documents in the specified collection, specifying options
    `MongoClient` | MongoClient.`runCommand(String commandName, JsonObject command, Handler<AsyncResult<JsonObject>> resultHandler)` Run an arbitrary MongoDB command.
    `MongoClient` | MongoClient.`save(String collection, JsonObject document, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection
    `MongoClient` | MongoClient.`saveWithOptions(String collection, JsonObject document, WriteOption writeOption, Handler<AsyncResult<String>> resultHandler)` Save a document in the specified collection with the specified write option
    `MongoClient` | MongoClient.`update(String collection, JsonObject query, JsonObject update, Handler<AsyncResult<Void>> resultHandler)` Update matching documents in the specified collection
    `MongoClient` | MongoClient.`updateWithOptions(String collection, JsonObject query, JsonObject update, UpdateOptions options, Handler<AsyncResult<Void>> resultHandler)` Update matching documents in the specified collection, specifying options

  - ### Uses of Handler in io.vertx.rxjava.ext.shell

    Methods in io.vertx.rxjava.ext.shell with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | ShellService.`start(Handler<AsyncResult<Void>> startHandler)` Start the shell service, this is an asynchronous start.
    `void` | ShellService.`stop(Handler<AsyncResult<Void>> stopHandler)` Stop the shell service, this is an asynchronous start.

  - ### Uses of Handler in io.vertx.rxjava.ext.shell.command

    Methods in io.vertx.rxjava.ext.shell.command with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `CommandBuilder` | CommandBuilder.`completionHandler(Handler<Completion> handler)` Set the command completion handler, the completion handler when the user asks for contextual command line completion, usually hitting the tab key.
    `CommandProcess` | CommandProcess.`eventHandler(EventType eventType, Handler<Void> handler)`
    `CommandBuilder` | CommandBuilder.`processHandler(Handler<CommandProcess> handler)` Set the command process handler, the process handler is called when the command is executed.

  - ### Uses of Handler in io.vertx.rxjava.ext.shell.io

    Methods in io.vertx.rxjava.ext.shell.io with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `Tty` | Tty.`eventHandler(EventType eventType, Handler<Void> handler)` Set an event handler to be notified by Shell events.
    `static Stream` | Stream.`ofJson(Handler<JsonObject> handler)`
    `static Stream` | Stream.`ofString(Handler<String> handler)`
    `Tty` | Tty.`setStdin(Handler<String> stdin)` Set an handler the standard input to read the data in String format.

  - ### Uses of Handler in io.vertx.rxjava.ext.shell.registry

    Methods in io.vertx.rxjava.ext.shell.registry with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | CommandRegistry.`createProcess(List<CliToken> line, Handler<AsyncResult<Process>> handler)` Try to create a process from the command line tokens.
    `void` | CommandRegistry.`createProcess(String line, Handler<AsyncResult<Process>> handler)` Parses a command line and try to create a process.
    `void` | CommandRegistry.`registerCommand(Command command, Handler<AsyncResult<CommandRegistration>> doneHandler)`
    `void` | CommandRegistry.`unregisterCommand(String commandName, Handler<AsyncResult<Void>> doneHandler)`

  - ### Uses of Handler in io.vertx.rxjava.ext.stomp

    Classes in io.vertx.rxjava.ext.stomp that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `StompServerHandler` STOMP server handler implements the behavior of the STOMP server when a specific event occurs.

    Methods in io.vertx.rxjava.ext.stomp with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `StompClientConnection` | StompClientConnection.`abort(String id, Handler<Frame> receiptHandler)` Aborts a transaction.
    `StompClientConnection` | StompClientConnection.`abort(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Aborts a transaction.
    `StompServerHandler` | StompServerHandler.`abortHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ABORT` frame is received.
    `StompClientConnection` | StompClientConnection.`ack(String id, Handler<Frame> receiptHandler)` Sends an acknowledgement for a specific message.
    `StompClientConnection` | StompClientConnection.`ack(String id, String txId, Handler<Frame> receiptHandler)` Sends an acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`ackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `ACK` frame is received.
    `StompServerHandler` | StompServerHandler.`beginHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `BEGIN` frame is received.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Handler<Frame> receiptHandler)` Begins a transaction.
    `StompClientConnection` | StompClientConnection.`beginTX(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Begins a transaction.
    `void` | StompServer.`close(Handler<AsyncResult<Void>> completionHandler)` Closes the server.
    `StompClientConnection` | StompClientConnection.`closeHandler(Handler<StompClientConnection> handler)` Sets a handler notified when the STOMP connection is closed.
    `StompServerHandler` | StompServerHandler.`closeHandler(Handler<StompServerConnection> handler)` Configures the action to execute when a connection with the client is closed.
    `StompClientConnection` | StompClientConnection.`commit(String id, Handler<Frame> receiptHandler)` Commits a transaction.
    `StompClientConnection` | StompClientConnection.`commit(String id, Map<String,String> headers, Handler<Frame> receiptHandler)` Commits a transaction.
    `StompServerHandler` | StompServerHandler.`commitHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `COMMIT` frame is received.
    `void` | StompServerConnection.`configureHeartbeat(long ping, long pong, Handler<StompServerConnection> pingHandler)` Configures the heartbeat.
    `StompClient` | StompClient.`connect(Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server using the host and port configured in the client's options.
    `StompClient` | StompClient.`connect(int port, String host, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(int port, String host, NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompClient` | StompClient.`connect(NetClient net, Handler<AsyncResult<StompClientConnection>> resultHandler)` Connects to the server.
    `StompServerHandler` | StompServerHandler.`connectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `CONNECT` frame is received.
    `StompClientConnection` | StompClientConnection.`disconnect(Frame frame, Handler<Frame> receiptHandler)` Disconnects the client.
    `StompClientConnection` | StompClientConnection.`disconnect(Handler<Frame> receiptHandler)` Disconnects the client.
    `StompServerHandler` | StompServerHandler.`disconnectHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `DISCONNECT` frame is received.
    `StompClientConnection` | StompClientConnection.`errorHandler(Handler<Frame> handler)` Sets a handler notified when an `ERROR` frame is received by the client.
    `StompServer` | StompServer.`listen(Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server default port (61613) and network interface (`0.0.0.0`).
    `StompServer` | StompServer.`listen(int port, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port.
    `StompServer` | StompServer.`listen(int port, String host, Handler<AsyncResult<StompServer>> handler)` Connects the STOMP server to the given port / interface.
    `StompClientConnection` | StompClientConnection.`nack(String id, Handler<Frame> receiptHandler)` Sends a non-acknowledgement for the given message.
    `StompClientConnection` | StompClientConnection.`nack(String id, String txId, Handler<Frame> receiptHandler)` Sends a non-acknowledgement for the given frame.
    `StompServerHandler` | StompServerHandler.`nackHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `NACK` frame is received.
    `StompServerHandler` | StompServerHandler.`onAckHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are acknowledged.
    `StompServerHandler` | StompServerHandler.`onAuthenticationRequest(StompServer server, String login, String passcode, Handler<AsyncResult<Boolean>> handler)` Called when the client connects to a server requiring authentication.
    `StompServerHandler` | StompServerHandler.`onNackHandler(Handler<Acknowledgement> handler)` Configures the action to execute when messages are not acknowledged.
    `StompClientConnection` | StompClientConnection.`pingHandler(Handler<StompClientConnection> handler)` Sets a handler that let customize the behavior when a ping needs to be sent to the server.
    `StompServerHandler` | StompServerHandler.`pingHandler(Handler<StompServerConnection> handler)` Allows customizing the action to do when the server needs to send a `PING` to the client.
    `StompClientConnection` | StompClientConnection.`send(Frame frame, Handler<Frame> receiptHandler)` Sends the given frame to the server.
    `StompClientConnection` | StompClientConnection.`send(Map<String,String> headers, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server.
    `StompClientConnection` | StompClientConnection.`send(String destination, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(String destination, Map<String,String> headers, Buffer body, Handler<Frame> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompServerHandler` | StompServerHandler.`sendHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SEND` frame is received.
    `StompServerHandler` | StompServerHandler.`stompHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `STOMP` frame is received.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `String` | StompClientConnection.`subscribe(String destination, Map<String,String> headers, Handler<Frame> handler, Handler<Frame> receiptHandler)` Subscribes to the given destination.
    `StompServerHandler` | StompServerHandler.`subscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `SUBSCRIBE` frame is received.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Handler<Frame> receiptHandler)` Un-subscribes from the given destination.
    `StompClientConnection` | StompClientConnection.`unsubscribe(String destination, Map<String,String> headers, Handler<Frame> receiptHandler)` Un-subscribes from the given destination.
    `StompServerHandler` | StompServerHandler.`unsubscribeHandler(Handler<ServerFrame> handler)` Configures the action to execute when a `UNSUBSCRIBE` frame is received.

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

    Methods in io.vertx.rxjava.ext.unit with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestSuite` | TestSuite.`after(Handler<TestContext> callback)` Set a callback executed after the tests.
    `TestSuite` | TestSuite.`afterEach(Handler<TestContext> callback)` Set a callback executed after each test and before the suite `after` callback.
    `TestSuite` | TestSuite.`before(Handler<TestContext> callback)` Set a callback executed before the tests.
    `TestSuite` | TestSuite.`beforeEach(Handler<TestContext> callback)` Set a callback executed before each test and after the suite `before` callback.
    `static TestCase` | TestCase.`create(String name, Handler<TestContext> testCase)` Create a test case.
    `void` | Completion.`handler(Handler<AsyncResult<T>> completionHandler)` Completion handler to receive a completion signal when this completions completes.
    `TestSuite` | TestSuite.`test(String name, Handler<TestContext> testCase)` Add a new test case to the suite.

  - ### Uses of Handler in io.vertx.rxjava.ext.unit.collect

    Methods in io.vertx.rxjava.ext.unit.collect with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static EventBusCollector` | EventBusCollector.`create(Vertx vertx, Handler<TestSuiteReport> reporter)`

  - ### Uses of Handler in io.vertx.rxjava.ext.unit.report

    Methods in io.vertx.rxjava.ext.unit.report with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `TestCaseReport` | TestCaseReport.`endHandler(Handler<TestResult> handler)` Set a callback for completion, the specified `handler` is invoked when the test exec has completed.
    `TestSuiteReport` | TestSuiteReport.`endHandler(Handler<Void> endHandler)`
    `TestSuiteReport` | TestSuiteReport.`exceptionHandler(Handler<Throwable> handler)` Set an exception handler, the exception handler reports the test suite errors, it can be called mulitple times before the test ends.
    `TestSuiteReport` | TestSuiteReport.`handler(Handler<TestCaseReport> handler)`

  - ### Uses of Handler in io.vertx.rxjava.ext.web

    Methods in io.vertx.rxjava.ext.web with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `int` | RoutingContext.`addBodyEndHandler(Handler<Void> handler)` Add a handler that will be called just before the response body has been completely written.
    `int` | RoutingContext.`addHeadersEndHandler(Handler<Void> handler)` Add a handler that will be called just before headers are written to the response.
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler)` Like `Route.blockingHandler(io.vertx.core.Handler<io.vertx.rxjava.ext.web.RoutingContext>)` called with ordered = true
    `Route` | Route.`blockingHandler(Handler<RoutingContext> requestHandler, boolean ordered)` Specify a blocking request handler for the route.
    `Router` | Router.`exceptionHandler(Handler<Throwable> exceptionHandler)` Specify a handler for any unhandled exceptions on this router.
    `Route` | Route.`failureHandler(Handler<RoutingContext> failureHandler)` Specify a failure handler for the route.
    `Route` | Route.`handler(Handler<RoutingContext> requestHandler)` Specify a request handler for the route.

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

    Classes in io.vertx.rxjava.ext.web.handler that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BasicAuthHandler` An auth handler that provides HTTP Basic Authentication support.
    `class` | `BodyHandler` A handler which gathers the entire request body and sets it on the .
    `class` | `CookieHandler` A handler which decodes cookies from the request, makes them available in the and writes them back in the response.
    `class` | `CorsHandler` A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
    `class` | `CSRFHandler` This handler adds a CSRF token to requests which mutate state.
    `class` | `ErrorHandler` A pretty error handler for rendering error pages.
    `class` | `FaviconHandler` A handler that serves favicons.
    `class` | `FormLoginHandler` Handler that handles login from a form on a custom login page.
    `class` | `JWTAuthHandler` An auth handler that provides JWT Authentication support.
    `class` | `LoggerHandler` A handler which logs request information to the Vert.x logger.
    `class` | `RedirectAuthHandler` An auth handler that's used to handle auth by redirecting user to a custom login page.
    `class` | `ResponseTimeHandler` Handler which adds a header `x-response-time` in the response of matching requests containing the time taken in ms to process the request.
    `class` | `SessionHandler` A handler that maintains a `Session` for each browser session.
    `class` | `StaticHandler` A handler for serving static resources from the file system or classpath.
    `class` | `TemplateHandler` A handler which renders responses using a template engine and where the template name is selected from the URI path.
    `class` | `TimeoutHandler` Handler that will timeout requests if the response has not been written after a certain time.
    `class` | `UserSessionHandler` This handler should be used if you want to store the User object in the Session so it's available between different requests, without you having re-authenticate each time.
    `class` | `VirtualHostHandler` Handler that will filter requests based on the request Host name.

    Methods in io.vertx.rxjava.ext.web.handler with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `static VirtualHostHandler` | VirtualHostHandler.`create(String hostname, Handler<RoutingContext> handler)` Create a handler

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

    Classes in io.vertx.rxjava.ext.web.handler.sockjs that implement Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SockJSHandler` A handler that allows you to handle SockJS connections from clients.

    Methods in io.vertx.rxjava.ext.web.handler.sockjs with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `SockJSHandler` | SockJSHandler.`bridge(BridgeOptions bridgeOptions, Handler<BridgeEvent> bridgeEventHandler)` Like `SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.BridgeOptions)` but specifying a handler that will receive bridge events.
    `SockJSSocket` | SockJSSocket.`drainHandler(Handler<Void> handler)`
    `SockJSSocket` | SockJSSocket.`endHandler(Handler<Void> endHandler)`
    `SockJSSocket` | SockJSSocket.`exceptionHandler(Handler<Throwable> handler)`
    `SockJSSocket` | SockJSSocket.`handler(Handler<Buffer> handler)`
    `SockJSHandler` | SockJSHandler.`socketHandler(Handler<SockJSSocket> handler)` Set a SockJS socket handler.

  - ### Uses of Handler in io.vertx.rxjava.ext.web.sstore

    Methods in io.vertx.rxjava.ext.web.sstore with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | SessionStore.`clear(Handler<AsyncResult<Boolean>> resultHandler)` Remove all sessions from the store
    `void` | SessionStore.`delete(String id, Handler<AsyncResult<Boolean>> resultHandler)` Delete the session with the specified ID
    `void` | SessionStore.`get(String id, Handler<AsyncResult<Session>> resultHandler)` Get the session with the specified ID
    `void` | SessionStore.`put(Session session, Handler<AsyncResult<Boolean>> resultHandler)` Add a session with the specified ID
    `void` | SessionStore.`size(Handler<AsyncResult<Integer>> resultHandler)` Get the number of sessions in the store

  - ### Uses of Handler in io.vertx.rxjava.ext.web.templ

    Methods in io.vertx.rxjava.ext.web.templ with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `void` | TemplateEngine.`render(RoutingContext context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render

  - ### Uses of Handler in io.vertx.rxjava.redis

    Methods in io.vertx.rxjava.redis with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `RedisClient` | RedisClient.`append(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a key
    `RedisClient` | RedisClient.`auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `RedisClient` | RedisClient.`bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `RedisClient` | RedisClient.`bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `RedisClient` | RedisClient.`bitcount(String key, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisClient` | RedisClient.`bitcountRange(String key, long start, long end, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisClient` | RedisClient.`bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Perform bitwise operations between strings
    `RedisClient` | RedisClient.`bitpos(String key, int bit, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string
    `RedisClient` | RedisClient.`bitposFrom(String key, int bit, int start, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
    `RedisClient` | RedisClient.`bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
    `RedisClient` | RedisClient.`blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisClient` | RedisClient.`blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisClient` | RedisClient.`brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler)` Pop a value from a list, push it to another list and return it; or block until one is available
    `RedisClient` | RedisClient.`brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `RedisClient` | RedisClient.`clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `RedisClient` | RedisClient.`clientKill(KillFilter filter, Handler<AsyncResult<Long>> handler)` Kill the connection of a client
    `RedisClient` | RedisClient.`clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `RedisClient` | RedisClient.`clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `RedisClient` | RedisClient.`clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
    `void` | RedisClient.`close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `RedisClient` | RedisClient.`clusterAddslots(List<Long> slots, Handler<AsyncResult<Void>> handler)` Assign new hash slots to receiving node.
    `RedisClient` | RedisClient.`clusterCountFailureReports(String nodeId, Handler<AsyncResult<Long>> handler)` Return the number of failure reports active for a given node.
    `RedisClient` | RedisClient.`clusterCountkeysinslot(long slot, Handler<AsyncResult<Long>> handler)` Return the number of local keys in the specified hash slot.
    `RedisClient` | RedisClient.`clusterDelslots(long slot, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `RedisClient` | RedisClient.`clusterDelslotsMany(List<Long> slots, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `RedisClient` | RedisClient.`clusterFailover(Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisClient` | RedisClient.`clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisClient` | RedisClient.`clusterForget(String nodeId, Handler<AsyncResult<Void>> handler)` Remove a node from the nodes table.
    `RedisClient` | RedisClient.`clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Return local key names in the specified hash slot.
    `RedisClient` | RedisClient.`clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Provides info about Redis Cluster node state.
    `RedisClient` | RedisClient.`clusterKeyslot(String key, Handler<AsyncResult<Long>> handler)` Returns the hash slot of the specified key.
    `RedisClient` | RedisClient.`clusterMeet(String ip, long port, Handler<AsyncResult<Void>> handler)` Force a node cluster to handshake with another node.
    `RedisClient` | RedisClient.`clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Get Cluster config for the node.
    `RedisClient` | RedisClient.`clusterReplicate(String nodeId, Handler<AsyncResult<Void>> handler)` Reconfigure a node as a slave of the specified master node.
    `RedisClient` | RedisClient.`clusterReset(Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `RedisClient` | RedisClient.`clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `RedisClient` | RedisClient.`clusterSaveconfig(Handler<AsyncResult<Void>> handler)` Forces the node to save cluster state on disk.
    `RedisClient` | RedisClient.`clusterSetConfigEpoch(long epoch, Handler<AsyncResult<Void>> handler)` Set the configuration epoch in a new node.
    `RedisClient` | RedisClient.`clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | RedisClient.`clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` List slave nodes of the specified master node.
    `RedisClient` | RedisClient.`clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
    `RedisClient` | RedisClient.`command(Handler<AsyncResult<JsonArray>> handler)` Get array of Redis command details
    `RedisClient` | RedisClient.`commandCount(Handler<AsyncResult<Long>> handler)` Get total number of Redis commands
    `RedisClient` | RedisClient.`commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
    `RedisClient` | RedisClient.`commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
    `RedisClient` | RedisClient.`configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
    `RedisClient` | RedisClient.`configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `RedisClient` | RedisClient.`configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `RedisClient` | RedisClient.`configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
    `RedisClient` | RedisClient.`dbsize(Handler<AsyncResult<Long>> handler)` Return the number of keys in the selected database
    `RedisClient` | RedisClient.`debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `RedisClient` | RedisClient.`debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `RedisClient` | RedisClient.`decr(String key, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by one
    `RedisClient` | RedisClient.`decrby(String key, long decrement, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by the given number
    `RedisClient` | RedisClient.`del(String key, Handler<AsyncResult<Long>> handler)` Delete a key
    `RedisClient` | RedisClient.`delMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete many keys
    `RedisClient` | RedisClient.`discard(Handler<AsyncResult<String>> handler)` Discard all commands issued after MULTI
    `RedisClient` | RedisClient.`dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisClient` | RedisClient.`echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `RedisClient` | RedisClient.`eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | RedisClient.`exec(Handler<AsyncResult<JsonArray>> handler)` Execute all commands issued after MULTI
    `RedisClient` | RedisClient.`exists(String key, Handler<AsyncResult<Long>> handler)` Determine if a key exists
    `RedisClient` | RedisClient.`expire(String key, int seconds, Handler<AsyncResult<Long>> handler)` Set a key's time to live in seconds
    `RedisClient` | RedisClient.`expireat(String key, long seconds, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp
    `RedisClient` | RedisClient.`flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `RedisClient` | RedisClient.`flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `RedisClient` | RedisClient.`get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisClient` | RedisClient.`getBinary(String key, Handler<AsyncResult<String>> handler)` Get the value of a key - without decoding as utf-8
    `RedisClient` | RedisClient.`getbit(String key, long offset, Handler<AsyncResult<Long>> handler)` Returns the bit value at offset in the string value stored at key
    `RedisClient` | RedisClient.`getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `RedisClient` | RedisClient.`getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
    `RedisClient` | RedisClient.`hdel(String key, String field, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `RedisClient` | RedisClient.`hdelMany(String key, List<String> fields, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `RedisClient` | RedisClient.`hexists(String key, String field, Handler<AsyncResult<Long>> handler)` Determine if a hash field exists
    `RedisClient` | RedisClient.`hget(String key, String field, Handler<AsyncResult<String>> handler)` Get the value of a hash field
    `RedisClient` | RedisClient.`hgetall(String key, Handler<AsyncResult<JsonObject>> handler)` Get all the fields and values in a hash
    `RedisClient` | RedisClient.`hincrby(String key, String field, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a hash field by the given number
    `RedisClient` | RedisClient.`hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a hash field by the given amount
    `RedisClient` | RedisClient.`hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
    `RedisClient` | RedisClient.`hlen(String key, Handler<AsyncResult<Long>> handler)` Get the number of fields in a hash
    `RedisClient` | RedisClient.`hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given hash fields
    `RedisClient` | RedisClient.`hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `RedisClient` | RedisClient.`hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate hash fields and associated values
    `RedisClient` | RedisClient.`hset(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the string value of a hash field
    `RedisClient` | RedisClient.`hsetnx(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the value of a hash field, only if the field does not exist
    `RedisClient` | RedisClient.`hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
    `RedisClient` | RedisClient.`incr(String key, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by one
    `RedisClient` | RedisClient.`incrby(String key, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by the given amount
    `RedisClient` | RedisClient.`incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a key by the given amount
    `RedisClient` | RedisClient.`info(Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisClient` | RedisClient.`infoSection(String section, Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisClient` | RedisClient.`keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
    `RedisClient` | RedisClient.`lastsave(Handler<AsyncResult<Long>> handler)` Get the UNIX time stamp of the last successful save to disk
    `RedisClient` | RedisClient.`lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
    `RedisClient` | RedisClient.`linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<Long>> handler)` Insert an element before or after another element in a list
    `RedisClient` | RedisClient.`llen(String key, Handler<AsyncResult<Long>> handler)` Get the length of a list
    `RedisClient` | RedisClient.`lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `RedisClient` | RedisClient.`lpush(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend one value to a list
    `RedisClient` | RedisClient.`lpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Prepend one or multiple values to a list
    `RedisClient` | RedisClient.`lpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend a value to a list, only if the list exists
    `RedisClient` | RedisClient.`lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Get a range of elements from a list
    `RedisClient` | RedisClient.`lrem(String key, long count, String value, Handler<AsyncResult<Long>> handler)` Remove elements from a list
    `RedisClient` | RedisClient.`lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
    `RedisClient` | RedisClient.`ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
    `RedisClient` | RedisClient.`mget(String key, Handler<AsyncResult<JsonArray>> handler)` Get the value of the given key
    `RedisClient` | RedisClient.`mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given keys
    `RedisClient` | RedisClient.`migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler)` Atomically transfer a key from a Redis instance to another one.
    `RedisClient` | RedisClient.`monitor(Handler<AsyncResult<Void>> handler)` Listen for all requests received by the server in real time
    `RedisClient` | RedisClient.`move(String key, int destdb, Handler<AsyncResult<Long>> handler)` Move a key to another database
    `RedisClient` | RedisClient.`mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisClient` | RedisClient.`msetnx(JsonObject keyvals, Handler<AsyncResult<Long>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `RedisClient` | RedisClient.`multi(Handler<AsyncResult<String>> handler)` Mark the start of a transaction block
    `RedisClient` | RedisClient.`object(String key, ObjectCmd cmd, Handler<AsyncResult<Void>> handler)` Inspect the internals of Redis objects
    `RedisClient` | RedisClient.`persist(String key, Handler<AsyncResult<Long>> handler)` Remove the expiration from a key
    `RedisClient` | RedisClient.`pexpire(String key, long millis, Handler<AsyncResult<Long>> handler)` Set a key's time to live in milliseconds
    `RedisClient` | RedisClient.`pexpireat(String key, long millis, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `RedisClient` | RedisClient.`pfadd(String key, String element, Handler<AsyncResult<Long>> handler)` Adds the specified element to the specified HyperLogLog.
    `RedisClient` | RedisClient.`pfaddMany(String key, List<String> elements, Handler<AsyncResult<Long>> handler)` Adds the specified elements to the specified HyperLogLog.
    `RedisClient` | RedisClient.`pfcount(String key, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisClient` | RedisClient.`pfcountMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisClient` | RedisClient.`pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisClient` | RedisClient.`ping(Handler<AsyncResult<String>> handler)` Ping the server
    `RedisClient` | RedisClient.`psetex(String key, long millis, String value, Handler<AsyncResult<Void>> handler)` Set the value and expiration in milliseconds of a key
    `RedisClient` | RedisClient.`psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given pattern
    `RedisClient` | RedisClient.`psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given patterns
    `RedisClient` | RedisClient.`pttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key in milliseconds
    `RedisClient` | RedisClient.`publish(String channel, String message, Handler<AsyncResult<Long>> handler)` Post a message to a channel
    `RedisClient` | RedisClient.`pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisClient` | RedisClient.`pubsubNumpat(Handler<AsyncResult<Long>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisClient` | RedisClient.`pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisClient` | RedisClient.`punsubscribe(List<String> patterns, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to channels matching the given patterns
    `RedisClient` | RedisClient.`randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `RedisClient` | RedisClient.`rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key
    `RedisClient` | RedisClient.`renamenx(String key, String newkey, Handler<AsyncResult<Long>> handler)` Rename a key, only if the new key does not exist
    `RedisClient` | RedisClient.`restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisClient` | RedisClient.`role(Handler<AsyncResult<JsonArray>> handler)` Return the role of the instance in the context of replication
    `RedisClient` | RedisClient.`rpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list
    `RedisClient` | RedisClient.`rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Remove the last element in a list, append it to another list and return it
    `RedisClient` | RedisClient.`rpush(String key, String value, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `RedisClient` | RedisClient.`rpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `RedisClient` | RedisClient.`rpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a list, only if the list exists
    `RedisClient` | RedisClient.`sadd(String key, String member, Handler<AsyncResult<Long>> handler)` Add a member to a set
    `RedisClient` | RedisClient.`saddMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a set
    `RedisClient` | RedisClient.`save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `RedisClient` | RedisClient.`scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate the keys space
    `RedisClient` | RedisClient.`scard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a set
    `RedisClient` | RedisClient.`scriptExists(String script, Handler<AsyncResult<JsonArray>> handler)` Check existence of script in the script cache.
    `RedisClient` | RedisClient.`scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler)` Check existence of scripts in the script cache.
    `RedisClient` | RedisClient.`scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `RedisClient` | RedisClient.`scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `RedisClient` | RedisClient.`scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `RedisClient` | RedisClient.`sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
    `RedisClient` | RedisClient.`sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<Long>> handler)` Subtract multiple sets and store the resulting set in a key
    `RedisClient` | RedisClient.`select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
    `RedisClient` | RedisClient.`set(String key, String value, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`setBinary(String key, String value, Handler<AsyncResult<Void>> handler)` Set the binary string value of a key - without encoding as utf-8
    `RedisClient` | RedisClient.`setbit(String key, long offset, int bit, Handler<AsyncResult<Long>> handler)` Sets or clears the bit at offset in the string value stored at key
    `RedisClient` | RedisClient.`setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
    `RedisClient` | RedisClient.`setnx(String key, String value, Handler<AsyncResult<Long>> handler)` Set the value of a key, only if the key does not exist
    `RedisClient` | RedisClient.`setrange(String key, int offset, String value, Handler<AsyncResult<Long>> handler)` Overwrite part of a string at key starting at the specified offset
    `RedisClient` | RedisClient.`setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `RedisClient` | RedisClient.`sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
    `RedisClient` | RedisClient.`sinterstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Intersect multiple sets and store the resulting set in a key
    `RedisClient` | RedisClient.`sismember(String key, String member, Handler<AsyncResult<Long>> handler)` Determine if a given value is a member of a set
    `RedisClient` | RedisClient.`slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Make the server a slave of another instance
    `RedisClient` | RedisClient.`slaveofNoone(Handler<AsyncResult<String>> handler)` Make this server a master
    `RedisClient` | RedisClient.`slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
    `RedisClient` | RedisClient.`slowlogLen(Handler<AsyncResult<Long>> handler)` Get the length of the Redis slow queries log
    `RedisClient` | RedisClient.`slowlogReset(Handler<AsyncResult<Void>> handler)` Reset the Redis slow queries log
    `RedisClient` | RedisClient.`smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | RedisClient.`smove(String key, String destkey, String member, Handler<AsyncResult<Long>> handler)` Move a member from one set to another
    `RedisClient` | RedisClient.`sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Sort the elements in a list, set or sorted set
    `RedisClient` | RedisClient.`spop(String key, Handler<AsyncResult<String>> handler)` Remove and return a random member from a set
    `RedisClient` | RedisClient.`spopMany(String key, int count, Handler<AsyncResult<String>> handler)` Remove and return random members from a set
    `RedisClient` | RedisClient.`srandmember(String key, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Get one or multiple random members from a set
    `RedisClient` | RedisClient.`srem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a set
    `RedisClient` | RedisClient.`sremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a set
    `RedisClient` | RedisClient.`sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate Set elements
    `RedisClient` | RedisClient.`strlen(String key, Handler<AsyncResult<Long>> handler)` Get the length of the value stored in a key
    `RedisClient` | RedisClient.`subscribe(String channel, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | RedisClient.`sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
    `RedisClient` | RedisClient.`sunionstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Add multiple sets and store the resulting set in a key
    `RedisClient` | RedisClient.`sync(Handler<AsyncResult<Void>> handler)` Internal command used for replication
    `RedisClient` | RedisClient.`time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `RedisClient` | RedisClient.`ttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key
    `RedisClient` | RedisClient.`type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `RedisClient` | RedisClient.`unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to the given channels
    `RedisClient` | RedisClient.`unwatch(Handler<AsyncResult<String>> handler)` Forget about all watched keys
    `RedisClient` | RedisClient.`wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisClient` | RedisClient.`watch(String key, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisClient` | RedisClient.`watchMany(List<String> keys, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisClient` | RedisClient.`zadd(String key, double score, String member, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | RedisClient.`zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | RedisClient.`zcard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a sorted set
    `RedisClient` | RedisClient.`zcount(String key, double min, double max, Handler<AsyncResult<Long>> handler)` Count the members in a sorted set with scores within the given values
    `RedisClient` | RedisClient.`zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
    `RedisClient` | RedisClient.`zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | RedisClient.`zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `RedisClient` | RedisClient.`zlexcount(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Count the number of members in a sorted set between a given lexicographical range
    `RedisClient` | RedisClient.`zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by lexicographical range
    `RedisClient` | RedisClient.`zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score
    `RedisClient` | RedisClient.`zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | RedisClient.`zrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set
    `RedisClient` | RedisClient.`zrem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a sorted set
    `RedisClient` | RedisClient.`zremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a sorted set
    `RedisClient` | RedisClient.`zremrangebylex(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set between the given lexicographical range
    `RedisClient` | RedisClient.`zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given indexes
    `RedisClient` | RedisClient.`zremrangebyscore(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given scores
    `RedisClient` | RedisClient.`zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisClient` | RedisClient.`zrevrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `RedisClient` | RedisClient.`zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate sorted sets elements and associated scores
    `RedisClient` | RedisClient.`zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
    `RedisClient` | RedisClient.`zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key
    `RedisClient` | RedisClient.`zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key

  - ### Uses of Handler in io.vertx.serviceproxy

    Classes in io.vertx.serviceproxy with annotations of type with type parameters of type that implement declared as with annotations of type with type parameters of type with annotations of type with annotations of type with type parameters of type that return that return types with arguments of type with parameters of type with type arguments of type that throw with annotations of type with annotations of type with parameters of type with type arguments of type that throw Handler
    Modifier and Type | Class and Description
    --- | ---
    `class` | `io.vertx.serviceproxy.ProxyHandler`

  - ### Uses of Handler in io.vertx.spi.cluster.hazelcast

    Methods in io.vertx.spi.cluster.hazelcast with parameters of type Handler
    Modifier and Type | Method and Description
    --- | ---
    `<K,V> void` | HazelcastClusterManager.`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)`
    `<K,V> void` | HazelcastClusterManager.`getAsyncMultiMap(String name, Handler<AsyncResult<AsyncMultiMap<K,V>>> resultHandler)` Every eventbus handler has an ID.
    `void` | HazelcastClusterManager.`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)`
    `void` | HazelcastClusterManager.`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)`
    `void` | HazelcastClusterManager.`join(Handler<AsyncResult<Void>> resultHandler)`
    `void` | HazelcastClusterManager.`leave(Handler<AsyncResult<Void>> resultHandler)`

Copyright © 2015. All rights reserved.