## Uses of Class
io.vertx.reactivex.core.buffer.Buffer

- Packages that use Buffer
  Package | Description
  --- | ---
  io.vertx.reactivex.amqp |
  io.vertx.reactivex.core |
  io.vertx.reactivex.core.buffer |
  io.vertx.reactivex.core.datagram |
  io.vertx.reactivex.core.file |
  io.vertx.reactivex.core.http |
  io.vertx.reactivex.core.net |
  io.vertx.reactivex.core.parsetools |
  io.vertx.reactivex.ext.auth.oauth2 |
  io.vertx.reactivex.ext.mail |
  io.vertx.reactivex.ext.mongo |
  io.vertx.reactivex.ext.stomp |
  io.vertx.reactivex.ext.web |
  io.vertx.reactivex.ext.web.client |
  io.vertx.reactivex.ext.web.client.predicate |
  io.vertx.reactivex.ext.web.codec |
  io.vertx.reactivex.ext.web.common.template |
  io.vertx.reactivex.ext.web.handler.sockjs |
  io.vertx.reactivex.ext.web.validation |
  io.vertx.reactivex.kafka.client.producer |
  io.vertx.reactivex.mqtt |
  io.vertx.reactivex.mqtt.messages |
  io.vertx.reactivex.rabbitmq |
  io.vertx.reactivex.redis.client |
  io.vertx.reactivex.sqlclient |

- - ### Uses of Buffer in io.vertx.reactivex.amqp

    Methods in io.vertx.reactivex.amqp that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | AmqpMessage.`bodyAsBinary()`

    Methods in io.vertx.reactivex.amqp with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `AmqpMessageBuilder` | AmqpMessageBuilder.`withBufferAsBody(Buffer buffer)`

  - ### Uses of Buffer in io.vertx.reactivex.core

    Methods in io.vertx.reactivex.core that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `static <T> MaybeTransformer<Buffer,T>` | MaybeHelper.`unmarshaller(Class<T> mappedType)`
    `static <T> SingleTransformer<Buffer,T>` | SingleHelper.`unmarshaller(Class<T> mappedType)`
    `static <T> FlowableTransformer<Buffer,T>` | FlowableHelper.`unmarshaller(Class<T> mappedType)`
    `static <T> ObservableTransformer<Buffer,T>` | ObservableHelper.`unmarshaller(Class<T> mappedType)`
    `static <T> MaybeTransformer<Buffer,T>` | MaybeHelper.`unmarshaller(Class<T> mappedType, ObjectCodec mapper)`
    `static <T> SingleTransformer<Buffer,T>` | SingleHelper.`unmarshaller(Class<T> mappedType, ObjectCodec mapper)`
    `static <T> FlowableTransformer<Buffer,T>` | FlowableHelper.`unmarshaller(Class<T> mappedType, ObjectCodec mapper)`
    `static <T> ObservableTransformer<Buffer,T>` | ObservableHelper.`unmarshaller(Class<T> mappedType, ObjectCodec mapper)`
    `static <T> MaybeTransformer<Buffer,T>` | MaybeHelper.`unmarshaller(TypeReference<T> mappedTypeRef)`
    `static <T> SingleTransformer<Buffer,T>` | SingleHelper.`unmarshaller(TypeReference<T> mappedTypeRef)`
    `static <T> FlowableTransformer<Buffer,T>` | FlowableHelper.`unmarshaller(TypeReference<T> mappedTypeRef)`
    `static <T> ObservableTransformer<Buffer,T>` | ObservableHelper.`unmarshaller(TypeReference<T> mappedTypeRef)`
    `static <T> MaybeTransformer<Buffer,T>` | MaybeHelper.`unmarshaller(TypeReference<T> mappedTypeRef, ObjectCodec mapper)`
    `static <T> SingleTransformer<Buffer,T>` | SingleHelper.`unmarshaller(TypeReference<T> mappedTypeRef, ObjectCodec mapper)`
    `static <T> FlowableTransformer<Buffer,T>` | FlowableHelper.`unmarshaller(TypeReference<T> mappedTypeRef, ObjectCodec mapper)`
    `static <T> ObservableTransformer<Buffer,T>` | ObservableHelper.`unmarshaller(TypeReference<T> mappedTypeRef, ObjectCodec mapper)`

  - ### Uses of Buffer in io.vertx.reactivex.core.buffer

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

    Methods in io.vertx.reactivex.core.buffer that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | Buffer.`appendBuffer(Buffer buff)` Appends the specified `Buffer` to the end of this Buffer.
    `Buffer` | Buffer.`appendBuffer(Buffer buff, int offset, int len)` Appends the specified `Buffer` starting at the `offset` using `len` to the end of this Buffer.
    `Buffer` | Buffer.`appendByte(byte b)` Appends the specified `byte` to the end of the Buffer.
    `Buffer` | Buffer.`appendBytes(byte[] bytes)` Appends the specified `byte[]` to the end of the Buffer.
    `Buffer` | Buffer.`appendBytes(byte[] bytes, int offset, int len)` Appends the specified number of bytes from `byte[]` to the end of the Buffer, starting at the given offset.
    `Buffer` | Buffer.`appendDouble(double d)` Appends the specified `double` to the end of the Buffer.
    `Buffer` | Buffer.`appendFloat(float f)` Appends the specified `float` to the end of the Buffer.
    `Buffer` | Buffer.`appendInt(int i)` Appends the specified `int` to the end of the Buffer.
    `Buffer` | Buffer.`appendIntLE(int i)` Appends the specified `int` to the end of the Buffer in the Little Endian Byte Order.
    `Buffer` | Buffer.`appendLong(long l)` Appends the specified `long` to the end of the Buffer.
    `Buffer` | Buffer.`appendLongLE(long l)` Appends the specified `long` to the end of the Buffer in the Little Endian Byte Order.
    `Buffer` | Buffer.`appendMedium(int i)` Appends the specified 24bit `int` to the end of the Buffer.
    `Buffer` | Buffer.`appendMediumLE(int i)` Appends the specified 24bit `int` to the end of the Buffer in the Little Endian Byte Order.
    `Buffer` | Buffer.`appendShort(short s)` Appends the specified `short` to the end of the Buffer.The buffer will expand as necessary to accommodate any bytes written.
    `Buffer` | Buffer.`appendShortLE(short s)` Appends the specified `short` to the end of the Buffer in the Little Endian Byte Order.The buffer will expand as necessary to accommodate any bytes written.
    `Buffer` | Buffer.`appendString(String str)` Appends the specified `String str` to the end of the Buffer with UTF-8 encoding.
    `Buffer` | Buffer.`appendString(String str, String enc)` Appends the specified `String` to the end of the Buffer with the encoding as specified by `enc`.
    `Buffer` | Buffer.`appendUnsignedByte(short b)` Appends the specified unsigned `byte` to the end of the Buffer.
    `Buffer` | Buffer.`appendUnsignedInt(long i)` Appends the specified unsigned `int` to the end of the Buffer.
    `Buffer` | Buffer.`appendUnsignedIntLE(long i)` Appends the specified unsigned `int` to the end of the Buffer in the Little Endian Byte Order.
    `Buffer` | Buffer.`appendUnsignedShort(int s)` Appends the specified unsigned `short` to the end of the Buffer.The buffer will expand as necessary to accommodate any bytes written.
    `Buffer` | Buffer.`appendUnsignedShortLE(int s)` Appends the specified unsigned `short` to the end of the Buffer in the Little Endian Byte Order.The buffer will expand as necessary to accommodate any bytes written.
    `static Buffer` | Buffer.`buffer()` Create a new, empty buffer.
    `static Buffer` | Buffer.`buffer(byte[] bytes)` Create a new buffer from a byte[].
    `static Buffer` | Buffer.`buffer(io.netty.buffer.ByteBuf byteBuf)` Create a new buffer from a Netty `ByteBuf`.
    `static Buffer` | Buffer.`buffer(int initialSizeHint)` Create a new buffer given the initial size hint.
    `static Buffer` | Buffer.`buffer(String string)` Create a new buffer from a string.
    `static Buffer` | Buffer.`buffer(String string, String enc)` Create a new buffer from a string and using the specified encoding.
    `Buffer` | Buffer.`copy()` Returns a copy of the entire Buffer.
    `Buffer` | Buffer.`getBuffer(int start, int end)` Returns a copy of a sub-sequence the Buffer as a `Buffer` starting at position `start` and ending at position `end - 1`
    `Buffer` | Buffer.`getBytes(byte[] dst)` Transfers the content of the Buffer into a `byte[]`.
    `Buffer` | Buffer.`getBytes(byte[] dst, int dstIndex)` Transfers the content of the Buffer into a `byte[]` at the specific destination.
    `Buffer` | Buffer.`getBytes(int start, int end, byte[] dst)` Transfers the content of the Buffer starting at position `start` and ending at position `end - 1` into a `byte[]`.
    `Buffer` | Buffer.`getBytes(int start, int end, byte[] dst, int dstIndex)` Transfers the content of the Buffer starting at position `start` and ending at position `end - 1` into a `byte[]` at the specific destination.
    `static Buffer` | Buffer.`newInstance(Buffer arg)`
    `Buffer` | Buffer.`setBuffer(int pos, Buffer b)` Sets the bytes at position `pos` in the Buffer to the bytes represented by the `Buffer b`.
    `Buffer` | Buffer.`setBuffer(int pos, Buffer b, int offset, int len)` Sets the bytes at position `pos` in the Buffer to the bytes represented by the `Buffer b` on the given `offset` and `len`.
    `Buffer` | Buffer.`setByte(int pos, byte b)` Sets the `byte` at position `pos` in the Buffer to the value `b`.
    `Buffer` | Buffer.`setBytes(int pos, byte[] b)` Sets the bytes at position `pos` in the Buffer to the bytes represented by the `byte[] b`.
    `Buffer` | Buffer.`setBytes(int pos, byte[] b, int offset, int len)` Sets the given number of bytes at position `pos` in the Buffer to the bytes represented by the `byte[] b`.
    `Buffer` | Buffer.`setBytes(int pos, ByteBuffer b)` Sets the bytes at position `pos` in the Buffer to the bytes represented by the `ByteBuffer b`.
    `Buffer` | Buffer.`setDouble(int pos, double d)` Sets the `double` at position `pos` in the Buffer to the value `d`.
    `Buffer` | Buffer.`setFloat(int pos, float f)` Sets the `float` at position `pos` in the Buffer to the value `f`.
    `Buffer` | Buffer.`setInt(int pos, int i)` Sets the `int` at position `pos` in the Buffer to the value `i`.
    `Buffer` | Buffer.`setIntLE(int pos, int i)` Sets the `int` at position `pos` in the Buffer to the value `i` in the Little Endian Byte Order.
    `Buffer` | Buffer.`setLong(int pos, long l)` Sets the `long` at position `pos` in the Buffer to the value `l`.
    `Buffer` | Buffer.`setLongLE(int pos, long l)` Sets the `long` at position `pos` in the Buffer to the value `l` in the Little Endian Byte Order.
    `Buffer` | Buffer.`setMedium(int pos, int i)` Sets the 24bit `int` at position `pos` in the Buffer to the value `i`.
    `Buffer` | Buffer.`setMediumLE(int pos, int i)` Sets the 24bit `int` at position `pos` in the Buffer to the value `i`.
    `Buffer` | Buffer.`setShort(int pos, short s)` Sets the `short` at position `pos` in the Buffer to the value `s`.
    `Buffer` | Buffer.`setShortLE(int pos, short s)` Sets the `short` at position `pos` in the Buffer to the value `s` in the Little Endian Byte Order.
    `Buffer` | Buffer.`setString(int pos, String str)` Sets the bytes at position `pos` in the Buffer to the value of `str` encoded in UTF-8.
    `Buffer` | Buffer.`setString(int pos, String str, String enc)` Sets the bytes at position `pos` in the Buffer to the value of `str` encoded in encoding `enc`.
    `Buffer` | Buffer.`setUnsignedByte(int pos, short b)` Sets the unsigned `byte` at position `pos` in the Buffer to the value `b`.
    `Buffer` | Buffer.`setUnsignedInt(int pos, long i)` Sets the unsigned `int` at position `pos` in the Buffer to the value `i`.
    `Buffer` | Buffer.`setUnsignedIntLE(int pos, long i)` Sets the unsigned `int` at position `pos` in the Buffer to the value `i` in the Little Endian Byte Order.
    `Buffer` | Buffer.`setUnsignedShort(int pos, int s)` Sets the unsigned `short` at position `pos` in the Buffer to the value `s`.
    `Buffer` | Buffer.`setUnsignedShortLE(int pos, int s)` Sets the unsigned `short` at position `pos` in the Buffer to the value `s` in the Little Endian Byte Order.
    `Buffer` | Buffer.`slice()` Returns a slice of this buffer.
    `Buffer` | Buffer.`slice(int start, int end)` Returns a slice of this buffer.

    Methods in io.vertx.reactivex.core.buffer with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | Buffer.`appendBuffer(Buffer buff)` Appends the specified `Buffer` to the end of this Buffer.
    `Buffer` | Buffer.`appendBuffer(Buffer buff, int offset, int len)` Appends the specified `Buffer` starting at the `offset` using `len` to the end of this Buffer.
    `Buffer` | Buffer.`setBuffer(int pos, Buffer b)` Sets the bytes at position `pos` in the Buffer to the bytes represented by the `Buffer b`.
    `Buffer` | Buffer.`setBuffer(int pos, Buffer b, int offset, int len)` Sets the bytes at position `pos` in the Buffer to the bytes represented by the `Buffer b` on the given `offset` and `len`.

  - ### Uses of Buffer in io.vertx.reactivex.core.datagram

    Methods in io.vertx.reactivex.core.datagram that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | DatagramPacket.`data()` Returns the data of the `DatagramPacket`

    Methods in io.vertx.reactivex.core.datagram that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `WriteStream<Buffer>` | DatagramSocket.`sender(int port, String host)` Returns a `WriteStream` able to send to the `SocketAddress`.

    Methods in io.vertx.reactivex.core.datagram with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Completable` | DatagramSocket.`rxSend(Buffer packet, int port, String host)` Write the given `Buffer` to the `SocketAddress`.
    `DatagramSocket` | DatagramSocket.`send(Buffer packet, int port, String host)` Write the given `Buffer` to the `SocketAddress`.
    `DatagramSocket` | DatagramSocket.`send(Buffer packet, int port, String host, Handler<AsyncResult<Void>> handler)` Write the given `Buffer` to the `SocketAddress`.

  - ### Uses of Buffer in io.vertx.reactivex.core.file

    Methods in io.vertx.reactivex.core.file that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | FileSystem.`readFileBlocking(String path)` Blocking version of `FileSystem.readFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>)`

    Methods in io.vertx.reactivex.core.file that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Pipe<Buffer>` | AsyncFile.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Single<Buffer>` | AsyncFile.`rxRead(Buffer buffer, int offset, long position, int length)` Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `Single<Buffer>` | FileSystem.`rxReadFile(String path)` Reads the entire file as represented by the path `path` as a , asynchronously.
    `Flowable<Buffer>` | AsyncFile.`toFlowable()`
    `Observable<Buffer>` | AsyncFile.`toObservable()`
    `io.vertx.reactivex.WriteStreamObserver<Buffer>` | AsyncFile.`toObserver()`
    `io.vertx.reactivex.WriteStreamSubscriber<Buffer>` | AsyncFile.`toSubscriber()`

    Methods in io.vertx.reactivex.core.file with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `void` | AsyncFile.`end(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | AsyncFile.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `AsyncFile` | AsyncFile.`read(Buffer buffer, int offset, long position, int length)` Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `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.
    `Completable` | AsyncFile.`rxEnd(Buffer data)` Same as but with an `handler` called when the operation completes
    `Single<Buffer>` | AsyncFile.`rxRead(Buffer buffer, int offset, long position, int length)` Reads `length` bytes of data from the file at position `position` in the file, asynchronously.
    `Completable` | AsyncFile.`rxWrite(Buffer data)` Same as but with an `handler` called when the operation completes
    `Completable` | AsyncFile.`rxWrite(Buffer buffer, long position)` Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `Completable` | FileSystem.`rxWriteFile(String path, Buffer data)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, asynchronously.
    `void` | AsyncFile.`write(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | AsyncFile.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | AsyncFile.`write(Buffer buffer, long position)` Write a `Buffer` to the file at position `position` in the file, asynchronously.
    `void` | 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)` Creates the file, and writes the specified `Buffer data` to the file represented by the path `path`, 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.
    `FileSystem` | FileSystem.`writeFileBlocking(String path, Buffer data)` Blocking version of `FileSystem.writeFile(java.lang.String, io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`

    Method parameters in io.vertx.reactivex.core.file with type arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `AsyncFile` | AsyncFile.`handler(Handler<Buffer> handler)`
    `void` | AsyncFile.`pipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | AsyncFile.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `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.`readFile(String path, Handler<AsyncResult<Buffer>> handler)` Reads the entire file as represented by the path `path` as a , asynchronously.
    `Completable` | AsyncFile.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of Buffer in io.vertx.reactivex.core.http

    Methods in io.vertx.reactivex.core.http that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | WebSocketFrame.`binaryData()`
    `Buffer` | HttpFrame.`payload()`

    Methods in io.vertx.reactivex.core.http that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Pipe<Buffer>` | HttpClientResponse.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Pipe<Buffer>` | ServerWebSocket.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Pipe<Buffer>` | WebSocket.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Pipe<Buffer>` | HttpServerFileUpload.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Pipe<Buffer>` | HttpServerRequest.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Pipe<Buffer>` | WebSocketBase.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Single<Buffer>` | HttpClientResponse.`rxBody()` Same as `HttpClientResponse.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>)` but with an `handler` called when the operation completes
    `Single<Buffer>` | HttpConnection.`rxPing(Buffer data)` Send a frame to the remote endpoint.
    `Flowable<Buffer>` | HttpClientResponse.`toFlowable()`
    `Flowable<Buffer>` | ServerWebSocket.`toFlowable()`
    `Flowable<Buffer>` | WebSocket.`toFlowable()`
    `Flowable<Buffer>` | HttpServerFileUpload.`toFlowable()`
    `Flowable<Buffer>` | HttpServerRequest.`toFlowable()`
    `Observable<Buffer>` | HttpClientResponse.`toObservable()`
    `Observable<Buffer>` | ServerWebSocket.`toObservable()`
    `Observable<Buffer>` | WebSocket.`toObservable()`
    `Observable<Buffer>` | HttpServerFileUpload.`toObservable()`
    `Observable<Buffer>` | HttpServerRequest.`toObservable()`
    `io.vertx.reactivex.WriteStreamObserver<Buffer>` | HttpServerResponse.`toObserver()`
    `io.vertx.reactivex.WriteStreamObserver<Buffer>` | ServerWebSocket.`toObserver()`
    `io.vertx.reactivex.WriteStreamObserver<Buffer>` | HttpClientRequest.`toObserver()`
    `io.vertx.reactivex.WriteStreamObserver<Buffer>` | WebSocket.`toObserver()`
    `io.vertx.reactivex.WriteStreamSubscriber<Buffer>` | HttpServerResponse.`toSubscriber()`
    `io.vertx.reactivex.WriteStreamSubscriber<Buffer>` | ServerWebSocket.`toSubscriber()`
    `io.vertx.reactivex.WriteStreamSubscriber<Buffer>` | HttpClientRequest.`toSubscriber()`
    `io.vertx.reactivex.WriteStreamSubscriber<Buffer>` | WebSocket.`toSubscriber()`

    Methods in io.vertx.reactivex.core.http with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `static WebSocketFrame` | WebSocketFrame.`binaryFrame(Buffer data, boolean isFinal)` Create a binary WebSocket frame.
    `static WebSocketFrame` | WebSocketFrame.`continuationFrame(Buffer data, boolean isFinal)` Create a continuation frame
    `void` | HttpServerResponse.`end(Buffer chunk)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`end(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(Buffer chunk)` Same as `HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocket.`end(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | WebSocketBase.`end(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`end(Buffer chunk, Handler<AsyncResult<Void>> handler)` Same as `HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `void` | WebSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocketBase.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `HttpConnection` | HttpConnection.`goAway(long errorCode, int lastStreamId, Buffer debugData)` Send a go away frame to the remote endpoint of the connection.
    `HttpConnection` | HttpConnection.`ping(Buffer data)` Send a frame to the remote endpoint.
    `HttpConnection` | HttpConnection.`ping(Buffer data, Handler<AsyncResult<Buffer>> pongHandler)` Send a frame to the remote endpoint.
    `static WebSocketFrame` | WebSocketFrame.`pingFrame(Buffer data)` Create a ping WebSocket frame.
    `static WebSocketFrame` | WebSocketFrame.`pongFrame(Buffer data)` Create a pong WebSocket frame.
    `void` | HttpClient.`post(int port, String host, String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(RequestOptions options, Buffer body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`post(RequestOptions options, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(RequestOptions options, Buffer body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`put(RequestOptions options, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Completable` | HttpServerResponse.`rxEnd(Buffer chunk)` Same as `HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `Completable` | ServerWebSocket.`rxEnd(Buffer data)` Same as but with an `handler` called when the operation completes
    `Completable` | HttpClientRequest.`rxEnd(Buffer chunk)` Same as `HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `Completable` | WebSocket.`rxEnd(Buffer data)` Same as but with an `handler` called when the operation completes
    `Completable` | WebSocketBase.`rxEnd(Buffer data)` Same as but with an `handler` called when the operation completes
    `Single<Buffer>` | HttpConnection.`rxPing(Buffer data)` Send a frame to the remote endpoint.
    `Single<HttpClientResponse>` | HttpClient.`rxPost(int port, String host, String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(RequestOptions options, Buffer body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String host, String requestURI, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(int port, String host, String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(RequestOptions options, Buffer body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String host, String requestURI, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, int port, String host, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String host, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(RequestOptions options, Buffer body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `Completable` | HttpServerResponse.`rxWrite(Buffer data)` Same as but with an `handler` called when the operation completes
    `Completable` | ServerWebSocket.`rxWrite(Buffer data)` Same as but with an `handler` called when the operation completes
    `Completable` | HttpClientRequest.`rxWrite(Buffer data)` Same as but with an `handler` called when the operation completes
    `Completable` | WebSocket.`rxWrite(Buffer data)` Same as but with an `handler` called when the operation completes
    `Completable` | WebSocketBase.`rxWrite(Buffer data)` Same as but with an `handler` called when the operation completes
    `Completable` | ServerWebSocket.`rxWriteBinaryMessage(Buffer data)`
    `Completable` | WebSocket.`rxWriteBinaryMessage(Buffer data)`
    `Completable` | WebSocketBase.`rxWriteBinaryMessage(Buffer data)` Same as `WebSocketBase.writeBinaryMessage(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `Completable` | ServerWebSocket.`rxWriteFinalBinaryFrame(Buffer data)`
    `Completable` | WebSocket.`rxWriteFinalBinaryFrame(Buffer data)`
    `Completable` | WebSocketBase.`rxWriteFinalBinaryFrame(Buffer data)` Same as `WebSocketBase.writeFinalBinaryFrame(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `Completable` | ServerWebSocket.`rxWritePing(Buffer data)` Writes a ping frame to the connection.
    `Completable` | WebSocket.`rxWritePing(Buffer data)` Writes a ping frame to the connection.
    `Completable` | WebSocketBase.`rxWritePing(Buffer data)` Writes a ping frame to the connection.
    `Completable` | ServerWebSocket.`rxWritePong(Buffer data)` Writes a pong frame to the connection.
    `Completable` | WebSocket.`rxWritePong(Buffer data)` Writes a pong frame to the connection.
    `Completable` | WebSocketBase.`rxWritePong(Buffer data)` Writes a pong frame to the connection.
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, Buffer body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, MultiMap headers, Buffer body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, MultiMap headers, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(RequestOptions options, Buffer body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`send(RequestOptions options, Buffer body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpServerResponse.`write(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`write(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`write(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | WebSocket.`write(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | WebSocketBase.`write(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | HttpServerResponse.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | ServerWebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | HttpClientRequest.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `void` | WebSocketBase.`write(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeBinaryMessage(Buffer data)`
    `WebSocket` | WebSocket.`writeBinaryMessage(Buffer data)`
    `WebSocketBase` | WebSocketBase.`writeBinaryMessage(Buffer data)` Same as `WebSocketBase.writeBinaryMessage(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeBinaryMessage(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `HttpServerResponse` | HttpServerResponse.`writeCustomFrame(int type, int flags, Buffer payload)` Write an HTTP/2 frame to the response, allowing to extend the HTTP/2 protocol.
    `HttpClientRequest` | HttpClientRequest.`writeCustomFrame(int type, int flags, Buffer payload)` Write an HTTP/2 frame to the request, allowing to extend the HTTP/2 protocol.
    `ServerWebSocket` | ServerWebSocket.`writeFinalBinaryFrame(Buffer data)`
    `WebSocket` | WebSocket.`writeFinalBinaryFrame(Buffer data)`
    `WebSocketBase` | WebSocketBase.`writeFinalBinaryFrame(Buffer data)` Same as `WebSocketBase.writeFinalBinaryFrame(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `ServerWebSocket` | ServerWebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocket` | WebSocket.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)`
    `WebSocketBase` | WebSocketBase.`writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalBinaryFrame(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the operation completes
    `WebSocketBase` | ServerWebSocket.`writePing(Buffer data)` Writes a ping frame to the connection.
    `WebSocketBase` | WebSocket.`writePing(Buffer data)` Writes a ping frame to the connection.
    `WebSocketBase` | WebSocketBase.`writePing(Buffer data)` Writes a ping frame to the connection.
    `WebSocketBase` | ServerWebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a ping frame to the connection.
    `WebSocketBase` | WebSocket.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a ping frame to the connection.
    `WebSocketBase` | WebSocketBase.`writePing(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a ping frame to the connection.
    `WebSocketBase` | ServerWebSocket.`writePong(Buffer data)` Writes a pong frame to the connection.
    `WebSocketBase` | WebSocket.`writePong(Buffer data)` Writes a pong frame to the connection.
    `WebSocketBase` | WebSocketBase.`writePong(Buffer data)` Writes a pong frame to the connection.
    `WebSocketBase` | ServerWebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a pong frame to the connection.
    `WebSocketBase` | WebSocket.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a pong frame to the connection.
    `WebSocketBase` | WebSocketBase.`writePong(Buffer data, Handler<AsyncResult<Void>> handler)` Writes a pong frame to the connection.

    Method parameters in io.vertx.reactivex.core.http with type arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `WebSocketBase` | ServerWebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `WebSocketBase` | WebSocket.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `WebSocketBase` | WebSocketBase.`binaryMessageHandler(Handler<Buffer> handler)` Set a binary message handler on the connection.
    `HttpClientResponse` | HttpClientResponse.`body(Handler<AsyncResult<Buffer>> handler)` Same as `HttpClientResponse.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>)` but with an `handler` called when the operation completes
    `HttpServerRequest` | HttpServerRequest.`body(Handler<AsyncResult<Buffer>> handler)` Same as `HttpServerRequest.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>)` but with an `handler` called when the operation completes
    `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.
    `HttpClientResponse` | HttpClientResponse.`handler(Handler<Buffer> handler)`
    `ServerWebSocket` | ServerWebSocket.`handler(Handler<Buffer> handler)`
    `WebSocket` | WebSocket.`handler(Handler<Buffer> handler)`
    `HttpServerFileUpload` | HttpServerFileUpload.`handler(Handler<Buffer> handler)`
    `HttpServerRequest` | HttpServerRequest.`handler(Handler<Buffer> handler)`
    `WebSocketBase` | WebSocketBase.`handler(Handler<Buffer> handler)`
    `HttpConnection` | HttpConnection.`ping(Buffer data, Handler<AsyncResult<Buffer>> pongHandler)` Send a frame to the remote endpoint.
    `HttpConnection` | HttpConnection.`pingHandler(Handler<Buffer> handler)` Set an handler notified when a frame is received from the remote endpoint.
    `void` | HttpClientResponse.`pipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | ServerWebSocket.`pipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocket.`pipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerFileUpload.`pipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerRequest.`pipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocketBase.`pipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpClientResponse.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | ServerWebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerFileUpload.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | HttpServerRequest.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | WebSocketBase.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `WebSocketBase` | ServerWebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `WebSocketBase` | WebSocket.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `WebSocketBase` | WebSocketBase.`pongHandler(Handler<Buffer> handler)` Set a pong frame handler on the connection.
    `void` | HttpClient.`post(int port, String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, MultiMap headers, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(int port, String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(RequestOptions options, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`post(RequestOptions options, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`post(RequestOptions options, Observable<Buffer> body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`post(RequestOptions options, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`post(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`post(RequestOptions options, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, MultiMap headers, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, MultiMap headers, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`post(String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, MultiMap headers, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(int port, String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(RequestOptions options, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`put(RequestOptions options, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`put(RequestOptions options, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`put(RequestOptions options, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`put(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`put(RequestOptions options, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, MultiMap headers, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, MultiMap headers, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`put(String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Completable` | HttpClientResponse.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Completable` | ServerWebSocket.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Completable` | WebSocket.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Completable` | HttpServerFileUpload.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Completable` | HttpServerRequest.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Completable` | WebSocketBase.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `Single<HttpClientResponse>` | HttpClient.`rxPost(int port, String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(int port, String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(RequestOptions options, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(RequestOptions options, Observable<Buffer> body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String requestURI, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String host, String requestURI, Observable<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPost(String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(int port, String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(int port, String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(RequestOptions options, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(RequestOptions options, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String requestURI, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String host, String requestURI, Observable<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxPut(String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, int port, String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String requestURI, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(HttpMethod method, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(RequestOptions options, Flowable<Buffer> body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(RequestOptions options, Observable<Buffer> body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `Single<HttpClientResponse>` | HttpClient.`rxSend(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, int port, String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, MultiMap headers, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the default host and port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, MultiMap headers, Flowable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, MultiMap headers, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, MultiMap headers, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, MultiMap headers, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, MultiMap headers, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, Observable<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, ReadStream<Buffer> body)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(HttpMethod method, String host, String requestURI, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive the response
    `void` | HttpClient.`send(RequestOptions options, Flowable<Buffer> body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`send(RequestOptions options, Flowable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`send(RequestOptions options, Observable<Buffer> body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`send(RequestOptions options, Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`send(RequestOptions options, ReadStream<Buffer> body)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response
    `void` | HttpClient.`send(RequestOptions options, ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> responseHandler)` Sends an HTTP request to send to the server with the specified options, specifying a response handler to receive the response

  - ### Uses of Buffer in io.vertx.reactivex.core.net

    Methods in io.vertx.reactivex.core.net that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Pipe<Buffer>` | NetSocket.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Flowable<Buffer>` | NetSocket.`toFlowable()`
    `Observable<Buffer>` | NetSocket.`toObservable()`
    `io.vertx.reactivex.WriteStreamObserver<Buffer>` | NetSocket.`toObserver()`
    `io.vertx.reactivex.WriteStreamSubscriber<Buffer>` | NetSocket.`toSubscriber()`

    Methods in io.vertx.reactivex.core.net with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `void` | NetSocket.`end(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | NetSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `Completable` | NetSocket.`rxEnd(Buffer data)` Same as but with an `handler` called when the operation completes
    `Completable` | NetSocket.`rxWrite(Buffer message)` Like `WriteStream.write(T, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the message has been written or failed to be written.
    `void` | NetSocket.`write(Buffer message)` Like `WriteStream.write(T, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the message has been written or failed to be written.
    `void` | NetSocket.`write(Buffer message, Handler<AsyncResult<Void>> handler)` Like `WriteStream.write(T, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with an `handler` called when the message has been written or failed to be written.

    Method parameters in io.vertx.reactivex.core.net with type arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `NetSocket` | NetSocket.`handler(Handler<Buffer> handler)`
    `void` | NetSocket.`pipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | NetSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Completable` | NetSocket.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of Buffer in io.vertx.reactivex.core.parsetools

    Methods in io.vertx.reactivex.core.parsetools that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | JsonEvent.`binaryValue()` Return the binary value.

    Methods in io.vertx.reactivex.core.parsetools that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Pipe<Buffer>` | RecordParser.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Flowable<Buffer>` | RecordParser.`toFlowable()`
    `Observable<Buffer>` | RecordParser.`toObservable()`

    Methods in io.vertx.reactivex.core.parsetools with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `void` | RecordParser.`delimitedMode(Buffer delim)` Flip the parser into delimited mode, and where the delimiter can be represented by the delimiter `delim`.
    `void` | RecordParser.`handle(Buffer buffer)` This method is called to provide the parser with data.
    `void` | JsonParser.`handle(Buffer event)` Something has happened, so handle it.
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim)` Create a new `RecordParser` instance, initially in delimited mode, and where the delimiter can be represented by the `Buffer` delim.
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Flowable<Buffer> stream)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but wraps the `stream`.
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Observable<Buffer> stream)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but wraps the `stream`.
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, ReadStream<Buffer> stream)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but wraps the `stream`.
    `JsonParser` | JsonParser.`write(Buffer buffer)` Handle a `Buffer`, pretty much like calling `Handler`.

    Method parameters in io.vertx.reactivex.core.parsetools with type arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `RecordParser` | RecordParser.`handler(Handler<Buffer> handler)`
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Flowable<Buffer> stream)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but wraps the `stream`.
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, Observable<Buffer> stream)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but wraps the `stream`.
    `static RecordParser` | RecordParser.`newDelimited(Buffer delim, ReadStream<Buffer> stream)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but wraps the `stream`.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Flowable<Buffer> stream)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but wraps the `stream`.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Handler<Buffer> output)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newDelimited(String delim, Observable<Buffer> stream)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but wraps the `stream`.
    `static RecordParser` | RecordParser.`newDelimited(String delim, ReadStream<Buffer> stream)` Like `RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>)` but wraps the `stream`.
    `static RecordParser` | RecordParser.`newFixed(int size, Flowable<Buffer> stream)` Like `RecordParser.newFixed(int)` but wraps the `stream`.
    `static RecordParser` | RecordParser.`newFixed(int size, Handler<Buffer> output)` Like `RecordParser.newFixed(int)` but set the `output` that will receive whole records which have been parsed.
    `static RecordParser` | RecordParser.`newFixed(int size, Observable<Buffer> stream)` Like `RecordParser.newFixed(int)` but wraps the `stream`.
    `static RecordParser` | RecordParser.`newFixed(int size, ReadStream<Buffer> stream)` Like `RecordParser.newFixed(int)` but wraps the `stream`.
    `static JsonParser` | JsonParser.`newParser(Flowable<Buffer> stream)` Create a new `JsonParser` instance.
    `static JsonParser` | JsonParser.`newParser(Observable<Buffer> stream)` Create a new `JsonParser` instance.
    `static JsonParser` | JsonParser.`newParser(ReadStream<Buffer> stream)` Create a new `JsonParser` instance.
    `void` | RecordParser.`pipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | RecordParser.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Completable` | RecordParser.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | RecordParser.`setOutput(Handler<Buffer> output)`

  - ### Uses of Buffer in io.vertx.reactivex.ext.auth.oauth2

    Methods in io.vertx.reactivex.ext.auth.oauth2 that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | OAuth2Response.`body()` Deprecated.

    Methods in io.vertx.reactivex.ext.auth.oauth2 with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `AccessToken` | AccessToken.`fetch(HttpMethod method, String resource, JsonObject headers, Buffer payload)` Fetches a JSON resource using this Access Token.
    `AccessToken` | AccessToken.`fetch(HttpMethod method, String resource, JsonObject headers, Buffer payload, Handler<AsyncResult<OAuth2Response>> callback)` Fetches a JSON resource using this Access Token.
    `Single<OAuth2Response>` | AccessToken.`rxFetch(HttpMethod method, String resource, JsonObject headers, Buffer payload)` Fetches a JSON resource using this Access Token.

  - ### Uses of Buffer in io.vertx.reactivex.ext.mail

    Methods in io.vertx.reactivex.ext.mail that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | MailAttachment.`getData()` get the data

    Methods in io.vertx.reactivex.ext.mail that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `ReadStream<Buffer>` | MailAttachment.`getStream()` Gets the data stream.

    Methods in io.vertx.reactivex.ext.mail with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `MailAttachment` | MailAttachment.`setData(Buffer data)` set the data

    Method parameters in io.vertx.reactivex.ext.mail with type arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `MailAttachment` | MailAttachment.`setStream(Flowable<Buffer> stream)` Sets the data stream.
    `MailAttachment` | MailAttachment.`setStream(Observable<Buffer> stream)` Sets the data stream.
    `MailAttachment` | MailAttachment.`setStream(ReadStream<Buffer> stream)` Sets the data stream.

  - ### Uses of Buffer in io.vertx.reactivex.ext.mongo

    Method parameters in io.vertx.reactivex.ext.mongo with type arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `MongoGridFsClient` | MongoGridFsClient.`downloadByFileName(WriteStream<Buffer> stream, String fileName)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadByFileName(WriteStream<Buffer> stream, String fileName, Handler<AsyncResult<Long>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadByFileNameWithOptions(WriteStream<Buffer> stream, String fileName, GridFsDownloadOptions options)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadByFileNameWithOptions(WriteStream<Buffer> stream, String fileName, GridFsDownloadOptions options, Handler<AsyncResult<Long>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadById(WriteStream<Buffer> stream, String id)`
    `MongoGridFsClient` | MongoGridFsClient.`downloadById(WriteStream<Buffer> stream, String id, Handler<AsyncResult<Long>> resultHandler)`
    `Single<Long>` | MongoGridFsClient.`rxDownloadByFileName(WriteStream<Buffer> stream, String fileName)`
    `Single<Long>` | MongoGridFsClient.`rxDownloadByFileNameWithOptions(WriteStream<Buffer> stream, String fileName, GridFsDownloadOptions options)`
    `Single<Long>` | MongoGridFsClient.`rxDownloadById(WriteStream<Buffer> stream, String id)`
    `Single<String>` | MongoGridFsClient.`rxUploadByFileName(Flowable<Buffer> stream, String fileName)`
    `Single<String>` | MongoGridFsClient.`rxUploadByFileName(Observable<Buffer> stream, String fileName)`
    `Single<String>` | MongoGridFsClient.`rxUploadByFileName(ReadStream<Buffer> stream, String fileName)`
    `Single<String>` | MongoGridFsClient.`rxUploadByFileNameWithOptions(Flowable<Buffer> stream, String fileName, GridFsUploadOptions options)`
    `Single<String>` | MongoGridFsClient.`rxUploadByFileNameWithOptions(Observable<Buffer> stream, String fileName, GridFsUploadOptions options)`
    `Single<String>` | MongoGridFsClient.`rxUploadByFileNameWithOptions(ReadStream<Buffer> stream, String fileName, GridFsUploadOptions options)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileName(Flowable<Buffer> stream, String fileName)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileName(Flowable<Buffer> stream, String fileName, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileName(Observable<Buffer> stream, String fileName)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileName(Observable<Buffer> stream, String fileName, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileName(ReadStream<Buffer> stream, String fileName)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileName(ReadStream<Buffer> stream, String fileName, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileNameWithOptions(Flowable<Buffer> stream, String fileName, GridFsUploadOptions options)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileNameWithOptions(Flowable<Buffer> stream, String fileName, GridFsUploadOptions options, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileNameWithOptions(Observable<Buffer> stream, String fileName, GridFsUploadOptions options)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileNameWithOptions(Observable<Buffer> stream, String fileName, GridFsUploadOptions options, Handler<AsyncResult<String>> resultHandler)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileNameWithOptions(ReadStream<Buffer> stream, String fileName, GridFsUploadOptions options)`
    `MongoGridFsClient` | MongoGridFsClient.`uploadByFileNameWithOptions(ReadStream<Buffer> stream, String fileName, GridFsUploadOptions options, Handler<AsyncResult<String>> resultHandler)`

  - ### Uses of Buffer in io.vertx.reactivex.ext.stomp

    Methods in io.vertx.reactivex.ext.stomp with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Single<Frame>` | StompClientConnection.`rxSend(Map<String,String> headers, Buffer body)` Sends a `SEND` frame to the server.
    `Single<Frame>` | StompClientConnection.`rxSend(String destination, Buffer body)` Sends a `SEND` frame to the server to the given destination.
    `Single<Frame>` | StompClientConnection.`rxSend(String destination, Map<String,String> headers, Buffer body)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(Map<String,String> headers, Buffer body)` Sends a `SEND` frame to the server.
    `StompClientConnection` | StompClientConnection.`send(Map<String,String> headers, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server.
    `StompClientConnection` | StompClientConnection.`send(String destination, Buffer body)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(String destination, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(String destination, Map<String,String> headers, Buffer body)` Sends a `SEND` frame to the server to the given destination.
    `StompClientConnection` | StompClientConnection.`send(String destination, Map<String,String> headers, Buffer body, Handler<AsyncResult<Frame>> receiptHandler)` Sends a `SEND` frame to the server to the given destination.
    `StompServerConnection` | StompServerConnection.`write(Buffer buffer)` Writes the given buffer to the socket.

  - ### Uses of Buffer in io.vertx.reactivex.ext.web

    Methods in io.vertx.reactivex.ext.web that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | RoutingContext.`getBody()`

    Methods in io.vertx.reactivex.ext.web with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Future<Void>` | RoutingContext.`end(Buffer buffer)` Shortcut to the response end.
    `void` | RoutingContext.`setBody(Buffer body)` Set the body.

  - ### Uses of Buffer in io.vertx.reactivex.ext.web.client

    Methods in io.vertx.reactivex.ext.web.client that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | HttpResponse.`bodyAsBuffer()`

    Methods in io.vertx.reactivex.ext.web.client that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `HttpRequest<Buffer>` | WebClient.`delete(int port, String host, String requestURI)` Create an HTTP DELETE request to send to the server at the specified host and port.
    `HttpRequest<Buffer>` | WebClient.`delete(String requestURI)` Create an HTTP DELETE request to send to the server at the default host and port.
    `HttpRequest<Buffer>` | WebClient.`delete(String host, String requestURI)` Create an HTTP DELETE request to send to the server at the specified host and default port.
    `HttpRequest<Buffer>` | WebClient.`deleteAbs(String absoluteURI)` Create an HTTP DELETE request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpRequest<Buffer>` | WebClient.`get(int port, String host, String requestURI)` Create an HTTP GET request to send to the server at the specified host and port.
    `HttpRequest<Buffer>` | WebClient.`get(String requestURI)` Create an HTTP GET request to send to the server at the default host and port.
    `HttpRequest<Buffer>` | WebClient.`get(String host, String requestURI)` Create an HTTP GET request to send to the server at the specified host and default port.
    `HttpRequest<Buffer>` | WebClient.`getAbs(String absoluteURI)` Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpRequest<Buffer>` | WebClient.`head(int port, String host, String requestURI)` Create an HTTP HEAD request to send to the server at the specified host and port.
    `HttpRequest<Buffer>` | WebClient.`head(String requestURI)` Create an HTTP HEAD request to send to the server at the default host and port.
    `HttpRequest<Buffer>` | WebClient.`head(String host, String requestURI)` Create an HTTP HEAD request to send to the server at the specified host and default port.
    `HttpRequest<Buffer>` | WebClient.`headAbs(String absoluteURI)` Create an HTTP HEAD request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpRequest<Buffer>` | WebClient.`patch(int port, String host, String requestURI)` Create an HTTP PATCH request to send to the server at the specified host and port.
    `HttpRequest<Buffer>` | WebClient.`patch(String requestURI)` Create an HTTP PATCH request to send to the server at the default host and port.
    `HttpRequest<Buffer>` | WebClient.`patch(String host, String requestURI)` Create an HTTP PATCH request to send to the server at the specified host and default port.
    `HttpRequest<Buffer>` | WebClient.`patchAbs(String absoluteURI)` Create an HTTP PATCH request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpRequest<Buffer>` | WebClient.`post(int port, String host, String requestURI)` Create an HTTP POST request to send to the server at the specified host and port.
    `HttpRequest<Buffer>` | WebClient.`post(String requestURI)` Create an HTTP POST request to send to the server at the default host and port.
    `HttpRequest<Buffer>` | WebClient.`post(String host, String requestURI)` Create an HTTP POST request to send to the server at the specified host and default port.
    `HttpRequest<Buffer>` | WebClient.`postAbs(String absoluteURI)` Create an HTTP POST request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpRequest<Buffer>` | WebClient.`put(int port, String host, String requestURI)` Create an HTTP PUT request to send to the server at the specified host and port.
    `HttpRequest<Buffer>` | WebClient.`put(String requestURI)` Create an HTTP PUT request to send to the server at the default host and port.
    `HttpRequest<Buffer>` | WebClient.`put(String host, String requestURI)` Create an HTTP PUT request to send to the server at the specified host and default port.
    `HttpRequest<Buffer>` | WebClient.`putAbs(String absoluteURI)` Create an HTTP PUT request to send to the server using an absolute URI, specifying a response handler to receive the response
    `HttpRequest<Buffer>` | WebClient.`request(HttpMethod method, int port, String host, String requestURI)` Create an HTTP request to send to the server at the specified host and port.
    `HttpRequest<Buffer>` | WebClient.`request(HttpMethod method, RequestOptions options)` Create an HTTP request to send to the server at the specified host and port.
    `HttpRequest<Buffer>` | WebClient.`request(HttpMethod method, SocketAddress serverAddress, int port, String host, String requestURI)` Like `WebClient.request(io.vertx.core.http.HttpMethod, int, java.lang.String, java.lang.String)` using the `serverAddress` parameter to connect to the server instead of the `port` and `host` parameters.
    `HttpRequest<Buffer>` | WebClient.`request(HttpMethod method, SocketAddress serverAddress, RequestOptions options)` Like `WebClient.request(io.vertx.core.http.HttpMethod, int, java.lang.String, java.lang.String)` using the `serverAddress` parameter to connect to the server instead of the `options` parameter.
    `HttpRequest<Buffer>` | WebClient.`request(HttpMethod method, SocketAddress serverAddress, String requestURI)` Like `WebClient.request(io.vertx.core.http.HttpMethod, int, java.lang.String, java.lang.String)` using the `serverAddress` parameter to connect to the server instead of the default port and default host.
    `HttpRequest<Buffer>` | WebClient.`request(HttpMethod method, SocketAddress serverAddress, String host, String requestURI)` Like `WebClient.request(io.vertx.core.http.HttpMethod, int, java.lang.String, java.lang.String)` using the `serverAddress` parameter to connect to the server instead of the default port and `host` parameter.
    `HttpRequest<Buffer>` | WebClient.`request(HttpMethod method, String requestURI)` Create an HTTP request to send to the server at the default host and port.
    `HttpRequest<Buffer>` | WebClient.`request(HttpMethod method, String host, String requestURI)` Create an HTTP request to send to the server at the specified host and default port.
    `HttpRequest<Buffer>` | WebClient.`requestAbs(HttpMethod method, SocketAddress serverAddress, String absoluteURI)` Like `WebClient.requestAbs(io.vertx.core.http.HttpMethod, java.lang.String)` using the `serverAddress` parameter to connect to the server instead of the `absoluteURI` parameter.
    `HttpRequest<Buffer>` | WebClient.`requestAbs(HttpMethod method, String absoluteURI)` Create an HTTP request to send to the server using an absolute URI

    Methods in io.vertx.reactivex.ext.web.client with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `HttpRequest<T>` | HttpRequest.`basicAuthentication(Buffer id, Buffer password)` Configure the request to perform basic access authentication.
    `Single<HttpResponse<T>>` | HttpRequest.`rxSendBuffer(Buffer body)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
    `void` | HttpRequest.`sendBuffer(Buffer body)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.
    `void` | HttpRequest.`sendBuffer(Buffer body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` buffer.

    Method parameters in io.vertx.reactivex.ext.web.client with type arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Single<HttpResponse<T>>` | HttpRequest.`rxSendStream(Flowable<Buffer> body)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `Single<HttpResponse<T>>` | HttpRequest.`rxSendStream(Observable<Buffer> body)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `Single<HttpResponse<T>>` | HttpRequest.`rxSendStream(ReadStream<Buffer> body)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | HttpRequest.`sendStream(Flowable<Buffer> body)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | HttpRequest.`sendStream(Flowable<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | HttpRequest.`sendStream(Observable<Buffer> body)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | HttpRequest.`sendStream(Observable<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | HttpRequest.`sendStream(ReadStream<Buffer> body)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.
    `void` | HttpRequest.`sendStream(ReadStream<Buffer> body, Handler<AsyncResult<HttpResponse<T>>> handler)` Like `HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.ext.web.client.HttpResponse<T>>>)` but with an HTTP request `body` stream.

  - ### Uses of Buffer in io.vertx.reactivex.ext.web.client.predicate

    Methods in io.vertx.reactivex.ext.web.client.predicate that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `HttpResponse<Buffer>` | ResponsePredicateResult.`response()` The which has been tested.

  - ### Uses of Buffer in io.vertx.reactivex.ext.web.codec

    Methods in io.vertx.reactivex.ext.web.codec that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `static BodyCodec<Buffer>` | BodyCodec.`buffer()`

    Method parameters in io.vertx.reactivex.ext.web.codec with type arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `static <T> BodyCodec<T>` | BodyCodec.`create(java.util.function.Function<Buffer,T> decode)` Create a codec that buffers the entire body and then apply the `decode` function and returns the result.
    `static BodyCodec<Void>` | BodyCodec.`pipe(WriteStream<Buffer> stream)` A body codec that pipes the body to a write stream.
    `static BodyCodec<Void>` | BodyCodec.`pipe(WriteStream<Buffer> stream, boolean close)` A body codec that pipes the body to a write stream.

  - ### Uses of Buffer in io.vertx.reactivex.ext.web.common.template

    Methods in io.vertx.reactivex.ext.web.common.template that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Single<Buffer>` | TemplateEngine.`rxRender(JsonObject context, String templateFileName)` Render the template.
    `Single<Buffer>` | TemplateEngine.`rxRender(Map<String,Object> context, String templateFileName)` Render the template.

    Method parameters in io.vertx.reactivex.ext.web.common.template with type arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `void` | TemplateEngine.`render(JsonObject context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.
    `void` | TemplateEngine.`render(Map<String,Object> context, String templateFileName, Handler<AsyncResult<Buffer>> handler)` Render the template.

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

    Methods in io.vertx.reactivex.ext.web.handler.sockjs that return types with arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Pipe<Buffer>` | SockJSSocket.`pipe()` Pause this stream and return a to transfer the elements of this stream to a destination .
    `Flowable<Buffer>` | SockJSSocket.`toFlowable()`
    `Observable<Buffer>` | SockJSSocket.`toObservable()`
    `io.vertx.reactivex.WriteStreamObserver<Buffer>` | SockJSSocket.`toObserver()`
    `io.vertx.reactivex.WriteStreamSubscriber<Buffer>` | SockJSSocket.`toSubscriber()`

    Methods in io.vertx.reactivex.ext.web.handler.sockjs with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `void` | SockJSSocket.`end(Buffer data)` Same as but with an `handler` called when the operation completes
    `void` | SockJSSocket.`end(Buffer data, Handler<AsyncResult<Void>> handler)` Same as but with an `handler` called when the operation completes
    `Completable` | SockJSSocket.`rxEnd(Buffer data)` Same as but with an `handler` called when the operation completes
    `Completable` | SockJSSocket.`rxWrite(Buffer data)`
    `void` | SockJSSocket.`write(Buffer data)`
    `void` | SockJSSocket.`write(Buffer data, Handler<AsyncResult<Void>> handler)`

    Method parameters in io.vertx.reactivex.ext.web.handler.sockjs with type arguments of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `SockJSSocket` | SockJSSocket.`handler(Handler<Buffer> handler)`
    `void` | SockJSSocket.`pipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.
    `void` | SockJSSocket.`pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)` Pipe this `ReadStream` to the `WriteStream`.
    `Completable` | SockJSSocket.`rxPipeTo(WriteStream<Buffer> dst)` Pipe this `ReadStream` to the `WriteStream`.

  - ### Uses of Buffer in io.vertx.reactivex.ext.web.validation

    Methods in io.vertx.reactivex.ext.web.validation that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | RequestParameter.`getBuffer()`

  - ### Uses of Buffer in io.vertx.reactivex.kafka.client.producer

    Methods in io.vertx.reactivex.kafka.client.producer that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | KafkaHeader.`value()`

    Methods in io.vertx.reactivex.kafka.client.producer with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `KafkaProducerRecord<K,V>` | KafkaProducerRecord.`addHeader(String key, Buffer value)` Like `KafkaProducerRecord.addHeader(java.lang.String, java.lang.String)` but with a key/value pair
    `static KafkaHeader` | KafkaHeader.`header(String key, Buffer value)`

  - ### Uses of Buffer in io.vertx.reactivex.mqtt

    Methods in io.vertx.reactivex.mqtt with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `MqttClient` | MqttClient.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain)` Sends the PUBLISH message to the remote MQTT server
    `MqttClient` | MqttClient.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `MqttEndpoint` | MqttEndpoint.`publish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, Handler<AsyncResult<Integer>> publishSentHandler)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
    `Single<Integer>` | MqttClient.`rxPublish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain)` Sends the PUBLISH message to the remote MQTT server
    `Single<Integer>` | MqttEndpoint.`rxPublish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain)` Sends the PUBLISH message to the remote MQTT server
    `Single<Integer>` | MqttEndpoint.`rxPublish(String topic, Buffer payload, io.netty.handler.codec.mqtt.MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId)` Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId

  - ### Uses of Buffer in io.vertx.reactivex.mqtt.messages

    Methods in io.vertx.reactivex.mqtt.messages that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | MqttPublishMessage.`payload()`

  - ### Uses of Buffer in io.vertx.reactivex.rabbitmq

    Methods in io.vertx.reactivex.rabbitmq that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | RabbitMQMessage.`body()`

    Methods in io.vertx.reactivex.rabbitmq with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)` Publish a message.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, Buffer body)` Publish a message.
    `void` | RabbitMQClient.`basicPublish(String exchange, String routingKey, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` Publish a message.
    `void` | RabbitMQClient.`basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `void` | RabbitMQPublisher.`publish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)` Publish a message.
    `void` | RabbitMQPublisher.`publish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Void>> resultHandler)` Publish a message.
    `Completable` | RabbitMQClient.`rxBasicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)` Publish a message.
    `Completable` | RabbitMQClient.`rxBasicPublish(String exchange, String routingKey, Buffer body)` Publish a message.
    `Completable` | RabbitMQClient.`rxBasicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler)` Publish a message.
    `Completable` | RabbitMQPublisher.`rxPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body)` Publish a message.

  - ### Uses of Buffer in io.vertx.reactivex.redis.client

    Methods in io.vertx.reactivex.redis.client that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | Response.`toBuffer()` Get this response as Buffer.

    Methods in io.vertx.reactivex.redis.client with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Request` | Request.`arg(Buffer arg)` Adds a String key argument

  - ### Uses of Buffer in io.vertx.reactivex.sqlclient

    Methods in io.vertx.reactivex.sqlclient that return Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Buffer` | Tuple.`getBuffer(int pos)` Get a buffer value at `pos`.
    `Buffer` | Row.`getBuffer(String name)` Get a buffer value at `pos`.

    Methods in io.vertx.reactivex.sqlclient with parameters of type Buffer
    Modifier and Type | Method and Description
    --- | ---
    `Tuple` | Tuple.`addBuffer(Buffer value)` Add a buffer value at the end of the tuple.

Copyright © 2020 Eclipse. All rights reserved.