Enum ChatMessage 

pub enum ChatMessage {
    Join {
        nickname: String,
        peer_id: [u8; 32],
        timestamp: SystemTime,
    },
    Leave {
        nickname: String,
        peer_id: [u8; 32],
        timestamp: SystemTime,
    },
    Text {
        nickname: String,
        peer_id: [u8; 32],
        text: String,
        timestamp: SystemTime,
    },
    Status {
        nickname: String,
        peer_id: [u8; 32],
        status: String,
        timestamp: SystemTime,
    },
    Direct {
        from_nickname: String,
        from_peer_id: [u8; 32],
        to_peer_id: [u8; 32],
        text: String,
        timestamp: SystemTime,
    },
    Typing {
        nickname: String,
        peer_id: [u8; 32],
        is_typing: bool,
    },
    PeerListRequest {
        peer_id: [u8; 32],
    },
    PeerListResponse {
        peers: Vec<PeerInfo>,
    },
}

Chat message types

Variants

Join

User joined the chat

Fields

nickname: String

Display name of the user

peer_id: [u8; 32]

Sender’s peer identifier

timestamp: SystemTime

Time the event occurred

Leave

User left the chat

Fields

nickname: String

Display name of the user

peer_id: [u8; 32]

Sender’s peer identifier

timestamp: SystemTime

Time the event occurred

Text

Text message from user

Fields

nickname: String

Display name of the user

peer_id: [u8; 32]

Sender’s peer identifier

text: String

UTF-8 message body

timestamp: SystemTime

Time the message was sent

Status

Status update from user

Fields

nickname: String

Display name of the user

peer_id: [u8; 32]

Sender’s peer identifier

status: String

Arbitrary status string

timestamp: SystemTime

Time the status was set

Direct

Direct message to specific peer

Fields

from_nickname: String

Sender nickname

from_peer_id: [u8; 32]

Sender peer ID

to_peer_id: [u8; 32]

Recipient peer ID

text: String

Encrypted or plain text body

timestamp: SystemTime

Time the message was sent

Typing

Typing indicator

Fields

nickname: String

Display name of the user

peer_id: [u8; 32]

Sender’s peer identifier

is_typing: bool

Whether the user is currently typing

PeerListRequest

Request peer list Request current peer list from the node

Fields

peer_id: [u8; 32]

Requestor’s peer identifier

PeerListResponse

Response with peer list Response containing current peers

Fields

peers: Vec<PeerInfo>

List of known peers and metadata

Implementations

impl ChatMessage

pub fn join(nickname: String, peer_id: PeerId) -> Self

Create a new join message

pub fn leave(nickname: String, peer_id: PeerId) -> Self

Create a new leave message

pub fn text(nickname: String, peer_id: PeerId, text: String) -> Self

Create a new text message

pub fn status(nickname: String, peer_id: PeerId, status: String) -> Self

Create a new status message

pub fn direct( from_nickname: String, from_peer_id: PeerId, to_peer_id: PeerId, text: String, ) -> Self

Create a new direct message

pub fn typing(nickname: String, peer_id: PeerId, is_typing: bool) -> Self

Create a typing indicator

pub fn serialize(&self) -> Result<Vec<u8>, ChatError>

Serialize message to bytes

pub fn deserialize(data: &[u8]) -> Result<Self, ChatError>

Deserialize message from bytes

pub fn peer_id(&self) -> Option<PeerId>

Get the peer ID from the message

pub fn nickname(&self) -> Option<&str>

Get the nickname from the message

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<'de> Deserialize<'de> for ChatMessage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 Serialize for ChatMessage

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ChatMessage