Struct websocket_base::codec::ws::MessageCodec

pub struct MessageCodec<M> where
    M: MessageTrait, { /* private fields */ }

A codec for asynchronously decoding and encoding websocket messages.

This codec decodes messages into the OwnedMessage struct, so using this the user will receive messages as OwnedMessages. However it can encode any type of message that implements the ws::Message trait (that type is decided by the M type parameter) like OwnedMessage and Message.

Warning: if you don’t know what your doing or want a simple websocket connection please use the ClientBuilder or the Server structs. You should only use this after a websocket handshake has already been completed on the stream you are using.

Example (for the high-level websocket crate)

use websocket::async::{MessageCodec, MsgCodecCtx};

let mut runtime = tokio::runtime::Builder::new().build().unwrap();
let mut input = Vec::new();
Message::text("50 schmeckels").serialize(&mut input, false);

let f = MessageCodec::default(MsgCodecCtx::Client)
    .framed(ReadWritePair(Cursor::new(input), Cursor::new(vec![])))
    .into_future()
    .map_err(|e| e.0)
    .map(|(m, _)| {
        assert_eq!(m, Some(OwnedMessage::Text("50 schmeckels".to_string())));
    });

runtime.block_on(f).unwrap();

Implementations

impl MessageCodec<OwnedMessage>

pub fn default(context: Context) -> Self

Create a new MessageCodec with a role of context (either Client or Server) to read and write messages asynchronously.

This will create the crate’s default codec which sends and receives OwnedMessage structs. The message data has to be sent to an intermediate buffer anyway so sending owned data is preferable.

If you have your own implementation of websocket messages, you can use the new method to create a codec for that implementation.

impl<M> MessageCodec<M> where
    M: MessageTrait, 

pub fn new(context: Context) -> MessageCodec<M>

Creates a codec that can encode a custom implementation of a websocket message.

If you just want to use a normal codec without a specific implementation of a websocket message, take a look at MessageCodec::default.

The codec automatically imposes default limits on message and data frame size. Use new_with_limits to override them.

pub fn new_with_limits(
    context: Context,
    max_dataframe_size: usize,
    max_message_size: usize
) -> MessageCodec<M>

Trait Implementations

impl<M> Decoder for MessageCodec<M> where
    M: MessageTrait, 

type Item = OwnedMessage

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<M> Encoder for MessageCodec<M> where
    M: MessageTrait, 

type Item = M

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.