Package io.vertx.mutiny.core.http

Class WebSocket

java.lang.Object

io.vertx.mutiny.core.http.WebSocket

All Implemented Interfaces:

MutinyDelegate, WebSocketBase, ReadStream<Buffer>, StreamBase, WriteStream<Buffer>

Direct Known Subclasses:

ClientWebSocket

public class WebSocket
extends Object
implements MutinyDelegate, WebSocketBase

Represents a client-side WebSocket.

NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

Field Summary

Fields

Modifier and Type	Field	Description
static final TypeArg<WebSocket>	__TYPE_ARG

Constructor Summary

Constructors

Constructor	Description
WebSocket(io.vertx.core.http.WebSocket delegate)
WebSocket(Object delegate)

Method Summary

Modifier and Type	Method	Description
String	binaryHandlerID()
WebSocketBase	binaryMessageHandler(Consumer<Buffer> handler)
io.smallrye.mutiny.Uni<Void>	close()	Same as WebSocketBase.close() but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	close(short statusCode)	Same as WebSocketBase.close() but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	close(short statusCode, String reason)	Same as WebSocketBase.close() but with an handler called when the operation completes
Void	closeAndAwait()	Blocking variant of WebSocketBase.close().
Void	closeAndAwait(short statusCode)	Blocking variant of WebSocketBase.close(short).
Void	closeAndAwait(short statusCode, String reason)	Blocking variant of WebSocketBase.close(short,String).
void	closeAndForget()	Variant of WebSocketBase.close() that ignores the result of the operation.
void	closeAndForget(short statusCode)	Variant of WebSocketBase.close(short) that ignores the result of the operation.
void	closeAndForget(short statusCode, String reason)	Variant of WebSocketBase.close(short,String) that ignores the result of the operation.
WebSocket	closeHandler(Runnable handler)
String	closeReason()
Short	closeStatusCode()
WebSocket	drainHandler(Runnable handler)
io.smallrye.mutiny.Uni<Void>	end()	Calls WebSocketBase.close()
io.smallrye.mutiny.Uni<Void>	end(Buffer data)	Same as but with an handler called when the operation completes
Void	endAndAwait()	Blocking variant of WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer).
Void	endAndAwait(Buffer data)	Blocking variant of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer).
void	endAndForget()	Variant of WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	endAndForget(Buffer data)	Variant of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
WebSocket	endHandler(Runnable endHandler)
boolean	equals(Object o)
WebSocket	exceptionHandler(Consumer<Throwable> handler)
WebSocket	fetch(long amount)
WebSocket	frameHandler(Consumer<WebSocketFrame> handler)
io.vertx.core.http.WebSocket	getDelegate()
WebSocket	handler(Consumer<Buffer> handler)
int	hashCode()
MultiMap	headers()
boolean	isClosed()
boolean	isSsl()
SocketAddress	localAddress()
static WebSocket	newInstance(io.vertx.core.http.WebSocket arg)
WebSocket	pause()
Pipe<Buffer>	pipe()
io.smallrye.mutiny.Uni<Void>	pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Void	pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
void	pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.
WebSocketBase	pongHandler(Consumer<Buffer> handler)
SocketAddress	remoteAddress()
WebSocket	resume()
WebSocket	setWriteQueueMaxSize(int maxSize)
SSLSession	sslSession()
String	subProtocol()
String	textHandlerID()
WebSocketBase	textMessageHandler(Consumer<String> handler)
Iterable<Buffer>	toBlockingIterable()
Stream<Buffer>	toBlockingStream()
io.smallrye.mutiny.Multi<Buffer>	toMulti()
String	toString()
WriteStreamSubscriber<Buffer>	toSubscriber()
io.smallrye.mutiny.Uni<Void>	write(Buffer data)	Same as but with an handler called when the operation completes
Void	writeAndAwait(Buffer data)	Blocking variant of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer).
void	writeAndForget(Buffer data)	Variant of 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>	writeBinaryMessage(Buffer data)	Same as WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes
Void	writeBinaryMessageAndAwait(Buffer data)	Blocking variant of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer).
WebSocket	writeBinaryMessageAndForget(Buffer data)	Variant of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	writeFinalBinaryFrame(Buffer data)	Same as WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes
Void	writeFinalBinaryFrameAndAwait(Buffer data)	Blocking variant of WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer).
WebSocket	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>	writeFinalTextFrame(String text)	Same as WebSocketBase.writeFinalTextFrame(java.lang.String) but with an handler called when the operation completes
Void	writeFinalTextFrameAndAwait(String text)	Blocking variant of WebSocketBase.writeFinalTextFrame(String).
WebSocket	writeFinalTextFrameAndForget(String text)	Variant of WebSocketBase.writeFinalTextFrame(String) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	writeFrame(WebSocketFrame frame)	Same as WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame) but with an handler called when the operation completes
Void	writeFrameAndAwait(WebSocketFrame frame)	Blocking variant of WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame).
WebSocket	writeFrameAndForget(WebSocketFrame frame)	Variant of WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	writePing(Buffer data)	Writes a ping frame to the connection.
Void	writePingAndAwait(Buffer data)	Blocking variant of WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer).
WebSocket	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>	writePong(Buffer data)	Writes a pong frame to the connection.
Void	writePongAndAwait(Buffer data)	Blocking variant of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer).
WebSocket	writePongAndForget(Buffer data)	Variant of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
boolean	writeQueueFull()
io.smallrye.mutiny.Uni<Void>	writeTextMessage(String text)	Same as WebSocketBase.writeTextMessage(java.lang.String) but with an handler called when the operation completes
Void	writeTextMessageAndAwait(String text)	Blocking variant of WebSocketBase.writeTextMessage(String).
WebSocket	writeTextMessageAndForget(String text)	Variant of WebSocketBase.writeTextMessage(String) that ignores the result of the operation.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Details

__TYPE_ARG

public static final TypeArg<WebSocket> __TYPE_ARG

Constructor Details

WebSocket

public WebSocket(io.vertx.core.http.WebSocket delegate)

WebSocket

public WebSocket(Object delegate)

Method Details

getDelegate

public io.vertx.core.http.WebSocket getDelegate()

Specified by:

getDelegate in interface MutinyDelegate

Specified by:

getDelegate in interface ReadStream<Buffer>

Specified by:

getDelegate in interface StreamBase

Specified by:

getDelegate in interface WebSocketBase

Specified by:

getDelegate in interface WriteStream<Buffer>

Returns:

the delegate used by this Mutiny object of generated type

toString

public String toString()

Overrides:

toString in class Object

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toSubscriber

@CheckReturnValue
public WriteStreamSubscriber<Buffer> toSubscriber()

write

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> write(Buffer data)

Same as but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

write in interface WebSocketBase

Specified by:

write in interface WriteStream<Buffer>

Parameters:

data -

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeAndAwait

public Void writeAndAwait(Buffer data)

Blocking variant of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeAndAwait in interface WebSocketBase

Specified by:

writeAndAwait in interface WriteStream<Buffer>

Parameters:

data -

Returns:

the Void instance produced by the operation.

writeAndForget

public void writeAndForget(Buffer data)

Variant of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

writeAndForget in interface WebSocketBase

Specified by:

writeAndForget in interface WriteStream<Buffer>

Parameters:

data -

end

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> end(Buffer data)

Same as but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

end in interface WebSocketBase

Specified by:

end in interface WriteStream<Buffer>

Parameters:

data -

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

endAndAwait

public Void endAndAwait(Buffer data)

Blocking variant of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

endAndAwait in interface WebSocketBase

Specified by:

endAndAwait in interface WriteStream<Buffer>

Parameters:

data -

Returns:

the Void instance produced by the operation.

endAndForget

public void endAndForget(Buffer data)

Variant of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

endAndForget in interface WebSocketBase

Specified by:

endAndForget in interface WriteStream<Buffer>

Parameters:

data -

writeQueueFull

public boolean writeQueueFull()

Specified by:

writeQueueFull in interface WebSocketBase

Specified by:

writeQueueFull in interface WriteStream<Buffer>

Returns:

true if write queue is full

pipe

public Pipe<Buffer> pipe()

Specified by:

pipe in interface ReadStream<Buffer>

Specified by:

pipe in interface WebSocketBase

Returns:

a pipe

pipeTo

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> pipeTo(WriteStream<Buffer> dst)

Pipe this ReadStream to the WriteStream.

Elements emitted by this stream will be written to the write stream until this stream ends or fails.

Once this stream has ended or failed, the write stream will be ended and the handler will be called with the result.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

pipeTo in interface ReadStream<Buffer>

Specified by:

pipeTo in interface WebSocketBase

Parameters:

dst - the destination write stream

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

pipeToAndAwait

public Void pipeToAndAwait(WriteStream<Buffer> dst)

Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

pipeToAndAwait in interface ReadStream<Buffer>

Specified by:

pipeToAndAwait in interface WebSocketBase

Parameters:

dst - the destination write stream

Returns:

the Void instance produced by the operation.

pipeToAndForget

public void pipeToAndForget(WriteStream<Buffer> dst)

Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.

This method subscribes on the result of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) but you don't need to compose it with other operations.

Specified by:

pipeToAndForget in interface ReadStream<Buffer>

Specified by:

pipeToAndForget in interface WebSocketBase

Parameters:

dst - the destination write stream

binaryHandlerID

public String binaryHandlerID()

Specified by:

binaryHandlerID in interface WebSocketBase

Returns:

the binary handler id

textHandlerID

public String textHandlerID()

Specified by:

textHandlerID in interface WebSocketBase

Returns:

the text handler id

subProtocol

public String subProtocol()

Specified by:

subProtocol in interface WebSocketBase

Returns:

closeStatusCode

public Short closeStatusCode()

Specified by:

closeStatusCode in interface WebSocketBase

Returns:

closeReason

public String closeReason()

Specified by:

closeReason in interface WebSocketBase

Returns:

headers

public MultiMap headers()

Specified by:

headers in interface WebSocketBase

Returns:

the headers

textMessageHandler

public WebSocketBase textMessageHandler(Consumer<String> handler)

Specified by:

textMessageHandler in interface WebSocketBase

Parameters:

handler - the handler

Returns:

binaryMessageHandler

public WebSocketBase binaryMessageHandler(Consumer<Buffer> handler)

Specified by:

binaryMessageHandler in interface WebSocketBase

Parameters:

handler - the handler

Returns:

pongHandler

public WebSocketBase pongHandler(Consumer<Buffer> handler)

Specified by:

pongHandler in interface WebSocketBase

Parameters:

handler - the handler

Returns:

end

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> end()

Calls WebSocketBase.close()

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

end in interface WebSocketBase

Specified by:

end in interface WriteStream<Buffer>

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

endAndAwait

public Void endAndAwait()

Blocking variant of WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

endAndAwait in interface WebSocketBase

Specified by:

endAndAwait in interface WriteStream<Buffer>

Returns:

the Void instance produced by the operation.

endAndForget

public void endAndForget()

Variant of WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

endAndForget in interface WebSocketBase

Specified by:

endAndForget in interface WriteStream<Buffer>

close

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> close()

Same as WebSocketBase.close() but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

close in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

closeAndAwait

public Void closeAndAwait()

Blocking variant of WebSocketBase.close().

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

closeAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

closeAndForget

public void closeAndForget()

Variant of WebSocketBase.close() that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.close(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.close() but you don't need to compose it with other operations.

Specified by:

closeAndForget in interface WebSocketBase

close

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> close(short statusCode)

Same as WebSocketBase.close() but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

close in interface WebSocketBase

Parameters:

statusCode -

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

closeAndAwait

public Void closeAndAwait(short statusCode)

Blocking variant of WebSocketBase.close(short).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

closeAndAwait in interface WebSocketBase

Parameters:

statusCode -

Returns:

the Void instance produced by the operation.

closeAndForget

public void closeAndForget(short statusCode)

Variant of WebSocketBase.close(short) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.close(short), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.close(short) but you don't need to compose it with other operations.

Specified by:

closeAndForget in interface WebSocketBase

Parameters:

statusCode -

close

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> close(short statusCode,
 String reason)

Same as WebSocketBase.close() but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

close in interface WebSocketBase

Parameters:

statusCode -

reason -

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

closeAndAwait

public Void closeAndAwait(short statusCode,
 String reason)

Blocking variant of WebSocketBase.close(short,String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

closeAndAwait in interface WebSocketBase

Parameters:

statusCode -

reason -

Returns:

the Void instance produced by the operation.

closeAndForget

public void closeAndForget(short statusCode,
 String reason)

Variant of WebSocketBase.close(short,String) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.close(short,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.close(short,String) but you don't need to compose it with other operations.

Specified by:

closeAndForget in interface WebSocketBase

Parameters:

statusCode -

reason -

remoteAddress

public SocketAddress remoteAddress()

Specified by:

remoteAddress in interface WebSocketBase

Returns:

the remote address for this connection, possibly null (e.g a server bound on a domain socket). If useProxyProtocol is set to true, the address returned will be of the actual connecting client.

localAddress

public SocketAddress localAddress()

Specified by:

localAddress in interface WebSocketBase

Returns:

the local address for this connection, possibly null (e.g a server bound on a domain socket) If useProxyProtocol is set to true, the address returned will be of the proxy.

isSsl

public boolean isSsl()

Specified by:

isSsl in interface WebSocketBase

Returns:

true if this HttpConnection is encrypted via SSL/TLS.

isClosed

public boolean isClosed()

Specified by:

isClosed in interface WebSocketBase

Returns:

true if the WebSocket is closed

exceptionHandler

public WebSocket exceptionHandler(Consumer<Throwable> handler)

Specified by:

exceptionHandler in interface ReadStream<Buffer>

Specified by:

exceptionHandler in interface StreamBase

Specified by:

exceptionHandler in interface WebSocketBase

Specified by:

exceptionHandler in interface WriteStream<Buffer>

Parameters:

handler - the exception handler

Returns:

handler

public WebSocket handler(Consumer<Buffer> handler)

Specified by:

handler in interface ReadStream<Buffer>

Specified by:

handler in interface WebSocketBase

Returns:

pause

public WebSocket pause()

Specified by:

pause in interface ReadStream<Buffer>

Specified by:

pause in interface WebSocketBase

Returns:

a reference to this, so the API can be used fluently

resume

public WebSocket resume()

Specified by:

resume in interface ReadStream<Buffer>

Specified by:

resume in interface WebSocketBase

Returns:

a reference to this, so the API can be used fluently

fetch

public WebSocket fetch(long amount)

Specified by:

fetch in interface ReadStream<Buffer>

Specified by:

fetch in interface WebSocketBase

Returns:

a reference to this, so the API can be used fluently

endHandler

public WebSocket endHandler(Runnable endHandler)

Specified by:

endHandler in interface ReadStream<Buffer>

Specified by:

endHandler in interface WebSocketBase

Returns:

setWriteQueueMaxSize

public WebSocket setWriteQueueMaxSize(int maxSize)

Specified by:

setWriteQueueMaxSize in interface WebSocketBase

Specified by:

setWriteQueueMaxSize in interface WriteStream<Buffer>

Parameters:

maxSize - the max size of the write stream

Returns:

a reference to this, so the API can be used fluently

drainHandler

public WebSocket drainHandler(Runnable handler)

Specified by:

drainHandler in interface WebSocketBase

Specified by:

drainHandler in interface WriteStream<Buffer>

Parameters:

handler - the handler

Returns:

writeFrame

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writeFrame(WebSocketFrame frame)

Description copied from interface: WebSocketBase

Same as WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame) but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writeFrame in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeFrameAndAwait

public Void writeFrameAndAwait(WebSocketFrame frame)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeFrameAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

writeFrameAndForget

public WebSocket writeFrameAndForget(WebSocketFrame frame)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame) but you don't need to compose it with other operations.

Specified by:

writeFrameAndForget in interface WebSocketBase

Returns:

the instance of WebSocketBase to chain method calls.

writeFinalTextFrame

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writeFinalTextFrame(String text)

Description copied from interface: WebSocketBase

Same as WebSocketBase.writeFinalTextFrame(java.lang.String) but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writeFinalTextFrame in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeFinalTextFrameAndAwait

public Void writeFinalTextFrameAndAwait(String text)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writeFinalTextFrame(String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeFinalTextFrameAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

writeFinalTextFrameAndForget

public WebSocket writeFinalTextFrameAndForget(String text)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writeFinalTextFrame(String) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writeFinalTextFrame(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writeFinalTextFrame(String) but you don't need to compose it with other operations.

Specified by:

writeFinalTextFrameAndForget in interface WebSocketBase

Returns:

the instance of WebSocketBase to chain method calls.

writeFinalBinaryFrame

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writeFinalBinaryFrame(Buffer data)

Description copied from interface: WebSocketBase

Same as WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writeFinalBinaryFrame in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeFinalBinaryFrameAndAwait

public Void writeFinalBinaryFrameAndAwait(Buffer data)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeFinalBinaryFrameAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

writeFinalBinaryFrameAndForget

public WebSocket writeFinalBinaryFrameAndForget(Buffer data)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

writeFinalBinaryFrameAndForget in interface WebSocketBase

Returns:

the instance of WebSocketBase to chain method calls.

writeBinaryMessage

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writeBinaryMessage(Buffer data)

Description copied from interface: WebSocketBase

Same as WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writeBinaryMessage in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeBinaryMessageAndAwait

public Void writeBinaryMessageAndAwait(Buffer data)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeBinaryMessageAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

writeBinaryMessageAndForget

public WebSocket writeBinaryMessageAndForget(Buffer data)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

writeBinaryMessageAndForget in interface WebSocketBase

Returns:

the instance of WebSocketBase to chain method calls.

writeTextMessage

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writeTextMessage(String text)

Description copied from interface: WebSocketBase

Same as WebSocketBase.writeTextMessage(java.lang.String) but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writeTextMessage in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeTextMessageAndAwait

public Void writeTextMessageAndAwait(String text)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writeTextMessage(String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeTextMessageAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

writeTextMessageAndForget

public WebSocket writeTextMessageAndForget(String text)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writeTextMessage(String) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writeTextMessage(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writeTextMessage(String) but you don't need to compose it with other operations.

Specified by:

writeTextMessageAndForget in interface WebSocketBase

Returns:

the instance of WebSocketBase to chain method calls.

writePing

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writePing(Buffer data)

Description copied from interface: WebSocketBase

Writes a ping frame to the connection. This will be written in a single frame. Ping frames may be at most 125 bytes (octets).

This method should not be used to write application data and should only be used for implementing a keep alive or to ensure the client is still responsive, see RFC 6455 Section section 5.5.2.

There is no handler for ping frames because RFC 6455 clearly states that the only response to a ping frame is a pong frame with identical contents.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writePing in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writePingAndAwait

public Void writePingAndAwait(Buffer data)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writePingAndAwait in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the Void instance produced by the operation.

writePingAndForget

public WebSocket writePingAndForget(Buffer data)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

writePingAndForget in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the instance of WebSocketBase to chain method calls.

writePong

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writePong(Buffer data)

Description copied from interface: WebSocketBase

Writes a pong frame to the connection. This will be written in a single frame. Pong frames may be at most 125 bytes (octets).

This method should not be used to write application data and should only be used for implementing a keep alive or to ensure the client is still responsive, see RFC 6455 section 5.5.2.

There is no need to manually write a pong frame, as the server and client both handle responding to a ping from with a pong from automatically and this is exposed to users. RFC 6455 section 5.5.3 states that pongs may be sent unsolicited in order to implement a one way heartbeat.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writePong in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writePongAndAwait

public Void writePongAndAwait(Buffer data)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writePongAndAwait in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the Void instance produced by the operation.

writePongAndForget

public WebSocket writePongAndForget(Buffer data)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

writePongAndForget in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the instance of WebSocketBase to chain method calls.

closeHandler

public WebSocket closeHandler(Runnable handler)

Specified by:

closeHandler in interface WebSocketBase

Parameters:

handler - the handler

Returns:

frameHandler

public WebSocket frameHandler(Consumer<WebSocketFrame> handler)

Specified by:

frameHandler in interface WebSocketBase

Parameters:

handler - the handler

Returns:

sslSession

public SSLSession sslSession()

Specified by:

sslSession in interface WebSocketBase

Returns:

SSLSession associated with the underlying socket. Returns null if connection is not SSL.

toMulti

@CheckReturnValue
public io.smallrye.mutiny.Multi<Buffer> toMulti()

Specified by:

toMulti in interface ReadStream<Buffer>

toBlockingIterable

public Iterable<Buffer> toBlockingIterable()

toBlockingStream

public Stream<Buffer> toBlockingStream()

newInstance

public static WebSocket newInstance(io.vertx.core.http.WebSocket arg)