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

Packages that use Buffer

Package	Description
io.vertx.mutiny.core.buffer
io.vertx.mutiny.core.datagram
io.vertx.mutiny.core.file
io.vertx.mutiny.core.http
io.vertx.mutiny.core.net
io.vertx.mutiny.core.parsetools

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

Fields in io.vertx.mutiny.core.buffer with type parameters of type Buffer

Modifier and Type	Field	Description
static final io.smallrye.mutiny.vertx.TypeArg<Buffer>	Buffer.__TYPE_ARG

Methods in io.vertx.mutiny.core.buffer that return Buffer

Modifier and Type	Method	Description
Buffer	Buffer.appendBuffer(Buffer buff)
Buffer	Buffer.appendBuffer(Buffer buff, int offset, int len)
Buffer	Buffer.appendByte(byte b)
Buffer	Buffer.appendBytes(byte[] bytes)
Buffer	Buffer.appendBytes(byte[] bytes, int offset, int len)
Buffer	Buffer.appendDouble(double d)
Buffer	Buffer.appendFloat(float f)
Buffer	Buffer.appendInt(int i)
Buffer	Buffer.appendIntLE(int i)
Buffer	Buffer.appendLong(long l)
Buffer	Buffer.appendLongLE(long l)
Buffer	Buffer.appendMedium(int i)
Buffer	Buffer.appendMediumLE(int i)
Buffer	Buffer.appendShort(short s)
Buffer	Buffer.appendShortLE(short s)
Buffer	Buffer.appendString(String str)
Buffer	Buffer.appendString(String str, String enc)
Buffer	Buffer.appendUnsignedByte(short b)
Buffer	Buffer.appendUnsignedInt(long i)
Buffer	Buffer.appendUnsignedIntLE(long i)
Buffer	Buffer.appendUnsignedShort(int s)
Buffer	Buffer.appendUnsignedShortLE(int s)
static Buffer	Buffer.buffer()
static Buffer	Buffer.buffer(byte[] bytes)
static Buffer	Buffer.buffer(int initialSizeHint)
static Buffer	Buffer.buffer(io.netty.buffer.ByteBuf byteBuf)	Deprecated. removed from public API in Vert.x 5
static Buffer	Buffer.buffer(String string)
static Buffer	Buffer.buffer(String string, String enc)
Buffer	Buffer.copy()
Buffer	Buffer.getBuffer(int start, int end)
Buffer	Buffer.getBytes(byte[] dst)
Buffer	Buffer.getBytes(byte[] dst, int dstIndex)
Buffer	Buffer.getBytes(int start, int end, byte[] dst)
Buffer	Buffer.getBytes(int start, int end, byte[] dst, int dstIndex)
static Buffer	Buffer.newInstance(io.vertx.core.buffer.Buffer arg)
Buffer	Buffer.setBuffer(int pos, Buffer b)
Buffer	Buffer.setBuffer(int pos, Buffer b, int offset, int len)
Buffer	Buffer.setByte(int pos, byte b)
Buffer	Buffer.setBytes(int pos, byte[] b)
Buffer	Buffer.setBytes(int pos, byte[] b, int offset, int len)
Buffer	Buffer.setBytes(int pos, ByteBuffer b)
Buffer	Buffer.setDouble(int pos, double d)
Buffer	Buffer.setFloat(int pos, float f)
Buffer	Buffer.setInt(int pos, int i)
Buffer	Buffer.setIntLE(int pos, int i)
Buffer	Buffer.setLong(int pos, long l)
Buffer	Buffer.setLongLE(int pos, long l)
Buffer	Buffer.setMedium(int pos, int i)
Buffer	Buffer.setMediumLE(int pos, int i)
Buffer	Buffer.setShort(int pos, short s)
Buffer	Buffer.setShortLE(int pos, short s)
Buffer	Buffer.setString(int pos, String str)
Buffer	Buffer.setString(int pos, String str, String enc)
Buffer	Buffer.setUnsignedByte(int pos, short b)
Buffer	Buffer.setUnsignedInt(int pos, long i)
Buffer	Buffer.setUnsignedIntLE(int pos, long i)
Buffer	Buffer.setUnsignedShort(int pos, int s)
Buffer	Buffer.setUnsignedShortLE(int pos, int s)
Buffer	Buffer.slice()
Buffer	Buffer.slice(int start, int end)

Methods in io.vertx.mutiny.core.buffer with parameters of type Buffer

Modifier and Type	Method	Description
Buffer	Buffer.appendBuffer(Buffer buff)
Buffer	Buffer.appendBuffer(Buffer buff, int offset, int len)
Buffer	Buffer.setBuffer(int pos, Buffer b)
Buffer	Buffer.setBuffer(int pos, Buffer b, int offset, int len)

Uses of Buffer in io.vertx.mutiny.core.datagram

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

Modifier and Type	Method	Description
Buffer	DatagramPacket.data()

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

Modifier and Type	Method	Description
WriteStream<Buffer>	DatagramSocket.sender(int port, String host)

Methods in io.vertx.mutiny.core.datagram with parameters of type Buffer

Modifier and Type	Method	Description
io.smallrye.mutiny.Uni<Void>	DatagramSocket.send(Buffer packet, int port, String host)	Write the given Buffer to the SocketAddress.
Void	DatagramSocket.sendAndAwait(Buffer packet, int port, String host)	Blocking variant of DatagramSocket.send(io.vertx.mutiny.core.buffer.Buffer,int,String).
DatagramSocket	DatagramSocket.sendAndForget(Buffer packet, int port, String host)	Variant of DatagramSocket.send(io.vertx.mutiny.core.buffer.Buffer,int,String) that ignores the result of the operation.

Uses of Buffer in io.vertx.mutiny.core.file

Methods in io.vertx.mutiny.core.file that return Buffer

Modifier and Type	Method	Description
Buffer	AsyncFile.readAndAwait(Buffer buffer, int offset, long position, int length)	Blocking variant of AsyncFile.read(io.vertx.mutiny.core.buffer.Buffer,int,long,int).
Buffer	FileSystem.readFileAndAwait(String path)	Blocking variant of FileSystem.readFile(String).
Buffer	FileSystem.readFileBlocking(String path)

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

Modifier and Type	Method	Description
Pipe<Buffer>	AsyncFile.pipe()
io.smallrye.mutiny.Uni<Buffer>	AsyncFile.read(Buffer buffer, int offset, long position, int length)	Reads length bytes of data from the file at position position in the file, asynchronously.
io.smallrye.mutiny.Uni<Buffer>	FileSystem.readFile(String path)	Reads the entire file as represented by the path path as a , asynchronously.
Iterable<Buffer>	AsyncFile.toBlockingIterable()
Stream<Buffer>	AsyncFile.toBlockingStream()
io.smallrye.mutiny.Multi<Buffer>	AsyncFile.toMulti()
io.smallrye.mutiny.vertx.WriteStreamSubscriber<Buffer>	AsyncFile.toSubscriber()

Methods in io.vertx.mutiny.core.file with parameters of type Buffer

Modifier and Type	Method	Description
io.smallrye.mutiny.Uni<Void>	AsyncFile.end(Buffer data)	Same as but with an handler called when the operation completes
Void	AsyncFile.endAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) .
void	AsyncFile.endAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Buffer>	AsyncFile.read(Buffer buffer, int offset, long position, int length)	Reads length bytes of data from the file at position position in the file, asynchronously.
Buffer	AsyncFile.readAndAwait(Buffer buffer, int offset, long position, int length)	Blocking variant of AsyncFile.read(io.vertx.mutiny.core.buffer.Buffer,int,long,int).
AsyncFile	AsyncFile.readAndForget(Buffer buffer, int offset, long position, int length)	Variant of AsyncFile.read(io.vertx.mutiny.core.buffer.Buffer,int,long,int) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	AsyncFile.write(Buffer data)	Same as but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	AsyncFile.write(Buffer buffer, long position)	Write a Buffer to the file at position position in the file, asynchronously.
Void	AsyncFile.writeAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) .
Void	AsyncFile.writeAndAwait(Buffer buffer, long position)	Blocking variant of AsyncFile.write(io.vertx.mutiny.core.buffer.Buffer,long).
void	AsyncFile.writeAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	AsyncFile.writeAndForget(Buffer buffer, long position)	Variant of AsyncFile.write(io.vertx.mutiny.core.buffer.Buffer,long) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	FileSystem.writeFile(String path, Buffer data)	Creates the file, and writes the specified Buffer data to the file represented by the path path, asynchronously.
Void	FileSystem.writeFileAndAwait(String path, Buffer data)	Blocking variant of FileSystem.writeFile(String,io.vertx.mutiny.core.buffer.Buffer).
FileSystem	FileSystem.writeFileAndForget(String path, Buffer data)	Variant of FileSystem.writeFile(String,io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
FileSystem	FileSystem.writeFileBlocking(String path, Buffer data)

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

Modifier and Type	Method	Description
AsyncFile	AsyncFile.handler(Consumer<Buffer> handler)
io.smallrye.mutiny.Uni<Void>	AsyncFile.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Void	AsyncFile.pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
void	AsyncFile.pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.

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

Fields in io.vertx.mutiny.core.http with type parameters of type Buffer

Modifier and Type	Field	Description
static final io.smallrye.mutiny.vertx.TypeArg<Buffer>	WebSocketBase.TYPE_ARG_0

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

Modifier and Type	Method	Description
Buffer	WebSocketFrame.binaryData()
Buffer	HttpClientResponse.bodyAndAwait()	Blocking variant of HttpClientResponse.body().
Buffer	HttpServerRequest.bodyAndAwait()	Blocking variant of HttpServerRequest.body().
Buffer	HttpFrame.payload()
Buffer	HttpConnection.pingAndAwait(Buffer data)	Blocking variant of HttpConnection.ping(io.vertx.mutiny.core.buffer.Buffer).

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

Modifier and Type	Method	Description
io.smallrye.mutiny.Uni<Buffer>	HttpClientResponse.body()	Same as HttpClientResponse.body() but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Buffer>	HttpServerRequest.body()	Same as HttpServerRequest.body() but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Buffer>	HttpConnection.ping(Buffer data)	Send a frame to the remote endpoint.
Pipe<Buffer>	ClientWebSocket.pipe()
Pipe<Buffer>	HttpClientResponse.pipe()
Pipe<Buffer>	HttpServerFileUpload.pipe()
Pipe<Buffer>	HttpServerRequest.pipe()
Pipe<Buffer>	ServerWebSocket.pipe()
Pipe<Buffer>	WebSocket.pipe()
Pipe<Buffer>	WebSocketBase.pipe()
Iterable<Buffer>	ClientWebSocket.toBlockingIterable()
Iterable<Buffer>	HttpClientResponse.toBlockingIterable()
Iterable<Buffer>	HttpServerFileUpload.toBlockingIterable()
Iterable<Buffer>	HttpServerRequest.toBlockingIterable()
Iterable<Buffer>	ServerWebSocket.toBlockingIterable()
Iterable<Buffer>	WebSocket.toBlockingIterable()
Stream<Buffer>	ClientWebSocket.toBlockingStream()
Stream<Buffer>	HttpClientResponse.toBlockingStream()
Stream<Buffer>	HttpServerFileUpload.toBlockingStream()
Stream<Buffer>	HttpServerRequest.toBlockingStream()
Stream<Buffer>	ServerWebSocket.toBlockingStream()
Stream<Buffer>	WebSocket.toBlockingStream()
io.smallrye.mutiny.Multi<Buffer>	ClientWebSocket.toMulti()
io.smallrye.mutiny.Multi<Buffer>	HttpClientResponse.toMulti()
io.smallrye.mutiny.Multi<Buffer>	HttpServerFileUpload.toMulti()
io.smallrye.mutiny.Multi<Buffer>	HttpServerRequest.toMulti()
io.smallrye.mutiny.Multi<Buffer>	ServerWebSocket.toMulti()
io.smallrye.mutiny.Multi<Buffer>	WebSocket.toMulti()
io.smallrye.mutiny.vertx.WriteStreamSubscriber<Buffer>	ClientWebSocket.toSubscriber()
io.smallrye.mutiny.vertx.WriteStreamSubscriber<Buffer>	HttpClientRequest.toSubscriber()
io.smallrye.mutiny.vertx.WriteStreamSubscriber<Buffer>	HttpServerResponse.toSubscriber()
io.smallrye.mutiny.vertx.WriteStreamSubscriber<Buffer>	ServerWebSocket.toSubscriber()
io.smallrye.mutiny.vertx.WriteStreamSubscriber<Buffer>	WebSocket.toSubscriber()

Methods in io.vertx.mutiny.core.http with parameters of type Buffer

Modifier and Type	Method	Description
static WebSocketFrame	WebSocketFrame.binaryFrame(Buffer data, boolean isFinal)
static WebSocketFrame	WebSocketFrame.continuationFrame(Buffer data, boolean isFinal)
io.smallrye.mutiny.Uni<Void>	ClientWebSocket.end(Buffer data)	Same as but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	HttpClientRequest.end(Buffer chunk)	Same as HttpClientRequest.end(java.lang.String) but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	HttpServerResponse.end(Buffer chunk)	Same as HttpServerResponse.end() but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	ServerWebSocket.end(Buffer data)	Same as but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	WebSocket.end(Buffer data)	Same as but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	WebSocketBase.end(Buffer data)	Same as but with an handler called when the operation completes
Void	ClientWebSocket.endAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) .
Void	HttpClientRequest.endAndAwait(Buffer chunk)	Blocking variant of HttpClientRequest.end(io.vertx.mutiny.core.buffer.Buffer).
Void	HttpServerResponse.endAndAwait(Buffer chunk)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) .
Void	ServerWebSocket.endAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) .
Void	WebSocket.endAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) .
Void	WebSocketBase.endAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) .
void	ClientWebSocket.endAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	HttpClientRequest.endAndForget(Buffer chunk)	Variant of HttpClientRequest.end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	HttpServerResponse.endAndForget(Buffer chunk)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	ServerWebSocket.endAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	WebSocket.endAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	WebSocketBase.endAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
HttpConnection	HttpConnection.goAway(long errorCode, int lastStreamId, Buffer debugData)
io.smallrye.mutiny.Uni<Buffer>	HttpConnection.ping(Buffer data)	Send a frame to the remote endpoint.
Buffer	HttpConnection.pingAndAwait(Buffer data)	Blocking variant of HttpConnection.ping(io.vertx.mutiny.core.buffer.Buffer).
HttpConnection	HttpConnection.pingAndForget(Buffer data)	Variant of HttpConnection.ping(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
static WebSocketFrame	WebSocketFrame.pingFrame(Buffer data)
static WebSocketFrame	WebSocketFrame.pongFrame(Buffer data)
io.smallrye.mutiny.Uni<HttpClientResponse>	HttpClientRequest.send(Buffer body)	Send the request with a buffer body.
io.smallrye.mutiny.Uni<Void>	HttpServerResponse.send(Buffer body)	Send the request with a buffer body.
HttpClientResponse	HttpClientRequest.sendAndAwait(Buffer body)	Blocking variant of HttpClientRequest.send(io.vertx.mutiny.core.buffer.Buffer).
Void	HttpServerResponse.sendAndAwait(Buffer body)	Blocking variant of HttpServerResponse.send(io.vertx.mutiny.core.buffer.Buffer).
void	HttpClientRequest.sendAndForget(Buffer body)	Variant of HttpClientRequest.send(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	HttpServerResponse.sendAndForget(Buffer body)	Variant of HttpServerResponse.send(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	ClientWebSocket.write(Buffer data)	Same as but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	HttpClientRequest.write(Buffer data)	Same as but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	HttpServerResponse.write(Buffer data)	Same as but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	ServerWebSocket.write(Buffer data)	Same as but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	WebSocket.write(Buffer data)	Same as but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	WebSocketBase.write(Buffer data)	Same as but with an handler called when the operation completes
Void	ClientWebSocket.writeAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) .
Void	HttpClientRequest.writeAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) .
Void	HttpServerResponse.writeAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) .
Void	ServerWebSocket.writeAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) .
Void	WebSocket.writeAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) .
Void	WebSocketBase.writeAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) .
void	ClientWebSocket.writeAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	HttpClientRequest.writeAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	HttpServerResponse.writeAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	ServerWebSocket.writeAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	WebSocket.writeAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	WebSocketBase.writeAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	ClientWebSocket.writeBinaryMessage(Buffer data)
io.smallrye.mutiny.Uni<Void>	ServerWebSocket.writeBinaryMessage(Buffer data)
io.smallrye.mutiny.Uni<Void>	WebSocket.writeBinaryMessage(Buffer data)
io.smallrye.mutiny.Uni<Void>	WebSocketBase.writeBinaryMessage(Buffer data)	Same as WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes
Void	ClientWebSocket.writeBinaryMessageAndAwait(Buffer data)
Void	ServerWebSocket.writeBinaryMessageAndAwait(Buffer data)
Void	WebSocket.writeBinaryMessageAndAwait(Buffer data)
Void	WebSocketBase.writeBinaryMessageAndAwait(Buffer data)	Blocking variant of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer).
ClientWebSocket	ClientWebSocket.writeBinaryMessageAndForget(Buffer data)
ServerWebSocket	ServerWebSocket.writeBinaryMessageAndForget(Buffer data)
WebSocket	WebSocket.writeBinaryMessageAndForget(Buffer data)
WebSocketBase	WebSocketBase.writeBinaryMessageAndForget(Buffer data)	Variant of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
HttpClientRequest	HttpClientRequest.writeCustomFrame(int type, int flags, Buffer payload)
HttpServerResponse	HttpServerResponse.writeCustomFrame(int type, int flags, Buffer payload)
io.smallrye.mutiny.Uni<Void>	ClientWebSocket.writeFinalBinaryFrame(Buffer data)
io.smallrye.mutiny.Uni<Void>	ServerWebSocket.writeFinalBinaryFrame(Buffer data)
io.smallrye.mutiny.Uni<Void>	WebSocket.writeFinalBinaryFrame(Buffer data)
io.smallrye.mutiny.Uni<Void>	WebSocketBase.writeFinalBinaryFrame(Buffer data)	Same as WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes
Void	ClientWebSocket.writeFinalBinaryFrameAndAwait(Buffer data)
Void	ServerWebSocket.writeFinalBinaryFrameAndAwait(Buffer data)
Void	WebSocket.writeFinalBinaryFrameAndAwait(Buffer data)
Void	WebSocketBase.writeFinalBinaryFrameAndAwait(Buffer data)	Blocking variant of WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer).
ClientWebSocket	ClientWebSocket.writeFinalBinaryFrameAndForget(Buffer data)
ServerWebSocket	ServerWebSocket.writeFinalBinaryFrameAndForget(Buffer data)
WebSocket	WebSocket.writeFinalBinaryFrameAndForget(Buffer data)
WebSocketBase	WebSocketBase.writeFinalBinaryFrameAndForget(Buffer data)	Variant of WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	ClientWebSocket.writePing(Buffer data)
io.smallrye.mutiny.Uni<Void>	ServerWebSocket.writePing(Buffer data)
io.smallrye.mutiny.Uni<Void>	WebSocket.writePing(Buffer data)
io.smallrye.mutiny.Uni<Void>	WebSocketBase.writePing(Buffer data)	Writes a ping frame to the connection.
Void	ClientWebSocket.writePingAndAwait(Buffer data)
Void	ServerWebSocket.writePingAndAwait(Buffer data)
Void	WebSocket.writePingAndAwait(Buffer data)
Void	WebSocketBase.writePingAndAwait(Buffer data)	Blocking variant of WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer).
ClientWebSocket	ClientWebSocket.writePingAndForget(Buffer data)
ServerWebSocket	ServerWebSocket.writePingAndForget(Buffer data)
WebSocket	WebSocket.writePingAndForget(Buffer data)
WebSocketBase	WebSocketBase.writePingAndForget(Buffer data)	Variant of WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	ClientWebSocket.writePong(Buffer data)
io.smallrye.mutiny.Uni<Void>	ServerWebSocket.writePong(Buffer data)
io.smallrye.mutiny.Uni<Void>	WebSocket.writePong(Buffer data)
io.smallrye.mutiny.Uni<Void>	WebSocketBase.writePong(Buffer data)	Writes a pong frame to the connection.
Void	ClientWebSocket.writePongAndAwait(Buffer data)
Void	ServerWebSocket.writePongAndAwait(Buffer data)
Void	WebSocket.writePongAndAwait(Buffer data)
Void	WebSocketBase.writePongAndAwait(Buffer data)	Blocking variant of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer).
ClientWebSocket	ClientWebSocket.writePongAndForget(Buffer data)
ServerWebSocket	ServerWebSocket.writePongAndForget(Buffer data)
WebSocket	WebSocket.writePongAndForget(Buffer data)
WebSocketBase	WebSocketBase.writePongAndForget(Buffer data)	Variant of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

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

Modifier and Type	Method	Description
ClientWebSocket	ClientWebSocket.binaryMessageHandler(Consumer<Buffer> handler)
WebSocketBase	ServerWebSocket.binaryMessageHandler(Consumer<Buffer> handler)
WebSocketBase	WebSocket.binaryMessageHandler(Consumer<Buffer> handler)
WebSocketBase	WebSocketBase.binaryMessageHandler(Consumer<Buffer> handler)
HttpClientResponse	HttpClientResponse.bodyHandler(Consumer<Buffer> bodyHandler)
HttpServerRequest	HttpServerRequest.bodyHandler(Consumer<Buffer> bodyHandler)
ClientWebSocket	ClientWebSocket.handler(Consumer<Buffer> handler)
HttpClientResponse	HttpClientResponse.handler(Consumer<Buffer> handler)
HttpServerFileUpload	HttpServerFileUpload.handler(Consumer<Buffer> handler)
HttpServerRequest	HttpServerRequest.handler(Consumer<Buffer> handler)
ServerWebSocket	ServerWebSocket.handler(Consumer<Buffer> handler)
WebSocket	WebSocket.handler(Consumer<Buffer> handler)
WebSocketBase	WebSocketBase.handler(Consumer<Buffer> handler)
HttpConnection	HttpConnection.pingHandler(Consumer<Buffer> handler)
io.smallrye.mutiny.Uni<Void>	ClientWebSocket.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
io.smallrye.mutiny.Uni<Void>	HttpClientResponse.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
io.smallrye.mutiny.Uni<Void>	HttpServerFileUpload.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
io.smallrye.mutiny.Uni<Void>	HttpServerRequest.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
io.smallrye.mutiny.Uni<Void>	ServerWebSocket.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
io.smallrye.mutiny.Uni<Void>	WebSocket.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
io.smallrye.mutiny.Uni<Void>	WebSocketBase.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Void	ClientWebSocket.pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
Void	HttpClientResponse.pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
Void	HttpServerFileUpload.pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
Void	HttpServerRequest.pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
Void	ServerWebSocket.pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
Void	WebSocket.pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
Void	WebSocketBase.pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
void	ClientWebSocket.pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.
void	HttpClientResponse.pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.
void	HttpServerFileUpload.pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.
void	HttpServerRequest.pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.
void	ServerWebSocket.pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.
void	WebSocket.pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.
void	WebSocketBase.pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.
ClientWebSocket	ClientWebSocket.pongHandler(Consumer<Buffer> handler)
WebSocketBase	ServerWebSocket.pongHandler(Consumer<Buffer> handler)
WebSocketBase	WebSocket.pongHandler(Consumer<Buffer> handler)
WebSocketBase	WebSocketBase.pongHandler(Consumer<Buffer> handler)
io.smallrye.mutiny.Uni<HttpClientResponse>	HttpClientRequest.send(ReadStream<Buffer> body)	Send the request with a stream body.
io.smallrye.mutiny.Uni<HttpClientResponse>	HttpClientRequest.send(Flow.Publisher<Buffer> body)	Send the request with a stream body.
io.smallrye.mutiny.Uni<Void>	HttpServerResponse.send(ReadStream<Buffer> body)	Send the request with a stream body.
io.smallrye.mutiny.Uni<Void>	HttpServerResponse.send(Flow.Publisher<Buffer> body)	Send the request with a stream body.
HttpClientResponse	HttpClientRequest.sendAndAwait(ReadStream<Buffer> body)	Blocking variant of HttpClientRequest.send(io.vertx.mutiny.core.streams.ReadStream).
HttpClientResponse	HttpClientRequest.sendAndAwait(Flow.Publisher<Buffer> body)	Blocking variant of HttpClientRequest.send(Flow$Publisher).
Void	HttpServerResponse.sendAndAwait(ReadStream<Buffer> body)	Blocking variant of HttpServerResponse.send(io.vertx.mutiny.core.streams.ReadStream).
Void	HttpServerResponse.sendAndAwait(Flow.Publisher<Buffer> body)	Blocking variant of HttpServerResponse.send(Flow$Publisher).
void	HttpClientRequest.sendAndForget(ReadStream<Buffer> body)	Variant of HttpClientRequest.send(io.vertx.mutiny.core.streams.ReadStream) that ignores the result of the operation.
void	HttpClientRequest.sendAndForget(Flow.Publisher<Buffer> body)	Variant of HttpClientRequest.send(Flow$Publisher) that ignores the result of the operation.
void	HttpServerResponse.sendAndForget(ReadStream<Buffer> body)	Variant of HttpServerResponse.send(io.vertx.mutiny.core.streams.ReadStream) that ignores the result of the operation.
void	HttpServerResponse.sendAndForget(Flow.Publisher<Buffer> body)	Variant of HttpServerResponse.send(Flow$Publisher) that ignores the result of the operation.

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

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

Modifier and Type	Method	Description
Pipe<Buffer>	NetSocket.pipe()
Iterable<Buffer>	NetSocket.toBlockingIterable()
Stream<Buffer>	NetSocket.toBlockingStream()
io.smallrye.mutiny.Multi<Buffer>	NetSocket.toMulti()
io.smallrye.mutiny.vertx.WriteStreamSubscriber<Buffer>	NetSocket.toSubscriber()

Methods in io.vertx.mutiny.core.net with parameters of type Buffer

Modifier and Type	Method	Description
io.smallrye.mutiny.Uni<Void>	NetSocket.end(Buffer data)	Same as but with an handler called when the operation completes
Void	NetSocket.endAndAwait(Buffer data)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) .
void	NetSocket.endAndForget(Buffer data)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	NetSocket.write(Buffer message)	Like WriteStream.write(T) but with an handler called when the message has been written or failed to be written.
Void	NetSocket.writeAndAwait(Buffer message)	Blocking variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) .
void	NetSocket.writeAndForget(Buffer message)	Variant of invalid reference io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

Method parameters in io.vertx.mutiny.core.net with type arguments of type Buffer

Modifier and Type	Method	Description
NetSocket	NetSocket.handler(Consumer<Buffer> handler)
io.smallrye.mutiny.Uni<Void>	NetSocket.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Void	NetSocket.pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
void	NetSocket.pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.

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

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

Modifier and Type	Method	Description
Buffer	JsonEvent.binaryValue()

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

Modifier and Type	Method	Description
Pipe<Buffer>	RecordParser.pipe()
Iterable<Buffer>	RecordParser.toBlockingIterable()
Stream<Buffer>	RecordParser.toBlockingStream()
io.smallrye.mutiny.Multi<Buffer>	RecordParser.toMulti()

Methods in io.vertx.mutiny.core.parsetools with parameters of type Buffer

Modifier and Type	Method	Description
void	JsonParser.accept(Buffer item)
void	RecordParser.accept(Buffer item)
void	RecordParser.delimitedMode(Buffer delim)
void	JsonParser.handle(Buffer event)
void	RecordParser.handle(Buffer buffer)
static RecordParser	RecordParser.newDelimited(Buffer delim)
static RecordParser	RecordParser.newDelimited(Buffer delim, ReadStream<Buffer> stream)
static RecordParser	RecordParser.newDelimited(Buffer delim, Flow.Publisher<Buffer> stream)
static RecordParser	RecordParser.newDelimited(Buffer delim, Consumer<Buffer> output)
JsonParser	JsonParser.write(Buffer buffer)

Method parameters in io.vertx.mutiny.core.parsetools with type arguments of type Buffer

Modifier and Type	Method	Description
RecordParser	RecordParser.handler(Consumer<Buffer> handler)
static RecordParser	RecordParser.newDelimited(Buffer delim, ReadStream<Buffer> stream)
static RecordParser	RecordParser.newDelimited(Buffer delim, Flow.Publisher<Buffer> stream)
static RecordParser	RecordParser.newDelimited(Buffer delim, Consumer<Buffer> output)
static RecordParser	RecordParser.newDelimited(String delim, ReadStream<Buffer> stream)
static RecordParser	RecordParser.newDelimited(String delim, Flow.Publisher<Buffer> stream)
static RecordParser	RecordParser.newDelimited(String delim, Consumer<Buffer> output)
static RecordParser	RecordParser.newFixed(int size, ReadStream<Buffer> stream)
static RecordParser	RecordParser.newFixed(int size, Flow.Publisher<Buffer> stream)
static RecordParser	RecordParser.newFixed(int size, Consumer<Buffer> output)
static JsonParser	JsonParser.newParser(ReadStream<Buffer> stream)
static JsonParser	JsonParser.newParser(Flow.Publisher<Buffer> stream)
io.smallrye.mutiny.Uni<Void>	RecordParser.pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Void	RecordParser.pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
void	RecordParser.pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.
void	RecordParser.setOutput(Consumer<Buffer> output)