Package org.apache.tomcat.websocket

# Class WsRemoteEndpointImplBase

java.lang.Object
org.apache.tomcat.websocket.WsRemoteEndpointImplBase

All Implemented Interfaces:
  `RemoteEndpoint`

Direct Known Subclasses:
  `WsRemoteEndpointImplClient`, `WsRemoteEndpointImplServer`

public abstract class WsRemoteEndpointImplBase extends Object implements RemoteEndpoint

## Nested Class Summary

## Nested classes/interfaces inherited from interface jakarta.websocket.RemoteEndpoint

`RemoteEndpoint.Async, RemoteEndpoint.Basic`

## Field Summary

Fields
Modifier and Type
Field
Description
`protected final Semaphore`
`messagePartInProgress`
`protected static final SendResult`
`SENDRESULT_OK`
`protected static final StringManager`
`sm`

## Constructor Summary

Constructors
Constructor
Description
`WsRemoteEndpointImplBase()`

## Method Summary

Modifier and Type
Method
Description
`protected boolean`
`acquireMessagePartInProgressSemaphore(byte opCode, long timeoutExpiry)`
Acquire the semaphore that allows a message part to be written.
`final void`
`close()`
`protected abstract void`
`doClose()`
`protected abstract void`
`doWrite(SendHandler handler, long blockingWriteTimeoutExpiry, ByteBuffer... data)`
`void`
`flushBatch()`
Flush any currently batched messages to the remote endpoint.
`boolean`
`getBatchingAllowed()`
Obtains the current batching status of the endpoint.
`protected abstract Lock`
`getLock()`
`OutputStream`
`getSendStream()`
`long`
`getSendTimeout()`
`Writer`
`getSendWriter()`
`protected abstract boolean`
`isMasked()`
`void`
`sendBytes(ByteBuffer data)`
`void`
`sendBytesByCompletion(ByteBuffer data, SendHandler handler)`
`Future<Void>`
`sendBytesByFuture(ByteBuffer data)`
`void`
`sendObject(Object obj)`
`void`
`sendObjectByCompletion(Object obj, SendHandler completion)`
`Future<Void>`
`sendObjectByFuture(Object obj)`
`void`
`sendPartialBytes(ByteBuffer partialByte, boolean last)`
`void`
`sendPartialString(String fragment, boolean isLast)`
`void`
`sendPing(ByteBuffer applicationData)`
Send a ping message blocking until the message has been sent.
`void`
`sendPong(ByteBuffer applicationData)`
Send a pong message blocking until the message has been sent.
`void`
`sendString(String text)`
`void`
`sendStringByCompletion(String text, SendHandler handler)`
`Future<Void>`
`sendStringByFuture(String text)`
`void`
`setBatchingAllowed(boolean batchingAllowed)`
Enable or disable the batching of outgoing messages for this endpoint.
`protected void`
`setEncoders(EndpointConfig endpointConfig)`
`void`
`setSendTimeout(long timeout)`
`protected void`
`setSession(WsSession wsSession)`
`protected void`
`setTransformation(Transformation transformation)`
`protected void`
`updateStats(long payloadLength)`
Hook for updating server side statistics.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Field Details

### sm

protected static final StringManager sm

### SENDRESULT_OK

protected static final SendResult SENDRESULT_OK

### messagePartInProgress

protected final Semaphore messagePartInProgress

## Constructor Details

### WsRemoteEndpointImplBase

public WsRemoteEndpointImplBase()

## Method Details

### setTransformation

protected void setTransformation(Transformation transformation)

### getSendTimeout

public long getSendTimeout()

### setSendTimeout

public void setSendTimeout(long timeout)

### setBatchingAllowed

public void setBatchingAllowed(boolean batchingAllowed) throws IOException
Description copied from interface: `jakarta.websocket.RemoteEndpoint`
Enable or disable the batching of outgoing messages for this endpoint. If batching is disabled when it was previously enabled then this method will block until any currently batched messages have been written.

Specified by:
  `setBatchingAllowed` in interface `RemoteEndpoint`
Parameters:
  `batchingAllowed` - New setting
Throws:
  `IOException` - If changing the value resulted in a call to `RemoteEndpoint.flushBatch()` and that call threw an `IOException`.

### getBatchingAllowed

public boolean getBatchingAllowed()
Description copied from interface: `jakarta.websocket.RemoteEndpoint`
Obtains the current batching status of the endpoint.

Specified by:
  `getBatchingAllowed` in interface `RemoteEndpoint`
Returns:
  `true` if batching is enabled, otherwise `false`.

### flushBatch

public void flushBatch() throws IOException
Description copied from interface: `jakarta.websocket.RemoteEndpoint`
Flush any currently batched messages to the remote endpoint. This method will block until the flush completes.

Specified by:
  `flushBatch` in interface `RemoteEndpoint`
Throws:
  `IOException` - If an I/O error occurs while flushing

### sendBytes

public void sendBytes(ByteBuffer data) throws IOException

Throws:
  `IOException`

### sendBytesByFuture

public Future<Void> sendBytesByFuture(ByteBuffer data)

### sendBytesByCompletion

public void sendBytesByCompletion(ByteBuffer data, SendHandler handler)

### sendPartialBytes

public void sendPartialBytes(ByteBuffer partialByte, boolean last) throws IOException

Throws:
  `IOException`

### sendPing

public void sendPing(ByteBuffer applicationData) throws IOException, IllegalArgumentException
Description copied from interface: `jakarta.websocket.RemoteEndpoint`
Send a ping message blocking until the message has been sent. Note that if a message is in the process of being sent asynchronously, this method will block until that message and this ping has been sent.

Specified by:
  `sendPing` in interface `RemoteEndpoint`
Parameters:
  `applicationData` - The payload for the ping message
Throws:
  `IOException` - If an I/O error occurs while sending the ping
  `IllegalArgumentException` - if the applicationData is too large for a control message (max 125 bytes)

### sendPong

public void sendPong(ByteBuffer applicationData) throws IOException, IllegalArgumentException
Description copied from interface: `jakarta.websocket.RemoteEndpoint`
Send a pong message blocking until the message has been sent. Note that if a message is in the process of being sent asynchronously, this method will block until that message and this pong has been sent.

Specified by:
  `sendPong` in interface `RemoteEndpoint`
Parameters:
  `applicationData` - The payload for the pong message
Throws:
  `IOException` - If an I/O error occurs while sending the pong
  `IllegalArgumentException` - if the applicationData is too large for a control message (max 125 bytes)

### sendString

public void sendString(String text) throws IOException

Throws:
  `IOException`

### sendStringByFuture

public Future<Void> sendStringByFuture(String text)

### sendStringByCompletion

public void sendStringByCompletion(String text, SendHandler handler)

### sendPartialString

public void sendPartialString(String fragment, boolean isLast) throws IOException

Throws:
  `IOException`

### getSendStream

public OutputStream getSendStream()

### getSendWriter

public Writer getSendWriter()

### acquireMessagePartInProgressSemaphore

protected boolean acquireMessagePartInProgressSemaphore(byte opCode, long timeoutExpiry) throws InterruptedException
Acquire the semaphore that allows a message part to be written.

Parameters:
  `opCode` - The OPCODE for the message to be written
  `timeoutExpiry` - The time when the attempt to acquire the semaphore should expire
Returns:
  `true` if the semaphore is obtained, otherwise `false`.
Throws:
  `InterruptedException` - If the wait for the semaphore is interrupted

### updateStats

protected void updateStats(long payloadLength)
Hook for updating server side statistics. Called on every frame written (including when batching is enabled and the frames are buffered locally until the buffer is full or is flushed).

Parameters:
  `payloadLength` - Size of message payload

### sendObject

public void sendObject(Object obj) throws IOException, EncodeException

Throws:
  `IOException`
  `EncodeException`

### sendObjectByFuture

public Future<Void> sendObjectByFuture(Object obj)

### sendObjectByCompletion

public void sendObjectByCompletion(Object obj, SendHandler completion)

### setSession

protected void setSession(WsSession wsSession)

### setEncoders

protected void setEncoders(EndpointConfig endpointConfig) throws DeploymentException

Throws:
  `DeploymentException`

### close

public final void close()

### doWrite

protected abstract void doWrite(SendHandler handler, long blockingWriteTimeoutExpiry, ByteBuffer... data)

### isMasked

protected abstract boolean isMasked()

### doClose

protected abstract void doClose()

### getLock

protected abstract Lock getLock()