All Superinterfaces:

ReadStream<Buffer>, StreamBase, WriteStream<Buffer>

All Known Implementing Classes:

ServerWebSocket, WebSocket
```
public interface WebSocketBase
extends ReadStream<Buffer>, WriteStream<Buffer>
```
Base WebSocket implementation.
It implements both and so it can be used with Pipe to pipe data with flow control.
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 TypeArg<Buffer> TYPE_ARG_0

Method Summary

All Methods Static Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`String`	`binaryHandlerID()`
`WebSocketBase`	`binaryMessageHandler(Consumer<Buffer> handler)`
`io.smallrye.mutiny.Uni<Void>`	`close()`	Same as `close()` but with an `handler` called when the operation completes
`io.smallrye.mutiny.Uni<Void>`	`close(short statusCode)`	Same as `close()` but with an `handler` called when the operation completes
`io.smallrye.mutiny.Uni<Void>`	`close(short statusCode, String reason)`	Same as `close()` but with an `handler` called when the operation completes
`Void`	`closeAndAwait()`	Blocking variant of `close()`.
`Void`	`closeAndAwait(short statusCode)`	Blocking variant of `close(short)`.
`Void`	`closeAndAwait(short statusCode, String reason)`	Blocking variant of `close(short,String)`.
`WebSocketBase`	`closeHandler(Consumer<Void> handler)`
`String`	`closeReason()`
`Short`	`closeStatusCode()`
`WebSocketBase`	`drainHandler(Consumer<Void> handler)`
`io.smallrye.mutiny.Uni<Void>`	`end()`	Calls `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 `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)`.
`WebSocketBase`	`endHandler(Consumer<Void> endHandler)`
`WebSocketBase`	`exceptionHandler(Consumer<Throwable> handler)`
`WebSocketBase`	`fetch(long amount)`
`WebSocketBase`	`frameHandler(Consumer<WebSocketFrame> handler)`
`io.vertx.core.http.WebSocketBase`	`getDelegate()`
`WebSocketBase`	`handler(Consumer<Buffer> handler)`
`MultiMap`	`headers()`
`boolean`	`isClosed()`
`boolean`	`isSsl()`
`SocketAddress`	`localAddress()`
`static WebSocketBase`	`newInstance(io.vertx.core.http.WebSocketBase arg)`
`WebSocketBase`	`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 `io.vertx.mutiny.core.streams.ReadStream#pipeTo(io.vertx.mutiny.core.streams.WriteStream)`.
`WebSocketBase`	`pongHandler(Consumer<Buffer> handler)`
`SocketAddress`	`remoteAddress()`
`WebSocketBase`	`resume()`
`WebSocketBase`	`setWriteQueueMaxSize(int maxSize)`
`SSLSession`	`sslSession()`
`String`	`subProtocol()`
`String`	`textHandlerID()`
`WebSocketBase`	`textMessageHandler(Consumer<String> handler)`
`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(T)`.
`io.smallrye.mutiny.Uni<Void>`	`writeBinaryMessage(Buffer data)`	Same as `writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer)` but with an `handler` called when the operation completes
`Void`	`writeBinaryMessageAndAwait(Buffer data)`	Blocking variant of `writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer)`.
`io.smallrye.mutiny.Uni<Void>`	`writeFinalBinaryFrame(Buffer data)`	Same as `writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer)` but with an `handler` called when the operation completes
`Void`	`writeFinalBinaryFrameAndAwait(Buffer data)`	Blocking variant of `writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer)`.
`io.smallrye.mutiny.Uni<Void>`	`writeFinalTextFrame(String text)`	Same as `writeFinalTextFrame(java.lang.String)` but with an `handler` called when the operation completes
`Void`	`writeFinalTextFrameAndAwait(String text)`	Blocking variant of `writeFinalTextFrame(String)`.
`io.smallrye.mutiny.Uni<Void>`	`writeFrame(WebSocketFrame frame)`	Same as `writeFrame(io.vertx.mutiny.core.http.WebSocketFrame)` but with an `handler` called when the operation completes
`Void`	`writeFrameAndAwait(WebSocketFrame frame)`	Blocking variant of `writeFrame(io.vertx.mutiny.core.http.WebSocketFrame)`.
`WebSocketBase`	`writePing(Buffer data)`
`WebSocketBase`	`writePong(Buffer data)`
`boolean`	`writeQueueFull()`
`io.smallrye.mutiny.Uni<Void>`	`writeTextMessage(String text)`	Same as `writeTextMessage(java.lang.String)` but with an `handler` called when the operation completes
`Void`	`writeTextMessageAndAwait(String text)`	Blocking variant of `writeTextMessage(String)`.

Methods inherited from interface io.vertx.mutiny.core.streams.ReadStream
toMulti

- Field Detail
  - TYPE_ARG_0
```
static final TypeArg<Buffer> TYPE_ARG_0
```
- Method Detail
  - getDelegate
```
io.vertx.core.http.WebSocketBase getDelegate()
```
    Specified by:
    
    getDelegate in interface ReadStream<Buffer>
    
    Specified by:
    
    getDelegate in interface StreamBase
    
    Specified by:
    
    getDelegate in interface WriteStream<Buffer>
  - end
```
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 WriteStream<Buffer>
    
    Parameters:
    
    data -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - endAndAwait
```
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 WriteStream<Buffer>
    
    Parameters:
    
    data -
    
    Returns:
    
    the Void instance produced by the operation
  - writeQueueFull
```
boolean writeQueueFull()
```
    Specified by:
    
    writeQueueFull in interface WriteStream<Buffer>
    
    Returns:
    
    true if write queue is full
  - pipe
```
Pipe<Buffer> pipe()
```
    Specified by:
    
    pipe in interface ReadStream<Buffer>
    
    Returns:
    
    a pipe
  - pipeTo
```
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>
    
    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
```
Void pipeToAndAwait(WriteStream<Buffer> dst)
```
    Blocking variant of io.vertx.mutiny.core.streams.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>
    
    Parameters:
    
    dst - the destination write stream
    
    Returns:
    
    the Void instance produced by the operation
  - exceptionHandler
```
WebSocketBase exceptionHandler(Consumer<Throwable> handler)
```
    Specified by:
    
    exceptionHandler in interface ReadStream<Buffer>
    
    Specified by:
    
    exceptionHandler in interface StreamBase
    
    Specified by:
    
    exceptionHandler in interface WriteStream<Buffer>
    
    Parameters:
    
    handler - the exception handler
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - handler
```
WebSocketBase handler(Consumer<Buffer> handler)
```
    Specified by:
    
    handler in interface ReadStream<Buffer>
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - pause
```
WebSocketBase pause()
```
    Specified by:
    
    pause in interface ReadStream<Buffer>
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - resume
```
WebSocketBase resume()
```
    Specified by:
    
    resume in interface ReadStream<Buffer>
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - fetch
```
WebSocketBase fetch(long amount)
```
    Specified by:
    
    fetch in interface ReadStream<Buffer>
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - endHandler
```
WebSocketBase endHandler(Consumer<Void> endHandler)
```
    Specified by:
    
    endHandler in interface ReadStream<Buffer>
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - write
```
io.smallrye.mutiny.Uni<Void> write(Buffer data)
```
    Description copied from interface: WriteStream
    
    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 WriteStream<Buffer>
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - writeAndAwait
```
Void writeAndAwait(Buffer data)
```
    Description copied from interface: WriteStream
    
    Blocking variant of io.vertx.mutiny.core.streams.WriteStream#write(T).
    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 WriteStream<Buffer>
    
    Returns:
    
    the Void instance produced by the operation
  - setWriteQueueMaxSize
```
WebSocketBase setWriteQueueMaxSize(int maxSize)
```
    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
```
WebSocketBase drainHandler(Consumer<Void> handler)
```
    Specified by:
    
    drainHandler in interface WriteStream<Buffer>
    
    Parameters:
    
    handler - the handler
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - binaryHandlerID
```
String binaryHandlerID()
```
    Returns:
    
    the binary handler id
  - textHandlerID
```
String textHandlerID()
```
    Returns:
  - subProtocol
```
String subProtocol()
```
    Returns:
  - closeStatusCode
```
Short closeStatusCode()
```
    Returns:
  - closeReason
```
String closeReason()
```
    Returns:
  - headers
```
MultiMap headers()
```
    Returns:
    
    the headers
  - writeFrame
```
io.smallrye.mutiny.Uni<Void> writeFrame(WebSocketFrame frame)
```
    Same as 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.
    
    Parameters:
    
    frame -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - writeFrameAndAwait
```
Void writeFrameAndAwait(WebSocketFrame frame)
```
    Blocking variant of 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).
    
    Parameters:
    
    frame -
    
    Returns:
    
    the Void instance produced by the operation
  - writeFinalTextFrame
```
io.smallrye.mutiny.Uni<Void> writeFinalTextFrame(String text)
```
    Same as 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.
    
    Parameters:
    
    text -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - writeFinalTextFrameAndAwait
```
Void writeFinalTextFrameAndAwait(String text)
```
    Blocking variant of 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).
    
    Parameters:
    
    text -
    
    Returns:
    
    the Void instance produced by the operation
  - writeFinalBinaryFrame
```
io.smallrye.mutiny.Uni<Void> writeFinalBinaryFrame(Buffer data)
```
    Same as 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.
    
    Parameters:
    
    data -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - writeFinalBinaryFrameAndAwait
```
Void writeFinalBinaryFrameAndAwait(Buffer data)
```
    Blocking variant of 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).
    
    Parameters:
    
    data -
    
    Returns:
    
    the Void instance produced by the operation
  - writeBinaryMessage
```
io.smallrye.mutiny.Uni<Void> writeBinaryMessage(Buffer data)
```
    Same as 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.
    
    Parameters:
    
    data -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - writeBinaryMessageAndAwait
```
Void writeBinaryMessageAndAwait(Buffer data)
```
    Blocking variant of 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).
    
    Parameters:
    
    data -
    
    Returns:
    
    the Void instance produced by the operation
  - writeTextMessage
```
io.smallrye.mutiny.Uni<Void> writeTextMessage(String text)
```
    Same as 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.
    
    Parameters:
    
    text -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - writeTextMessageAndAwait
```
Void writeTextMessageAndAwait(String text)
```
    Blocking variant of 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).
    
    Parameters:
    
    text -
    
    Returns:
    
    the Void instance produced by the operation
  - writePing
```
WebSocketBase writePing(Buffer data)
```
    Parameters:
    
    data - the data to write, may be at most 125 bytes
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - writePong
```
WebSocketBase writePong(Buffer data)
```
    Parameters:
    
    data - the data to write, may be at most 125 bytes
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - closeHandler
```
WebSocketBase closeHandler(Consumer<Void> handler)
```
    Parameters:
    
    handler - the handler
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - frameHandler
```
WebSocketBase frameHandler(Consumer<WebSocketFrame> handler)
```
    Parameters:
    
    handler - the handler
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - textMessageHandler
```
WebSocketBase textMessageHandler(Consumer<String> handler)
```
    Parameters:
    
    handler - the handler
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - binaryMessageHandler
```
WebSocketBase binaryMessageHandler(Consumer<Buffer> handler)
```
    Parameters:
    
    handler - the handler
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - pongHandler
```
WebSocketBase pongHandler(Consumer<Buffer> handler)
```
    Parameters:
    
    handler - the handler
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - end
```
io.smallrye.mutiny.Uni<Void> end()
```
    Calls 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 WriteStream<Buffer>
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - endAndAwait
```
Void endAndAwait()
```
    Blocking variant of 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 WriteStream<Buffer>
    
    Returns:
    
    the Void instance produced by the operation
  - close
```
io.smallrye.mutiny.Uni<Void> close()
```
    Same as 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.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - closeAndAwait
```
Void closeAndAwait()
```
    Blocking variant of 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).
    
    Returns:
    
    the Void instance produced by the operation
  - close
```
io.smallrye.mutiny.Uni<Void> close(short statusCode)
```
    Same as 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.
    
    Parameters:
    
    statusCode -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - closeAndAwait
```
Void closeAndAwait(short statusCode)
```
    Blocking variant of 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).
    
    Parameters:
    
    statusCode -
    
    Returns:
    
    the Void instance produced by the operation
  - close
```
io.smallrye.mutiny.Uni<Void> close(short statusCode,
                                   String reason)
```
    Same as 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.
    
    Parameters:
    
    statusCode -
    
    reason -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - closeAndAwait
```
Void closeAndAwait(short statusCode,
                   String reason)
```
    Blocking variant of 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).
    
    Parameters:
    
    statusCode -
    
    reason -
    
    Returns:
    
    the Void instance produced by the operation
  - remoteAddress
```
SocketAddress remoteAddress()
```
    Returns:
    
    the remote address for this connection, possibly null (e.g a server bound on a domain socket)
  - localAddress
```
SocketAddress localAddress()
```
    Returns:
    
    the local address for this connection, possibly null (e.g a server bound on a domain socket)
  - isSsl
```
boolean isSsl()
```
    Returns:
    
    true if this HttpConnection is encrypted via SSL/TLS.
  - isClosed
```
boolean isClosed()
```
    Returns:
    
    true if the WebSocket is closed
  - sslSession
```
SSLSession sslSession()
```
    Returns:
    
    SSLSession associated with the underlying socket. Returns null if connection is not SSL.
  - newInstance
```
static WebSocketBase newInstance(io.vertx.core.http.WebSocketBase arg)
```

Interface WebSocketBase

Field Summary

Method Summary

Methods inherited from interface io.vertx.mutiny.core.streams.ReadStream

Field Detail

TYPE_ARG_0

Method Detail

getDelegate

end

endAndAwait

writeQueueFull

pipe

pipeTo

pipeToAndAwait

exceptionHandler

handler

pause

resume

fetch

endHandler

write

writeAndAwait

setWriteQueueMaxSize

drainHandler

binaryHandlerID

textHandlerID

subProtocol

closeStatusCode

closeReason

headers

writeFrame

writeFrameAndAwait

writeFinalTextFrame

writeFinalTextFrameAndAwait

writeFinalBinaryFrame

writeFinalBinaryFrameAndAwait

writeBinaryMessage

writeBinaryMessageAndAwait

writeTextMessage

writeTextMessageAndAwait

writePing

writePong

closeHandler

frameHandler

textMessageHandler

binaryMessageHandler

pongHandler

end

endAndAwait

close

closeAndAwait

close

closeAndAwait

close

closeAndAwait

remoteAddress

localAddress

isSsl

isClosed

sslSession

newInstance