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 of WebSocket message
cd_status_code	Optional status code to send when closing a connection. (only used if this message is of Type::Close)
payload	Main payload

Methods

impl<'a> Message<'a>

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

Create a new WebSocket message with text data

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

Create a new WebSocket message with binary data

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

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.

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

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

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

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

fn opcode(&self) -> u8

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

fn payload<'b>(&'b self) -> Cow<'b, [u8]>

fn size(&self) -> usize

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

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

impl<'a, 'b> Message<'b, &'b Message<'a>> for Message<'a>

type DataFrameIterator = Take<Repeat<&'b Message<'a>>>

fn dataframes(&'b self) -> Self::DataFrameIterator

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

Derived Implementations

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

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

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

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

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

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

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

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