Struct CompressedWebSocketStream 

pub struct CompressedWebSocketStream<S> { /* private fields */ }

A WebSocket stream with permessage-deflate compression (RFC 7692)

This type mirrors WebSocketStream but uses CompressedProtocol for automatic compression/decompression of messages.

Implementations

impl<S> CompressedWebSocketStream<S>

where S: AsyncRead + AsyncWrite + Unpin,

pub fn server(inner: S, config: Config, deflate_config: DeflateConfig) -> Self

Create a new compressed WebSocket stream for server role

pub fn client(inner: S, config: Config, deflate_config: DeflateConfig) -> Self

Create a new compressed WebSocket stream for client role

pub fn is_closed(&self) -> bool

Check if the connection is closed

pub fn is_backpressured(&self) -> bool

Check if backpressure should be applied

pub fn write_buffer_len(&self) -> usize

Get the current write buffer length

pub async fn close(&mut self, code: u16, reason: &str) -> Result<()>

Send a close frame

impl<S> CompressedWebSocketStream<S>

where S: AsyncRead + AsyncWrite + Unpin,

pub fn split(self) -> (CompressedSplitReader<S>, CompressedSplitWriter<S>)

Split the compressed WebSocket stream into separate read and write halves

This allows TRUE concurrent reading and writing from different tasks with ZERO lock contention. The underlying TCP stream is split at the OS level for maximum performance.

Both halves maintain compression/decompression state independently:

• Reader has the decoder for decompressing incoming messages
• Writer has the encoder for compressing outgoing messages

Example

let (mut reader, mut writer) = compressed_ws.split();

// Read in one task - NEVER blocks writer
tokio::spawn(async move {
    while let Some(msg) = reader.next().await {
        println!("Got: {:?}", msg);
    }
});

// Write in another - NEVER blocks reader
writer.send(Message::Text("Hello".into())).await?;

Trait Implementations

impl<S> Sink<Message> for CompressedWebSocketStream<S>

where S: AsyncRead + AsyncWrite + Unpin,

Available on crate feature permessage-deflate only.

type Error = Error

The type of value produced by the sink when an error occurs.

fn poll_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<()>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: Message) -> Result<()>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Flush any remaining output from this sink.

fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Flush any remaining output and close this sink, if necessary.

impl<S> Stream for CompressedWebSocketStream<S>

where S: AsyncRead + AsyncWrite + Unpin,

Available on crate feature permessage-deflate only.

type Item = Result<Message, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'__pin, S> Unpin for CompressedWebSocketStream<S>

where PinnedFieldsOf<__Origin<'__pin, S>>: Unpin,