io.vertx.core.http

## Interface WebSocket

- All Superinterfaces:
    ReadStream<Buffer>, StreamBase, WebSocketBase, WriteStream<Buffer>

      public interface WebSocket
      extends WebSocketBase

  Represents a client-side WebSocket.
  Author:
    Tim Fox

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `WebSocket` | `closeHandler(Handler<Void> handler)` Set a close handler.
    `WebSocket` | `drainHandler(Handler<Void> handler)` Set a drain handler on the stream.
    `WebSocket` | `endHandler(Handler<Void> endHandler)` Set an end handler.
    `WebSocket` | `exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `WebSocket` | `fetch(long amount)` Fetch the specified `amount` of elements.
    `WebSocket` | `frameHandler(Handler<WebSocketFrame> handler)` Set a frame handler on the connection.
    `WebSocket` | `handler(Handler<Buffer> handler)` Set a data handler.
    `WebSocket` | `pause()` Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand.
    `WebSocket` | `resume()` Resume reading, and sets the buffer in `flowing` mode.
    `WebSocket` | `setWriteQueueMaxSize(int maxSize)` Set the maximum size of the write queue to `maxSize`.
    `WebSocket` | `writeBinaryMessage(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeBinaryMessage(Buffer)` but with an `handler` called when the operation completes
    `WebSocket` | `writeFinalBinaryFrame(Buffer data, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalBinaryFrame(Buffer, Handler)` but with an `handler` called when the operation completes
    `WebSocket` | `writeFinalTextFrame(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFinalTextFrame(String, Handler)` but with an `handler` called when the operation completes
    `WebSocket` | `writeFrame(WebSocketFrame frame, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeFrame(WebSocketFrame)` but with an `handler` called when the operation completes
    `WebSocket` | `writeTextMessage(String text, Handler<AsyncResult<Void>> handler)` Same as `WebSocketBase.writeTextMessage(String)` but with an `handler` called when the operation completes

    - ### Methods inherited from interface io.vertx.core.http.WebSocketBase

      `binaryHandlerID, binaryMessageHandler, close, close, close, close, close, close, closeReason, closeStatusCode, end, end, headers, isClosed, isSsl, localAddress, peerCertificateChain, peerCertificates, pongHandler, remoteAddress, sslSession, subProtocol, textHandlerID, textMessageHandler, writeBinaryMessage, writeFinalBinaryFrame, writeFinalTextFrame, writeFrame, writePing, writePing, writePong, writePong, writeTextMessage`

    - ### Methods inherited from interface io.vertx.core.streams.ReadStream

      `pipe, pipeTo, pipeTo`

    - ### Methods inherited from interface io.vertx.core.streams.WriteStream

      `end, end, write, write, writeQueueFull`

- - ### Method Detail

    - #### exceptionHandler

          WebSocket exceptionHandler(Handler<Throwable> handler)

      Description copied from interface: `ReadStream`
      Set an exception handler on the read stream.
      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:
        a reference to this, so the API can be used fluently

    - #### handler

          WebSocket handler(Handler<Buffer> handler)

      Description copied from interface: `ReadStream`
      Set a data handler. As data is read, the handler will be called with the data.
      Specified by:
        `handler` in interface `ReadStream<Buffer>`
      Specified by:
        `handler` in interface `WebSocketBase`
      Returns:
        a reference to this, so the API can be used fluently

    - #### pause

          WebSocket pause()

      Description copied from interface: `ReadStream`
      Pause the `ReadStream`, it sets the buffer in `fetch` mode and clears the actual demand.

      While it's paused, no data will be sent to the data `handler`.

      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

          WebSocket resume()

      Description copied from interface: `ReadStream`
      Resume reading, and sets the buffer in `flowing` mode.

      If the `ReadStream` has been paused, reading will recommence on it.
      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

          WebSocket fetch(long amount)

      Description copied from interface: `ReadStream`
      Fetch the specified `amount` of elements. If the `ReadStream` has been paused, reading will recommence with the specified `amount` of items, otherwise the specified `amount` will be added to the current stream demand.
      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

          WebSocket endHandler(Handler<Void> endHandler)

      Description copied from interface: `ReadStream`
      Set an end handler. Once the stream has ended, and there is no more data to be read, this handler will be called.
      Specified by:
        `endHandler` in interface `ReadStream<Buffer>`
      Specified by:
        `endHandler` in interface `WebSocketBase`
      Returns:
        a reference to this, so the API can be used fluently

    - #### setWriteQueueMaxSize

          WebSocket setWriteQueueMaxSize(int maxSize)

      Description copied from interface: `WriteStream`
      Set the maximum size of the write queue to `maxSize`. You will still be able to write to the stream even if there is more than `maxSize` items in the write queue. This is used as an indicator by classes such as `Pipe` to provide flow control.

      The value is defined by the implementation of the stream, e.g in bytes for a `NetSocket`, etc...
      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

          WebSocket drainHandler(Handler<Void> handler)

      Description copied from interface: `WriteStream`
      Set a drain handler on the stream. If the write queue is full, then the handler will be called when the write queue is ready to accept buffers again. See `Pipe` for an example of this being used.

      The stream implementation defines when the drain handler, for example it could be when the queue size has been reduced to `maxSize / 2`.

      Specified by:
        `drainHandler` in interface `WebSocketBase`
      Specified by:
        `drainHandler` in interface `WriteStream<Buffer>`
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### writeFrame

          WebSocket writeFrame(WebSocketFrame frame,
                               Handler<AsyncResult<Void>> handler)

      Description copied from interface: `WebSocketBase`
      Same as `WebSocketBase.writeFrame(WebSocketFrame)` but with an `handler` called when the operation completes
      Specified by:
        `writeFrame` in interface `WebSocketBase`

    - #### writeFinalTextFrame

          WebSocket writeFinalTextFrame(String text,
                                        Handler<AsyncResult<Void>> handler)

      Description copied from interface: `WebSocketBase`
      Same as `WebSocketBase.writeFinalTextFrame(String, Handler)` but with an `handler` called when the operation completes
      Specified by:
        `writeFinalTextFrame` in interface `WebSocketBase`

    - #### writeFinalBinaryFrame

          WebSocket writeFinalBinaryFrame(Buffer data,
                                          Handler<AsyncResult<Void>> handler)

      Description copied from interface: `WebSocketBase`
      Same as `WebSocketBase.writeFinalBinaryFrame(Buffer, Handler)` but with an `handler` called when the operation completes
      Specified by:
        `writeFinalBinaryFrame` in interface `WebSocketBase`

    - #### writeBinaryMessage

          WebSocket writeBinaryMessage(Buffer data,
                                       Handler<AsyncResult<Void>> handler)

      Description copied from interface: `WebSocketBase`
      Same as `WebSocketBase.writeBinaryMessage(Buffer)` but with an `handler` called when the operation completes
      Specified by:
        `writeBinaryMessage` in interface `WebSocketBase`

    - #### writeTextMessage

          WebSocket writeTextMessage(String text,
                                     Handler<AsyncResult<Void>> handler)

      Description copied from interface: `WebSocketBase`
      Same as `WebSocketBase.writeTextMessage(String)` but with an `handler` called when the operation completes
      Specified by:
        `writeTextMessage` in interface `WebSocketBase`

    - #### closeHandler

          WebSocket closeHandler(Handler<Void> handler)

      Description copied from interface: `WebSocketBase`
      Set a close handler. This will be called when the WebSocket is closed.

      After this callback, no more messages are expected. When the WebSocket received a close frame, the `WebSocketBase.closeStatusCode()` will return the status code and `WebSocketBase.closeReason()` will return the reason.
      Specified by:
        `closeHandler` in interface `WebSocketBase`
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### frameHandler

          WebSocket frameHandler(Handler<WebSocketFrame> handler)

      Description copied from interface: `WebSocketBase`
      Set a frame handler on the connection. This handler will be called when frames are read on the connection.
      Specified by:
        `frameHandler` in interface `WebSocketBase`
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

Copyright © 2022 Eclipse. All rights reserved.