Struct ChatMessage 

pub struct ChatMessage {
    pub origin_node: u32,
    pub timestamp: u64,
    pub is_broadcast: bool,
    pub requires_ack: bool,
    pub reply_to_node: u32,
    pub reply_to_timestamp: u64,
    /* private fields */
}

A single chat message in the mesh

Messages are uniquely identified by (origin_node, timestamp). This allows deduplication across mesh sync while preserving message ordering.

Fields

origin_node: u32

Node that originated this message

timestamp: u64

Timestamp when message was created (ms since epoch)

is_broadcast: bool

Whether this is a broadcast message (vs directed)

requires_ack: bool

Whether ACK is requested

reply_to_node: u32

Reply-to: origin node of the message being replied to (0 = not a reply)

reply_to_timestamp: u64

Reply-to: timestamp of the message being replied to (0 = not a reply)

Implementations

impl ChatMessage

pub fn new(origin_node: u32, timestamp: u64, sender: &str, text: &str) -> Self

Create a new chat message

pub fn set_sender(&mut self, sender: &str)

Set the sender name (truncated to 12 bytes)

pub fn sender(&self) -> &str

Get the sender name as a string

pub fn set_text(&mut self, text: &str)

Set the message text (truncated to 128 bytes)

pub fn text(&self) -> &str

Get the message text as a string

pub fn set_reply_to(&mut self, node: u32, timestamp: u64)

Set reply-to information

pub fn is_reply(&self) -> bool

Check if this is a reply to another message

pub fn message_id(&self) -> u64

Get the unique message ID (combines origin_node and timestamp)

Format: (origin_node as u64) << 32 | (timestamp & 0xFFFFFFFF) This provides a sortable key where messages from same node are ordered by time.

pub fn encode(&self) -> Vec<u8>

Encode to bytes for transmission

Wire format:

origin_node:       4 bytes (LE)
timestamp:         8 bytes (LE)
sender_len:        1 byte
sender:            sender_len bytes
text_len:          1 byte
text:              text_len bytes
flags:             1 byte (bit 0: is_broadcast, bit 1: requires_ack)
reply_to_node:     4 bytes (LE)
reply_to_timestamp: 8 bytes (LE)

pub fn decode(data: &[u8]) -> Option<(Self, usize)>

Decode from bytes with strict validation

Returns None if the data is malformed or fails validation checks. This is a security-critical function - malformed messages could be spoofed or part of an attack.

Validation checks:

• origin_node must be non-zero
• timestamp must be non-zero and within reasonable bounds
• sender must be non-empty and valid UTF-8
• text must be valid UTF-8 (can be empty for ACK messages)
• All length fields must be within bounds

Trait Implementations

impl Clone for ChatMessage

fn clone(&self) -> ChatMessage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChatMessage

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

Formats the value using the given formatter.

impl Default for ChatMessage

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for ChatMessage

fn eq(&self, other: &ChatMessage) -> 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 StructuralPartialEq for ChatMessage