Package io.vertx.mutiny.core.http

Class ClientWebSocket

java.lang.Object

io.vertx.mutiny.core.http.WebSocket

io.vertx.mutiny.core.http.ClientWebSocket

All Implemented Interfaces:

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

public class ClientWebSocket
extends WebSocket
implements MutinyDelegate

Represents a client-side WebSocket initially not connected.

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<ClientWebSocket>	__TYPE_ARG

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method	Description
String	binaryHandlerID()
ClientWebSocket	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.
ClientWebSocket	closeHandler(Runnable handler)
String	closeReason()
Short	closeStatusCode()
io.smallrye.mutiny.Uni<WebSocket>	connect(int port, String host, String requestURI)	Connect a WebSocket to the specified port, host and relative request URI
io.smallrye.mutiny.Uni<WebSocket>	connect(io.vertx.core.http.WebSocketConnectOptions options)	Connect a WebSocket with the specified options.
io.smallrye.mutiny.Uni<WebSocket>	connect(String requestURI)	Connect this WebSocket at the relative request URI using the default host and port.
io.smallrye.mutiny.Uni<WebSocket>	connect(String host, String requestURI)	Connect this WebSocket to the host and relative request URI and default port.
WebSocket	connectAndAwait(int port, String host, String requestURI)	Blocking variant of connect(int,String,String).
WebSocket	connectAndAwait(io.vertx.core.http.WebSocketConnectOptions options)	Blocking variant of connect(WebSocketConnectOptions).
WebSocket	connectAndAwait(String requestURI)	Blocking variant of connect(String).
WebSocket	connectAndAwait(String host, String requestURI)	Blocking variant of connect(String,String).
void	connectAndForget(int port, String host, String requestURI)	Variant of connect(int,String,String) that ignores the result of the operation.
void	connectAndForget(io.vertx.core.http.WebSocketConnectOptions options)	Variant of connect(WebSocketConnectOptions) that ignores the result of the operation.
void	connectAndForget(String requestURI)	Variant of connect(String) that ignores the result of the operation.
void	connectAndForget(String host, String requestURI)	Variant of connect(String,String) that ignores the result of the operation.
ClientWebSocket	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.
ClientWebSocket	endHandler(Runnable endHandler)
boolean	equals(Object o)
ClientWebSocket	exceptionHandler(Consumer<Throwable> handler)
ClientWebSocket	frameHandler(Consumer<WebSocketFrame> handler)
io.vertx.core.http.ClientWebSocket	getDelegate()
ClientWebSocket	handler(Consumer<Buffer> handler)
int	hashCode()
MultiMap	headers()
boolean	isClosed()
boolean	isSsl()
SocketAddress	localAddress()
static ClientWebSocket	newInstance(io.vertx.core.http.ClientWebSocket arg)
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.
ClientWebSocket	pongHandler(Consumer<Buffer> handler)
SocketAddress	remoteAddress()
SSLSession	sslSession()
String	subProtocol()
String	textHandlerID()
ClientWebSocket	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).
ClientWebSocket	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).
ClientWebSocket	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).
ClientWebSocket	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).
ClientWebSocket	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).
ClientWebSocket	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).
ClientWebSocket	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).
ClientWebSocket	writeTextMessageAndForget(String text)	Variant of WebSocketBase.writeTextMessage(String) that ignores the result of the operation.

Methods inherited from class io.vertx.mutiny.core.http.WebSocket

fetch, newInstance, pause, resume, setWriteQueueMaxSize

Methods inherited from class java.lang.Object

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

Field Details

__TYPE_ARG

public static final TypeArg<ClientWebSocket> __TYPE_ARG

Constructor Details

ClientWebSocket

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

ClientWebSocket

public ClientWebSocket(Object delegate)

Method Details

getDelegate

public io.vertx.core.http.ClientWebSocket 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>

Overrides:

getDelegate in class WebSocket

Returns:

the delegate used by this Mutiny object of generated type

toString

public String toString()

Overrides:

toString in class WebSocket

equals

public boolean equals(Object o)

Overrides:

equals in class WebSocket

hashCode

public int hashCode()

Overrides:

hashCode in class WebSocket

toSubscriber

@CheckReturnValue
public WriteStreamSubscriber<Buffer> toSubscriber()

Overrides:

toSubscriber in class WebSocket

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>

Overrides:

write in class WebSocket

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>

Overrides:

writeAndAwait in class WebSocket

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>

Overrides:

writeAndForget in class WebSocket

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>

Overrides:

end in class WebSocket

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>

Overrides:

endAndAwait in class WebSocket

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>

Overrides:

endAndForget in class WebSocket

Parameters:

data -

writeQueueFull

public boolean writeQueueFull()

Specified by:

writeQueueFull in interface WebSocketBase

Specified by:

writeQueueFull in interface WriteStream<Buffer>

Overrides:

writeQueueFull in class WebSocket

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

Overrides:

pipe in class WebSocket

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

Overrides:

pipeTo in class WebSocket

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

Overrides:

pipeToAndAwait in class WebSocket

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

Overrides:

pipeToAndForget in class WebSocket

Parameters:

dst - the destination write stream

binaryHandlerID

public String binaryHandlerID()

Specified by:

binaryHandlerID in interface WebSocketBase

Overrides:

binaryHandlerID in class WebSocket

Returns:

the binary handler id

textHandlerID

public String textHandlerID()

Specified by:

textHandlerID in interface WebSocketBase

Overrides:

textHandlerID in class WebSocket

Returns:

the text handler id

subProtocol

public String subProtocol()

Specified by:

subProtocol in interface WebSocketBase

Overrides:

subProtocol in class WebSocket

Returns:

closeStatusCode

public Short closeStatusCode()

Specified by:

closeStatusCode in interface WebSocketBase

Overrides:

closeStatusCode in class WebSocket

Returns:

closeReason

public String closeReason()

Specified by:

closeReason in interface WebSocketBase

Overrides:

closeReason in class WebSocket

Returns:

headers

public MultiMap headers()

Specified by:

headers in interface WebSocketBase

Overrides:

headers in class WebSocket

Returns:

the headers

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>

Overrides:

end in class WebSocket

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>

Overrides:

endAndAwait in class WebSocket

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>

Overrides:

endAndForget in class WebSocket

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

Overrides:

close in class WebSocket

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

Overrides:

closeAndAwait in class WebSocket

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

Overrides:

closeAndForget in class WebSocket

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

Overrides:

close in class WebSocket

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

Overrides:

closeAndAwait in class WebSocket

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

Overrides:

closeAndForget in class WebSocket

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

Overrides:

close in class WebSocket

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

Overrides:

closeAndAwait in class WebSocket

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

Overrides:

closeAndForget in class WebSocket

Parameters:

statusCode -

reason -

remoteAddress

public SocketAddress remoteAddress()

Specified by:

remoteAddress in interface WebSocketBase

Overrides:

remoteAddress in class WebSocket

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

Overrides:

localAddress in class WebSocket

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

Overrides:

isSsl in class WebSocket

Returns:

true if this HttpConnection is encrypted via SSL/TLS.

isClosed

public boolean isClosed()

Specified by:

isClosed in interface WebSocketBase

Overrides:

isClosed in class WebSocket

Returns:

true if the WebSocket is closed

connect

@CheckReturnValue
public io.smallrye.mutiny.Uni<WebSocket> connect(int port,
 String host,
 String requestURI)

Connect a WebSocket to the specified port, host and relative request URI

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

Parameters:

port - the port

host - the host

requestURI - the relative URI

Returns:

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

connectAndAwait

public WebSocket connectAndAwait(int port,
 String host,
 String requestURI)

Blocking variant of connect(int,String,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).

Parameters:

port - the port

host - the host

requestURI - the relative URI

Returns:

the WebSocket instance produced by the operation.

connectAndForget

public void connectAndForget(int port,
 String host,
 String requestURI)

Variant of connect(int,String,String) that ignores the result of the operation.

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

Parameters:

port - the port

host - the host

requestURI - the relative URI

connect

@CheckReturnValue
public io.smallrye.mutiny.Uni<WebSocket> connect(io.vertx.core.http.WebSocketConnectOptions options)

Connect a WebSocket with the specified options.

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

Parameters:

options - the request options

Returns:

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

connectAndAwait

public WebSocket connectAndAwait(io.vertx.core.http.WebSocketConnectOptions options)

Blocking variant of connect(WebSocketConnectOptions).

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).

Parameters:

options - the request options

Returns:

the WebSocket instance produced by the operation.

connectAndForget

public void connectAndForget(io.vertx.core.http.WebSocketConnectOptions options)

Variant of connect(WebSocketConnectOptions) that ignores the result of the operation.

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

Parameters:

options - the request options

connect

@CheckReturnValue
public io.smallrye.mutiny.Uni<WebSocket> connect(String host,
 String requestURI)

Connect this WebSocket to the host and relative request URI and default port.

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

Parameters:

host - the host

requestURI - the relative URI

Returns:

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

connectAndAwait

public WebSocket connectAndAwait(String host,
 String requestURI)

Blocking variant of connect(String,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).

Parameters:

host - the host

requestURI - the relative URI

Returns:

the WebSocket instance produced by the operation.

connectAndForget

public void connectAndForget(String host,
 String requestURI)

Variant of connect(String,String) that ignores the result of the operation.

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

Parameters:

host - the host

requestURI - the relative URI

connect

@CheckReturnValue
public io.smallrye.mutiny.Uni<WebSocket> connect(String requestURI)

Connect this WebSocket at the relative request URI using the default host and port.

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

Parameters:

requestURI - the relative URI

Returns:

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

connectAndAwait

public WebSocket connectAndAwait(String requestURI)

Blocking variant of connect(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).

Parameters:

requestURI - the relative URI

Returns:

the WebSocket instance produced by the operation.

connectAndForget

public void connectAndForget(String requestURI)

Variant of connect(String) that ignores the result of the operation.

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

Parameters:

requestURI - the relative URI

handler

public ClientWebSocket handler(Consumer<Buffer> handler)

Specified by:

handler in interface ReadStream<Buffer>

Specified by:

handler in interface WebSocketBase

Overrides:

handler in class WebSocket

Returns:

endHandler

public ClientWebSocket endHandler(Runnable endHandler)

Specified by:

endHandler in interface ReadStream<Buffer>

Specified by:

endHandler in interface WebSocketBase

Overrides:

endHandler in class WebSocket

Returns:

drainHandler

public ClientWebSocket drainHandler(Runnable handler)

Specified by:

drainHandler in interface WebSocketBase

Specified by:

drainHandler in interface WriteStream<Buffer>

Overrides:

drainHandler in class WebSocket

Parameters:

handler - the handler

Returns:

closeHandler

public ClientWebSocket closeHandler(Runnable handler)

Specified by:

closeHandler in interface WebSocketBase

Overrides:

closeHandler in class WebSocket

Parameters:

handler - the handler

Returns:

frameHandler

public ClientWebSocket frameHandler(Consumer<WebSocketFrame> handler)

Specified by:

frameHandler in interface WebSocketBase

Overrides:

frameHandler in class WebSocket

Parameters:

handler - the handler

Returns:

textMessageHandler

public ClientWebSocket textMessageHandler(Consumer<String> handler)

Specified by:

textMessageHandler in interface WebSocketBase

Overrides:

textMessageHandler in class WebSocket

Parameters:

handler - the handler

Returns:

binaryMessageHandler

public ClientWebSocket binaryMessageHandler(Consumer<Buffer> handler)

Specified by:

binaryMessageHandler in interface WebSocketBase

Overrides:

binaryMessageHandler in class WebSocket

Parameters:

handler - the handler

Returns:

pongHandler

public ClientWebSocket pongHandler(Consumer<Buffer> handler)

Specified by:

pongHandler in interface WebSocketBase

Overrides:

pongHandler in class WebSocket

Parameters:

handler - the handler

Returns:

exceptionHandler

public ClientWebSocket 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>

Overrides:

exceptionHandler in class WebSocket

Parameters:

handler - the exception 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

Overrides:

writeFrame in class WebSocket

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

Overrides:

writeFrameAndAwait in class WebSocket

Returns:

the Void instance produced by the operation.

writeFrameAndForget

public ClientWebSocket 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

Overrides:

writeFrameAndForget in class WebSocket

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

Overrides:

writeFinalTextFrame in class WebSocket

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

Overrides:

writeFinalTextFrameAndAwait in class WebSocket

Returns:

the Void instance produced by the operation.

writeFinalTextFrameAndForget

public ClientWebSocket 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

Overrides:

writeFinalTextFrameAndForget in class WebSocket

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

Overrides:

writeFinalBinaryFrame in class WebSocket

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

Overrides:

writeFinalBinaryFrameAndAwait in class WebSocket

Returns:

the Void instance produced by the operation.

writeFinalBinaryFrameAndForget

public ClientWebSocket 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

Overrides:

writeFinalBinaryFrameAndForget in class WebSocket

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

Overrides:

writeBinaryMessage in class WebSocket

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

Overrides:

writeBinaryMessageAndAwait in class WebSocket

Returns:

the Void instance produced by the operation.

writeBinaryMessageAndForget

public ClientWebSocket 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

Overrides:

writeBinaryMessageAndForget in class WebSocket

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

Overrides:

writeTextMessage in class WebSocket

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

Overrides:

writeTextMessageAndAwait in class WebSocket

Returns:

the Void instance produced by the operation.

writeTextMessageAndForget

public ClientWebSocket 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

Overrides:

writeTextMessageAndForget in class WebSocket

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

Overrides:

writePing in class WebSocket

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

Overrides:

writePingAndAwait in class WebSocket

Parameters:

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

Returns:

the Void instance produced by the operation.

writePingAndForget

public ClientWebSocket 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

Overrides:

writePingAndForget in class WebSocket

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

Overrides:

writePong in class WebSocket

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

Overrides:

writePongAndAwait in class WebSocket

Parameters:

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

Returns:

the Void instance produced by the operation.

writePongAndForget

public ClientWebSocket 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

Overrides:

writePongAndForget in class WebSocket

Parameters:

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

Returns:

the instance of WebSocketBase to chain method calls.

sslSession

public SSLSession sslSession()

Specified by:

sslSession in interface WebSocketBase

Overrides:

sslSession in class WebSocket

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>

Overrides:

toMulti in class WebSocket

toBlockingIterable

public Iterable<Buffer> toBlockingIterable()

Overrides:

toBlockingIterable in class WebSocket

toBlockingStream

public Stream<Buffer> toBlockingStream()

Overrides:

toBlockingStream in class WebSocket

newInstance

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