Enum Message 

pub enum Message {
    Text {
        data: String,
    },
    Binary {
        data: Vec<u8>,
    },
    Ping,
    Pong,
    Close {
        code: u16,
        reason: String,
    },
}

Available on crate feature websockets and non-WebAssembly only.

WebSocket message types

Variants

Text

A UTF-8 text message.

Fields

data: String

The text content of the message.

Binary

A binary message.

Fields

data: Vec<u8>

The raw bytes of the message.

Ping

A ping control frame.

Pong

A pong control frame (response to ping).

Close

A close control frame with status code and reason.

Fields

code: u16

The WebSocket close status code.

reason: String

A human-readable reason for closing.

Implementations

impl Message

pub fn text(data: String) -> Message

Creates a new text message.

Examples

use reinhardt_websockets::Message;

let msg = Message::text("Hello, World!".to_string());
match msg {
    Message::Text { data } => assert_eq!(data, "Hello, World!"),
    _ => panic!("Expected text message"),
}

pub fn binary(data: Vec<u8>) -> Message

Creates a new binary message.

Examples

use reinhardt_websockets::Message;

let data = vec![0x48, 0x65, 0x6c, 0x6c, 0x6f]; // "Hello" in bytes
let msg = Message::binary(data.clone());
match msg {
    Message::Binary { data: d } => assert_eq!(d, data),
    _ => panic!("Expected binary message"),
}

pub fn json<T>(data: &T) -> Result<Message, WebSocketError>

where T: Serialize,

Creates a text message containing JSON-serialized data.

Examples

use reinhardt_websockets::Message;
use serde::Serialize;

#[derive(Serialize)]
struct User {
    name: String,
    age: u32,
}

let user = User {
    name: "Alice".to_string(),
    age: 30,
};

let msg = Message::json(&user).unwrap();
match msg {
    Message::Text { data } => {
        assert!(data.contains("Alice"));
        assert!(data.contains("30"));
    },
    _ => panic!("Expected text message"),
}

pub fn parse_json<T>(&self) -> Result<T, WebSocketError>

where T: DeserializeOwned,

Parses the message content as JSON into the target type.

Examples

use reinhardt_websockets::Message;
use serde::Deserialize;

#[derive(Deserialize, Debug, PartialEq)]
struct User {
    name: String,
    age: u32,
}

let msg = Message::text(r#"{"name":"Bob","age":25}"#.to_string());
let user: User = msg.parse_json().unwrap();
assert_eq!(user.name, "Bob");
assert_eq!(user.age, 25);

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Message

fn deserialize<__D>( __deserializer: __D, ) -> Result<Message, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Message

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Message

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Message