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

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

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.

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.

Trait Implementations

The type of decoded frames.

The type of unrecoverable frame decoding errors. Read more

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

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

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. Read more

The type of items consumed by the Encoder

The type of encoding errors. Read more

Encodes a frame into the buffer provided. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Should always be Self

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.