Struct WebSocket 

pub struct WebSocket<'buf, RW, Rng> { /* private fields */ }

A WebSocket connection.

Defaults:

• auto_pong: true
• auto_close: true

Implementations

impl<'buf, RW, Rng> WebSocket<'buf, RW, Rng>

pub const fn client( inner: RW, rng: Rng, read_buffer: &'buf mut [u8], write_buffer: &'buf mut [u8], fragments_buffer: &'buf mut [u8], ) -> Self

Creates a new WebSocket client after a successful handshake.

pub const fn server( inner: RW, rng: Rng, read_buffer: &'buf mut [u8], write_buffer: &'buf mut [u8], fragments_buffer: &'buf mut [u8], ) -> Self

Creates a new WebSocket server after a successful handshake.

pub async fn connect<const N: usize>( options: ConnectOptions<'_, '_>, inner: RW, rng: Rng, read_buffer: &'buf mut [u8], write_buffer: &'buf mut [u8], fragments_buffer: &'buf mut [u8], ) -> Result<Self, Error<RW::Error>>

where RW: Read + Write, Rng: RngCore,

Creates a new WebSocket client and performs the handshake.

Generic Parameters

N: The maximum number of headers to accept in the handshake response.

pub async fn connect_with<const N: usize, F, T, E>( options: ConnectOptions<'_, '_>, inner: RW, rng: Rng, read_buffer: &'buf mut [u8], write_buffer: &'buf mut [u8], fragments_buffer: &'buf mut [u8], on_response: F, ) -> Result<(Self, T), Error<RW::Error, E>>

where F: for<'a> Fn(&Response<'a, N>) -> Result<T, E>, RW: Read + Write, Rng: RngCore,

Creates a new WebSocket client and performs the handshake with a custom response handler.

Generic Parameters

N: The maximum number of headers to accept in the handshake response.

pub async fn accept<const N: usize>( options: AcceptOptions<'_, '_>, inner: RW, rng: Rng, read_buffer: &'buf mut [u8], write_buffer: &'buf mut [u8], fragments_buffer: &'buf mut [u8], ) -> Result<Self, Error<RW::Error>>

where RW: Read + Write,

Creates a new WebSocket server and performs the handshake.

Generic Parameters

N: The maximum number of headers to accept in the handshake request.

pub async fn accept_with<const N: usize, F, T, E>( options: AcceptOptions<'_, '_>, inner: RW, rng: Rng, read_buffer: &'buf mut [u8], write_buffer: &'buf mut [u8], fragments_buffer: &'buf mut [u8], on_request: F, ) -> Result<(Self, T), Error<RW::Error, E>>

where F: for<'a> Fn(&Request<'a, N>) -> Result<T, E>, RW: Read + Write,

Creates a new WebSocket server and performs the handshake with a custom request handler.

Generic Parameters

N: The maximum number of headers to accept in the handshake request.

pub const fn with_auto_pong(self, auto_pong: bool) -> Self

Sets whether to automatically send a Pong response.

pub const fn with_auto_close(self, auto_close: bool) -> Self

Sets whether to automatically close the connection on receiving a Close frame.

pub const fn inner(&self) -> &RW

Returns reference to the reader/writer.

pub const fn inner_mut(&mut self) -> &mut RW

Returns mutable reference to the reader/writer.

pub fn into_inner(self) -> RW

Consumes the WebSocket and returns the reader/writer.

pub const fn framable(&self) -> usize

Returns the number of bytes that can be framed.

pub async fn send( &mut self, message: Message<'_>, ) -> Result<(), Error<RW::Error>>

where RW: Write, Rng: RngCore,

Sends a WebSocket message.

pub async fn send_fragmented( &mut self, message: Message<'_>, fragment_size: usize, ) -> Result<(), Error<RW::Error>>

where RW: Write, Rng: RngCore,

Sends a fragmented WebSocket message.

pub fn split_with<F, R, W>( self, split: F, ) -> (WebSocketRead<'buf, R>, WebSocketWrite<'buf, W, Rng>)

where F: FnOnce(RW) -> (R, W),

Splits the WebSocket into a WebSocketRead and a WebSocketWrite with the provided split function.

Note

auto_pong and auto_close will NOT be applied to the split instances.

Trait Implementations

impl<'buf, RW: Debug, Rng: Debug> Debug for WebSocket<'buf, RW, Rng>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.