Struct websocket_base::codec::ws::DataFrameCodec

pub struct DataFrameCodec<D> { /* private fields */ }

A codec for decoding and encoding websocket dataframes.

This codec decodes dataframes into the crates default implementation of Dataframe but can encode and send any struct that implements the ws::Dataframe trait. The type of struct to encode is given by the D type parameter in the struct.

Using dataframes directly is meant for users who want low-level access to the connection. If you don’t want to do anything low-level please use the MessageCodec codec instead, or better yet use the ClientBuilder to make clients and the Server to make servers.

Implementations

impl DataFrameCodec<DataFrame>

pub fn default(context: Context) -> Self

Create a new DataFrameCodec struct using the crate’s implementation of dataframes for reading and writing dataframes.

Use this method if you don’t want to provide a custom implementation for your dataframes.

impl<D> DataFrameCodec<D>

pub fn new(context: Context) -> DataFrameCodec<D>

Create a new DataFrameCodec struct using any implementation of ws::Dataframe you want. This is useful if you want to manipulate the websocket layer very specifically.

If you only want to be able to send and receive the crate’s DataFrame struct use .default(Context) instead.

There is a default dataframe size limit imposed. Use new_with_limits to override it

pub fn new_with_limits(
    context: Context,
    max_dataframe_size: usize
) -> DataFrameCodec<D>

Trait Implementations

impl<D> Decoder for DataFrameCodec<D>

type Item = DataFrame

The type of decoded frames.

type Error = WebSocketError

The type of unrecoverable frame decoding errors.

fn decode(
    &mut self,
    src: &mut BytesMut
) -> Result<Option<Self::Item>, Self::Error>

Attempts to decode a frame from the provided buffer of bytes.

fn decode_eof(
    &mut self,
    buf: &mut BytesMut
) -> Result<Option<Self::Item>, Self::Error>

A default method available to be called when there are no more bytes available to be read from the underlying I/O.

fn framed<T>(self, io: T) -> Framed<T, Self> where
    T: AsyncRead + AsyncWrite,
    Self: Encoder, 

Provides a Stream and Sink interface for reading and writing to this Io object, using Decode and Encode to read and write the raw data.

impl<D> Encoder for DataFrameCodec<D> where
    D: Borrow<dyn DataFrameTrait>, 

type Item = D

The type of items consumed by the Encoder

type Error = WebSocketError

The type of encoding errors.

fn encode(
    &mut self,
    item: Self::Item,
    dst: &mut BytesMut
) -> Result<(), Self::Error>

Encodes a frame into the buffer provided.