Enum WsFrame

pub enum WsFrame {
    Text(String),
    Binary(Vec<u8>),
    Ping(Vec<u8>),
    Pong(Vec<u8>),
    Close(CloseData),
}

enumerates the different websocket message types

Variants

Text(String)

utf8 text

Binary(Vec<u8>)

a string of bytes

Ping(Vec<u8>)

a ping message, content must be < 125 bytes

Pong(Vec<u8>)

a pong message, content must be < 125 bytes

Close(CloseData)

a close message, with a websocket close code https://www.iana.org/assignments/websocket/websocket.xml#close-code-number

Implementations

impl WsFrame

pub fn assume<O: Into<Self>>(&mut self, oth: O)

consume another frame-type instance

pub fn as_bytes(&self) -> &[u8]

get frame data out as byte slice

pub fn as_str(&self) -> Cow<'_, str>

get frame data out as a string slice

pub fn is_text(&self) -> bool

true if frame type is WsFrame::Text

pub fn is_binary(&self) -> bool

true if frame type is WsFrame::Binary

pub fn is_ping(&self) -> bool

true if frame type is WsFrame::Ping

pub fn is_pong(&self) -> bool

true if frame type is WsFrame::Pong

pub fn is_close(&self) -> bool

true if frame type is WsFrame::Close

Trait Implementations

impl Clone for WsFrame

fn clone(&self) -> WsFrame

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WsFrame

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

Formats the value using the given formatter.

impl Default for WsFrame

fn default() -> Self

Returns the “default value” for a type.

impl From<&[u8]> for WsFrame

fn from(b: &[u8]) -> Self

Converts to this type from the input type.

impl From<&str> for WsFrame

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<Message> for WsFrame

fn from(m: Message) -> Self

Converts to this type from the input type.

impl From<String> for WsFrame

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for WsFrame

fn from(b: Vec<u8>) -> Self

Converts to this type from the input type.

impl From<WsFrame> for Message

fn from(m: WsFrame) -> Self

Converts to this type from the input type.

impl<Sub: InStreamStd> InStream<&mut WsFrame, WsFrame> for InStreamWss<Sub>

const URL_SCHEME: &'static str = SCHEME

your implementation should work with a single url scheme/protocol if you need to support multiple (i.e. ws:// vs wss://) consider using macros/code generation to DRY

fn raw_connect<C: InStreamConfig>(url: &Url2, config: C) -> Result<Self>

create a new connection / stream of this type. this function does the actual work of connecting, but it is recommended your struct provide a wrapper with a concrete config type

fn check_ready(&mut self) -> Result<bool>

process the stream to see if any remaining handshake items can be completed returns true if stream is set-up and ready to send/receive note that you can write before this function returns true but your messages may be buffered / sent later

fn remote_url(&self) -> Url2

access the remote url this connection represents

fn read(&mut self, data: &mut WsFrame) -> Result<usize>

non-blocking read. if R is an array-type, success result is number of elements read otherwise it is 1

fn write(&mut self, data: WsFrame) -> Result<usize>

buffered write. Implementors should buffer data on WouldBlock

fn flush(&mut self) -> Result<()>

blocking flush all pending buffered write data.

impl<Sub: InStreamListenerStd> InStreamListener<&mut WsFrame, WsFrame> for InStreamListenerWss<Sub>

type Stream = InStreamWss<<Sub as InStreamListenerStd>::StreamStd>

fn raw_bind<C: InStreamConfig>(url: &Url2, config: C) -> Result<Self>

begin listening on the given url spec this function does the actual work of binding, but it is recommended your struct provide a wrapper with a concrete config type

fn binding(&self) -> Url2

access the url for the bound interface

fn accept( &mut self, ) -> Result<<Self as InStreamListener<&mut WsFrame, WsFrame>>::Stream>

attempt to accept a stream/socket from this binding may return Err(ErrorKind::WouldBlock.into())