Struct websocket::message::Message

pub struct Message<'a> {
    pub opcode: Type,
    pub cd_status_code: Option<u16>,
    pub payload: Cow<'a, [u8]>,
}

Represents a WebSocket message.

This message also has the ability to not own its payload, and stores its entire payload in chunks that get written in order when the message gets sent. This makes the write_payload allocate less memory than the payload method (which creates a new buffer every time).

Incidentally this (the default implementation of Message) implements the DataFrame trait because this message just gets sent as one single DataFrame.

Fields

opcode: Type

Type of WebSocket message

cd_status_code: Option<u16>

Optional status code to send when closing a connection. (only used if this message is of Type::Close)

payload: Cow<'a, [u8]>

Main payload

Methods

impl<'a> Message<'a>

pub fn text<S>(data: S) -> Self where     S: Into<Cow<'a, str>>,

Create a new WebSocket message with text data

pub fn binary<B>(data: B) -> Self where     B: IntoCowBytes<'a>,

Create a new WebSocket message with binary data

pub fn close() -> Self

Create a new WebSocket message that signals the end of a WebSocket connection, although messages can still be sent after sending this

pub fn close_because<S>(code: u16, reason: S) -> Self where     S: Into<Cow<'a, str>>,

Create a new WebSocket message that signals the end of a WebSocket connection and provide a text reason and a status code for why. Messages can still be sent after sending this message.

pub fn ping<P>(data: P) -> Self where     P: IntoCowBytes<'a>,

Create a ping WebSocket message, a pong is usually sent back after sending this with the same data

pub fn pong<P>(data: P) -> Self where     P: IntoCowBytes<'a>,

Create a pong WebSocket message, usually a response to a ping message

pub fn into_pong(&mut self) -> Result<(), ()>

Convert a ping message to a pong, keeping the data. This will fail if the original message is not a ping.

Trait Implementations

impl<'a> DataFrame for Message<'a>

fn is_last(&self) -> bool

Is this dataframe the final dataframe of the message?

fn opcode(&self) -> u8

What type of data does this dataframe contain?

fn reserved(&self) -> &[bool; 3]

Reserved bits of this dataframe

fn size(&self) -> usize

How long (in bytes) is this dataframe's payload

fn write_payload(&self, socket: &mut dyn Write) -> WebSocketResult<()>

Write the payload to a writer

Important traits for Vec<u8>

impl Write for Vec<u8>

fn take_payload(self) -> Vec<u8>

Takes the payload out into a vec

fn frame_size(&self, masked: bool) -> usize

Get's the size of the entire dataframe in bytes, i.e. header and payload.

fn write_to(&self, writer: &mut dyn Write, mask: bool) -> WebSocketResult<()>

Writes a DataFrame to a Writer.

impl<'a> Message for Message<'a>

fn serialize(&self, writer: &mut dyn Write, masked: bool) -> WebSocketResult<()>

Attempt to form a message from a series of data frames

fn message_size(&self, masked: bool) -> usize

Returns how many bytes this message will take up

fn from_dataframes<D>(frames: Vec<D>) -> WebSocketResult<Self> where     D: DataFrameTrait,

Attempt to form a message from a series of data frames

impl<'a> PartialEq<Message<'a>> for Message<'a>

fn eq(&self, other: &Message<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Message<'a>) -> bool

This method tests for !=.

impl<'m> From<Message<'m>> for OwnedMessage

fn from(message: Message<'m>) -> Self

Performs the conversion.

impl<'m> From<OwnedMessage> for Message<'m>

fn from(message: OwnedMessage) -> Self

Performs the conversion.

impl<'a> Clone for Message<'a>

fn clone(&self) -> Message<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Eq for Message<'a>

impl<'a> Debug for Message<'a>

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

Formats the value using the given formatter.