Uses of Class
io.vertx.rxjava.core.buffer.Buffer

Packages that use Buffer

Package	Description
io.vertx.rxjava.amqp
io.vertx.rxjava.core
io.vertx.rxjava.core.buffer
io.vertx.rxjava.core.datagram
io.vertx.rxjava.core.file
io.vertx.rxjava.core.http
io.vertx.rxjava.core.net
io.vertx.rxjava.core.parsetools
io.vertx.rxjava.ext.mail
io.vertx.rxjava.ext.mongo
io.vertx.rxjava.ext.stomp
io.vertx.rxjava.ext.web
io.vertx.rxjava.ext.web.client
io.vertx.rxjava.ext.web.client.predicate
io.vertx.rxjava.ext.web.codec
io.vertx.rxjava.ext.web.common.template
io.vertx.rxjava.ext.web.handler.sockjs
io.vertx.rxjava.ext.web.multipart
io.vertx.rxjava.ext.web.validation
io.vertx.rxjava.grpc.client
io.vertx.rxjava.grpc.common
io.vertx.rxjava.grpc.server
io.vertx.rxjava.kafka.client.producer
io.vertx.rxjava.mqtt
io.vertx.rxjava.mqtt.messages
io.vertx.rxjava.rabbitmq
io.vertx.rxjava.redis.client
io.vertx.rxjava.sqlclient

Uses of Buffer in io.vertx.rxjava.amqp

Methods in io.vertx.rxjava.amqp that return Buffer

Modifier and Type	Method and Description
Buffer	AmqpMessage.bodyAsBinary()

Methods in io.vertx.rxjava.amqp with parameters of type Buffer

Modifier and Type	Method and Description
AmqpMessageBuilder	AmqpMessageBuilder.withBufferAsBody(Buffer buffer)

Uses of Buffer in io.vertx.rxjava.core

Methods in io.vertx.rxjava.core that return types with arguments of type Buffer

Modifier and Type

Method and Description

static <T> Observable.Operator<T,Buffer>

RxHelper.unmarshaller(Class<T> mappedType) Returns a json unmarshaller for the specified java type as a Observable.Operator instance. The marshaller can be used with the Observable.lift(rx.Observable.Operator) method to transform a Observable<Buffer> into a Observable<T>. The unmarshaller buffers the content until onComplete is called, then unmarshalling happens. Note that the returned observable will emit at most a single object.

Uses of Buffer in io.vertx.rxjava.core.buffer

Fields in io.vertx.rxjava.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.rxjava.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(ByteBuf byteBuf) Deprecated.
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.rxjava.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.rxjava.core.datagram

Methods in io.vertx.rxjava.core.datagram that return Buffer

Modifier and Type	Method and Description
Buffer	DatagramPacket.data() Returns the data of the DatagramPacket

Methods in io.vertx.rxjava.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.rxjava.core.datagram with parameters of type Buffer

Modifier and Type	Method and Description
Single<Void>	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.rxjava.core.file

Methods in io.vertx.rxjava.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.rxjava.core.buffer.Buffer>>)

Methods in io.vertx.rxjava.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.
Observable<Buffer>	AsyncFile.toObservable()
WriteStreamSubscriber<Buffer>	AsyncFile.toSubscriber()

Methods in io.vertx.rxjava.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.
Single<Void>	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.
Single<Void>	AsyncFile.rxWrite(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	AsyncFile.rxWrite(Buffer buffer, long position) Write a Buffer to the file at position position in the file, asynchronously.
Single<Void>	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.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)

Method parameters in io.vertx.rxjava.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.
Single<Void>	AsyncFile.rxPipeTo(WriteStream<Buffer> dst) Pipe this ReadStream to the WriteStream.

Uses of Buffer in io.vertx.rxjava.core.http

Methods in io.vertx.rxjava.core.http that return Buffer

Modifier and Type	Method and Description
Buffer	WebSocketFrame.binaryData()
Buffer	HttpFrame.payload()

Methods in io.vertx.rxjava.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>	ClientWebSocket.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.rxjava.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.
Observable<Buffer>	HttpClientResponse.toObservable()
Observable<Buffer>	ServerWebSocket.toObservable()
Observable<Buffer>	WebSocket.toObservable()
Observable<Buffer>	HttpServerFileUpload.toObservable()
Observable<Buffer>	HttpServerRequest.toObservable()
Observable<Buffer>	ClientWebSocket.toObservable()
WriteStreamSubscriber<Buffer>	HttpServerResponse.toSubscriber()
WriteStreamSubscriber<Buffer>	ServerWebSocket.toSubscriber()
WriteStreamSubscriber<Buffer>	HttpClientRequest.toSubscriber()
WriteStreamSubscriber<Buffer>	WebSocket.toSubscriber()
WriteStreamSubscriber<Buffer>	ClientWebSocket.toSubscriber()

Methods in io.vertx.rxjava.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	ClientWebSocket.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	ClientWebSocket.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.
Single<Void>	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
Single<Void>	ServerWebSocket.rxEnd(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	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
Single<Void>	WebSocket.rxEnd(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	ClientWebSocket.rxEnd(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	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<Void>	HttpServerResponse.rxSend(Buffer body) Send the request with a buffer body.
Single<HttpClientResponse>	HttpClientRequest.rxSend(Buffer body) Send the request with a buffer body.
Single<Void>	HttpServerResponse.rxWrite(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	ServerWebSocket.rxWrite(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	HttpClientRequest.rxWrite(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	WebSocket.rxWrite(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	ClientWebSocket.rxWrite(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	WebSocketBase.rxWrite(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	ServerWebSocket.rxWriteBinaryMessage(Buffer data)
Single<Void>	WebSocket.rxWriteBinaryMessage(Buffer data)
Single<Void>	ClientWebSocket.rxWriteBinaryMessage(Buffer data)
Single<Void>	WebSocketBase.rxWriteBinaryMessage(Buffer data) Same as WebSocketBase.writeBinaryMessage(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes
Single<Void>	ServerWebSocket.rxWriteFinalBinaryFrame(Buffer data)
Single<Void>	WebSocket.rxWriteFinalBinaryFrame(Buffer data)
Single<Void>	ClientWebSocket.rxWriteFinalBinaryFrame(Buffer data)
Single<Void>	WebSocketBase.rxWriteFinalBinaryFrame(Buffer data) Same as WebSocketBase.writeFinalBinaryFrame(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes
Single<Void>	ServerWebSocket.rxWritePing(Buffer data)
Single<Void>	WebSocket.rxWritePing(Buffer data)
Single<Void>	ClientWebSocket.rxWritePing(Buffer data)
Single<Void>	WebSocketBase.rxWritePing(Buffer data) Writes a ping frame to the connection.
Single<Void>	ServerWebSocket.rxWritePong(Buffer data)
Single<Void>	WebSocket.rxWritePong(Buffer data)
Single<Void>	ClientWebSocket.rxWritePong(Buffer data)
Single<Void>	WebSocketBase.rxWritePong(Buffer data) Writes a pong frame to the connection.
void	HttpServerResponse.send(Buffer body) Send the request with a buffer body.
void	HttpClientRequest.send(Buffer body) Send the request with a buffer body.
void	HttpClientRequest.send(Buffer body, Handler<AsyncResult<HttpClientResponse>> handler) Send the request with a buffer body.
void	HttpServerResponse.send(Buffer body, Handler<AsyncResult<Void>> handler) Send the request with a buffer body.
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	ClientWebSocket.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	ClientWebSocket.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)
ClientWebSocket	ClientWebSocket.writeBinaryMessage(Buffer data)
WebSocketBase	WebSocketBase.writeBinaryMessage(Buffer data) Same as WebSocketBase.writeBinaryMessage(io.vertx.rxjava.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)
ClientWebSocket	ClientWebSocket.writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)
WebSocketBase	WebSocketBase.writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler) Same as WebSocketBase.writeBinaryMessage(io.vertx.rxjava.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)
ClientWebSocket	ClientWebSocket.writeFinalBinaryFrame(Buffer data)
WebSocketBase	WebSocketBase.writeFinalBinaryFrame(Buffer data) Same as WebSocketBase.writeFinalBinaryFrame(io.vertx.rxjava.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)
ClientWebSocket	ClientWebSocket.writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)
WebSocketBase	WebSocketBase.writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler) Same as WebSocketBase.writeFinalBinaryFrame(io.vertx.rxjava.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.writePing(Buffer data)
WebSocket	WebSocket.writePing(Buffer data)
ClientWebSocket	ClientWebSocket.writePing(Buffer data)
WebSocketBase	WebSocketBase.writePing(Buffer data) Writes a ping frame to the connection.
ServerWebSocket	ServerWebSocket.writePing(Buffer data, Handler<AsyncResult<Void>> handler)
WebSocket	WebSocket.writePing(Buffer data, Handler<AsyncResult<Void>> handler)
ClientWebSocket	ClientWebSocket.writePing(Buffer data, Handler<AsyncResult<Void>> handler)
WebSocketBase	WebSocketBase.writePing(Buffer data, Handler<AsyncResult<Void>> handler) Writes a ping frame to the connection.
ServerWebSocket	ServerWebSocket.writePong(Buffer data)
WebSocket	WebSocket.writePong(Buffer data)
ClientWebSocket	ClientWebSocket.writePong(Buffer data)
WebSocketBase	WebSocketBase.writePong(Buffer data) Writes a pong frame to the connection.
ServerWebSocket	ServerWebSocket.writePong(Buffer data, Handler<AsyncResult<Void>> handler)
WebSocket	WebSocket.writePong(Buffer data, Handler<AsyncResult<Void>> handler)
ClientWebSocket	ClientWebSocket.writePong(Buffer data, Handler<AsyncResult<Void>> handler)
WebSocketBase	WebSocketBase.writePong(Buffer data, Handler<AsyncResult<Void>> handler) Writes a pong frame to the connection.

Method parameters in io.vertx.rxjava.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.
ClientWebSocket	ClientWebSocket.binaryMessageHandler(Handler<Buffer> handler)
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.rxjava.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.rxjava.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)
ClientWebSocket	ClientWebSocket.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	ClientWebSocket.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	ClientWebSocket.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.
ClientWebSocket	ClientWebSocket.pongHandler(Handler<Buffer> handler)
WebSocketBase	WebSocketBase.pongHandler(Handler<Buffer> handler) Set a pong frame handler on the connection.
Single<Void>	HttpClientResponse.rxPipeTo(WriteStream<Buffer> dst) Pipe this ReadStream to the WriteStream.
Single<Void>	ServerWebSocket.rxPipeTo(WriteStream<Buffer> dst) Pipe this ReadStream to the WriteStream.
Single<Void>	WebSocket.rxPipeTo(WriteStream<Buffer> dst) Pipe this ReadStream to the WriteStream.
Single<Void>	HttpServerFileUpload.rxPipeTo(WriteStream<Buffer> dst) Pipe this ReadStream to the WriteStream.
Single<Void>	HttpServerRequest.rxPipeTo(WriteStream<Buffer> dst) Pipe this ReadStream to the WriteStream.
Single<Void>	ClientWebSocket.rxPipeTo(WriteStream<Buffer> dst) Pipe this ReadStream to the WriteStream.
Single<Void>	WebSocketBase.rxPipeTo(WriteStream<Buffer> dst) Pipe this ReadStream to the WriteStream.
Single<Void>	HttpServerResponse.rxSend(Observable<Buffer> body) Send the request with a stream body.
Single<HttpClientResponse>	HttpClientRequest.rxSend(Observable<Buffer> body) Send the request with a stream body.
Single<Void>	HttpServerResponse.rxSend(ReadStream<Buffer> body) Send the request with a stream body.
Single<HttpClientResponse>	HttpClientRequest.rxSend(ReadStream<Buffer> body) Send the request with a stream body.
void	HttpServerResponse.send(Observable<Buffer> body) Send the request with a stream body.
void	HttpClientRequest.send(Observable<Buffer> body) Send the request with a stream body.
void	HttpClientRequest.send(Observable<Buffer> body, Handler<AsyncResult<HttpClientResponse>> handler) Send the request with a stream body.
void	HttpServerResponse.send(Observable<Buffer> body, Handler<AsyncResult<Void>> handler) Send the request with a stream body.
void	HttpServerResponse.send(ReadStream<Buffer> body) Send the request with a stream body.
void	HttpClientRequest.send(ReadStream<Buffer> body) Send the request with a stream body.
void	HttpClientRequest.send(ReadStream<Buffer> body, Handler<AsyncResult<HttpClientResponse>> handler) Send the request with a stream body.
void	HttpServerResponse.send(ReadStream<Buffer> body, Handler<AsyncResult<Void>> handler) Send the request with a stream body.

Uses of Buffer in io.vertx.rxjava.core.net

Methods in io.vertx.rxjava.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 .
Observable<Buffer>	NetSocket.toObservable()
WriteStreamSubscriber<Buffer>	NetSocket.toSubscriber()

Methods in io.vertx.rxjava.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
Single<Void>	NetSocket.rxEnd(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	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.rxjava.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.
Single<Void>	NetSocket.rxPipeTo(WriteStream<Buffer> dst) Pipe this ReadStream to the WriteStream.

Uses of Buffer in io.vertx.rxjava.core.parsetools

Methods in io.vertx.rxjava.core.parsetools that return Buffer

Modifier and Type	Method and Description
Buffer	JsonEvent.binaryValue() Return the binary value.

Methods in io.vertx.rxjava.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 .
Observable<Buffer>	RecordParser.toObservable()

Methods in io.vertx.rxjava.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, Handler<Buffer> output) Like RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava.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.rxjava.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.rxjava.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.rxjava.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, Handler<Buffer> output) Like RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava.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.rxjava.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.rxjava.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.rxjava.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.rxjava.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.rxjava.core.buffer.Buffer>) 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(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.
Single<Void>	RecordParser.rxPipeTo(WriteStream<Buffer> dst) Pipe this ReadStream to the WriteStream.
void	RecordParser.setOutput(Handler<Buffer> output)

Uses of Buffer in io.vertx.rxjava.ext.mail

Methods in io.vertx.rxjava.ext.mail that return Buffer

Modifier and Type	Method and Description
Buffer	MailAttachment.getData() get the data

Methods in io.vertx.rxjava.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.rxjava.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.rxjava.ext.mail with type arguments of type Buffer

Modifier and Type	Method and Description
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.rxjava.ext.mongo

Methods in io.vertx.rxjava.ext.mongo that return types with arguments of type Buffer

Modifier and Type	Method and Description
ReadStream<Buffer>	MongoGridFsClient.readByFileName(String fileName) Read file by name to ReadStream
ReadStream<Buffer>	MongoGridFsClient.readByFileNameWithOptions(String fileName, GridFsDownloadOptions options) Read file by name to ReadStream with options
ReadStream<Buffer>	MongoGridFsClient.readById(String id) Read file by id to ReadStream

Method parameters in io.vertx.rxjava.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(Observable<Buffer> stream, String fileName)
Single<String>	MongoGridFsClient.rxUploadByFileName(ReadStream<Buffer> stream, String fileName)
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(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(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.rxjava.ext.stomp

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

Methods in io.vertx.rxjava.ext.web that return Buffer

Modifier and Type	Method and Description
Buffer	RequestBody.buffer()
Buffer	RoutingContext.getBody() Deprecated.

Methods in io.vertx.rxjava.ext.web with parameters of type Buffer

Modifier and Type	Method and Description
RoutingContext	RoutingContext.end(Buffer buffer) See RoutingContext.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
RoutingContext	RoutingContext.end(Buffer buffer, Handler<AsyncResult<Void>> handler) See RoutingContext.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
Single<Void>	RoutingContext.rxEnd(Buffer buffer) See RoutingContext.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)
void	RoutingContext.setBody(Buffer body) Deprecated.

Uses of Buffer in io.vertx.rxjava.ext.web.client

Methods in io.vertx.rxjava.ext.web.client that return Buffer

Modifier and Type	Method and Description
Buffer	HttpResponse.bodyAsBuffer()

Methods in io.vertx.rxjava.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(int port, String host, UriTemplate 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.delete(String host, UriTemplate requestURI) Create an HTTP DELETE request to send to the server at the specified host and default port.
HttpRequest<Buffer>	WebClient.delete(UriTemplate requestURI) Create an HTTP DELETE request to send to the server at the default host and 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.deleteAbs(UriTemplate 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(int port, String host, UriTemplate 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.get(String host, UriTemplate requestURI) Create an HTTP GET request to send to the server at the specified host and default port.
HttpRequest<Buffer>	WebClient.get(UriTemplate requestURI) Create an HTTP GET request to send to the server at the default host and 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.getAbs(UriTemplate 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(int port, String host, UriTemplate 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.head(String host, UriTemplate requestURI) Create an HTTP HEAD request to send to the server at the specified host and default port.
HttpRequest<Buffer>	WebClient.head(UriTemplate requestURI) Create an HTTP HEAD request to send to the server at the default host and 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.headAbs(UriTemplate 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(int port, String host, UriTemplate 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.patch(String host, UriTemplate requestURI) Create an HTTP PATCH request to send to the server at the specified host and default port.
HttpRequest<Buffer>	WebClient.patch(UriTemplate requestURI) Create an HTTP PATCH request to send to the server at the default host and 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.patchAbs(UriTemplate 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(int port, String host, UriTemplate 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.post(String host, UriTemplate requestURI) Create an HTTP POST request to send to the server at the specified host and default port.
HttpRequest<Buffer>	WebClient.post(UriTemplate requestURI) Create an HTTP POST request to send to the server at the default host and 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.postAbs(UriTemplate 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(int port, String host, UriTemplate 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.put(String host, UriTemplate requestURI) Create an HTTP PUT request to send to the server at the specified host and default port.
HttpRequest<Buffer>	WebClient.put(UriTemplate requestURI) Create an HTTP PUT request to send to the server at the default host and 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.putAbs(UriTemplate 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, int port, String host, UriTemplate 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, int port, String host, UriTemplate 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, SocketAddress serverAddress, String host, UriTemplate 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, SocketAddress serverAddress, UriTemplate 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, 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.request(HttpMethod method, String host, UriTemplate requestURI) Create an HTTP request to send to the server at the specified host and default port.
HttpRequest<Buffer>	WebClient.request(HttpMethod method, UriTemplate requestURI) Create an HTTP request to send to the server at the default host and 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, SocketAddress serverAddress, UriTemplate 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
HttpRequest<Buffer>	WebClient.requestAbs(HttpMethod method, UriTemplate absoluteURI) Create an HTTP request to send to the server using an absolute URI

Methods in io.vertx.rxjava.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.rxjava.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.rxjava.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.rxjava.ext.web.client.HttpResponse<T>>>) but with an HTTP request body buffer.

Method parameters in io.vertx.rxjava.ext.web.client with type arguments of type Buffer

Modifier and Type	Method and Description
Single<HttpResponse<T>>	HttpRequest.rxSendStream(Observable<Buffer> body) Like HttpRequest.send(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.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.rxjava.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.rxjava.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.rxjava.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.rxjava.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.rxjava.ext.web.client.HttpResponse<T>>>) but with an HTTP request body stream.

Uses of Buffer in io.vertx.rxjava.ext.web.client.predicate

Methods in io.vertx.rxjava.ext.web.client.predicate that return types with arguments of type Buffer

Modifier and Type	Method and Description
HttpResponse<Buffer>	ResponsePredicateResult.response() Deprecated.

Uses of Buffer in io.vertx.rxjava.ext.web.codec

Methods in io.vertx.rxjava.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.rxjava.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.rxjava.ext.web.common.template

Methods in io.vertx.rxjava.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.rxjava.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.rxjava.ext.web.handler.sockjs

Methods in io.vertx.rxjava.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 .
Observable<Buffer>	SockJSSocket.toObservable()
WriteStreamSubscriber<Buffer>	SockJSSocket.toSubscriber()

Methods in io.vertx.rxjava.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
Single<Void>	SockJSSocket.rxEnd(Buffer data) Same as but with an handler called when the operation completes
Single<Void>	SockJSSocket.rxWrite(Buffer data)
void	SockJSSocket.write(Buffer data)
void	SockJSSocket.write(Buffer data, Handler<AsyncResult<Void>> handler)

Method parameters in io.vertx.rxjava.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.
Single<Void>	SockJSSocket.rxPipeTo(WriteStream<Buffer> dst) Pipe this ReadStream to the WriteStream.

Uses of Buffer in io.vertx.rxjava.ext.web.multipart

Methods in io.vertx.rxjava.ext.web.multipart that return Buffer

Modifier and Type	Method and Description
Buffer	FormDataPart.content()

Methods in io.vertx.rxjava.ext.web.multipart with parameters of type Buffer

Modifier and Type	Method and Description
MultipartForm	MultipartForm.binaryFileUpload(String name, String filename, Buffer content, String mediaType) Add a binary file upload form data part.
MultipartForm	MultipartForm.textFileUpload(String name, String filename, Buffer content, String mediaType) Add a text file upload form data part.

Uses of Buffer in io.vertx.rxjava.ext.web.validation

Methods in io.vertx.rxjava.ext.web.validation that return Buffer

Modifier and Type	Method and Description
Buffer	RequestParameter.getBuffer()

Uses of Buffer in io.vertx.rxjava.grpc.client

Methods in io.vertx.rxjava.grpc.client that return types with arguments of type Buffer

Modifier and Type	Method and Description
Future<GrpcClientRequest<Buffer,Buffer>>	GrpcClient.request(SocketAddress server) Connect to the remote server and create a request for any hosted gRPC service.
Future<GrpcClientRequest<Buffer,Buffer>>	GrpcClient.request(SocketAddress server) Connect to the remote server and create a request for any hosted gRPC service.
Single<GrpcClientRequest<Buffer,Buffer>>	GrpcClient.rxRequest(SocketAddress server) Connect to the remote server and create a request for any hosted gRPC service.
Single<GrpcClientRequest<Buffer,Buffer>>	GrpcClient.rxRequest(SocketAddress server) Connect to the remote server and create a request for any hosted gRPC service.

Uses of Buffer in io.vertx.rxjava.grpc.common

Fields in io.vertx.rxjava.grpc.common with type parameters of type Buffer

Modifier and Type	Field and Description
static GrpcMessageDecoder<Buffer>	GrpcMessageDecoder.GZIP
static GrpcMessageEncoder<Buffer>	GrpcMessageEncoder.GZIP
static GrpcMessageDecoder<Buffer>	GrpcMessageDecoder.IDENTITY
static GrpcMessageEncoder<Buffer>	GrpcMessageEncoder.IDENTITY

Methods in io.vertx.rxjava.grpc.common that return Buffer

Modifier and Type	Method and Description
Buffer	GrpcMessage.payload()

Methods in io.vertx.rxjava.grpc.common with parameters of type Buffer

Modifier and Type	Method and Description
static GrpcMessage	GrpcMessage.message(String encoding, Buffer payload)

Uses of Buffer in io.vertx.rxjava.grpc.server

Method parameters in io.vertx.rxjava.grpc.server with type arguments of type Buffer

Modifier and Type	Method and Description
GrpcServer	GrpcServer.callHandler(Handler<GrpcServerRequest<Buffer,Buffer>> handler) Set a call handler that handles any call made to the server.
GrpcServer	GrpcServer.callHandler(Handler<GrpcServerRequest<Buffer,Buffer>> handler) Set a call handler that handles any call made to the server.

Uses of Buffer in io.vertx.rxjava.kafka.client.producer

Methods in io.vertx.rxjava.kafka.client.producer that return Buffer

Modifier and Type	Method and Description
Buffer	KafkaHeader.value()

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

Methods in io.vertx.rxjava.mqtt with parameters of type Buffer

Modifier and Type	Method and Description
MqttClient	MqttClient.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain) Sends the PUBLISH message to the remote MQTT server
MqttEndpoint	MqttEndpoint.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain) Sends the PUBLISH message to the remote MQTT server
MqttClient	MqttClient.publish(String topic, Buffer payload, 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, 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, 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, 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
MqttEndpoint	MqttEndpoint.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, MqttProperties properties) Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
MqttEndpoint	MqttEndpoint.publish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, MqttProperties properties, 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, MqttQoS qosLevel, boolean isDup, boolean isRetain) Sends the PUBLISH message to the remote MQTT server
Single<Integer>	MqttEndpoint.rxPublish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain) Sends the PUBLISH message to the remote MQTT server
Single<Integer>	MqttEndpoint.rxPublish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId) Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
Single<Integer>	MqttEndpoint.rxPublish(String topic, Buffer payload, MqttQoS qosLevel, boolean isDup, boolean isRetain, int messageId, MqttProperties properties) Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId

Uses of Buffer in io.vertx.rxjava.mqtt.messages

Methods in io.vertx.rxjava.mqtt.messages that return Buffer

Modifier and Type	Method and Description
Buffer	MqttPublishMessage.payload()

Uses of Buffer in io.vertx.rxjava.rabbitmq

Methods in io.vertx.rxjava.rabbitmq that return Buffer

Modifier and Type	Method and Description
Buffer	RabbitMQMessage.body()

Methods in io.vertx.rxjava.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.
void	RabbitMQPublisher.publishConfirm(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body) Publish a message and complete when publish confirm has returned.
void	RabbitMQPublisher.publishConfirm(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<AsyncResult<Long>> resultHandler) Publish a message and complete when publish confirm has returned.
Single<Void>	RabbitMQClient.rxBasicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body) Publish a message.
Single<Void>	RabbitMQClient.rxBasicPublish(String exchange, String routingKey, Buffer body) Publish a message.
Single<Void>	RabbitMQClient.rxBasicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body, Handler<Long> deliveryTagHandler) Publish a message.
Single<Void>	RabbitMQPublisher.rxPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body) Publish a message.
Single<Long>	RabbitMQPublisher.rxPublishConfirm(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, Buffer body) Publish a message and complete when publish confirm has returned.

Uses of Buffer in io.vertx.rxjava.redis.client

Methods in io.vertx.rxjava.redis.client that return Buffer

Modifier and Type	Method and Description
Buffer	Response.toBuffer() Get this response as Buffer.

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

Methods in io.vertx.rxjava.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 column) Get a buffer value for the given column.

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