Struct Message 

pub struct Message {

    pub id: MessageId,
    pub sender: UserId,
    pub recipient: UserId,
    pub app_id: AppId,
    pub priority: MessagePriority,
    pub ttl: TTL,
    pub hop_count: HopCount,
    pub timestamp: Timestamp,
    pub lamport_clock: LamportClock,
    pub content_type: ContentType,
    pub content: String,
    pub binary_content: Option<Vec<u8>>,
    pub media_metadata: Option<MediaMetadata>,
    pub metadata: HashMap<String, String>,
    pub requires_ack: bool,
    pub reply_to_msg: Option<MessageId>,
    pub forwarded_from: Option<ForwardInfo>,
    pub reply_context: Option<ReplyContext>,
    /* private fields */
}

A message in the Offline Protocol.

Fields

id: MessageId

Unique message identifier.

sender: UserId

Sender’s user ID.

recipient: UserId

Recipient’s user ID.

app_id: AppId

Application ID that this message belongs to.

priority: MessagePriority

Message priority.

ttl: TTL

Time-to-live: maximum hops remaining.

hop_count: HopCount

Number of hops this message has traversed.

timestamp: Timestamp

Timestamp when the message was created (wall-clock, for display only).

lamport_clock: LamportClock

Lamport logical clock for causal ordering across devices.

content_type: ContentType

The type of content this message carries.

content: String

Message content (text, JSON-serialized file chunk metadata, etc.).

binary_content: Option<Vec<u8>>

Raw payload for file chunk data carried by the message envelope. This avoids wrapping chunk bytes in FileChunk JSON/base64 content. Note: current transport serialization still uses JSON for Message.

media_metadata: Option<MediaMetadata>

Media metadata (present for non-text content types).

metadata: HashMap<String, String>

Optional metadata for application-specific use.

requires_ack: bool

Whether this message requires an ACK.

reply_to_msg: Option<MessageId>

ID of the message this is replying to (optional).

forwarded_from: Option<ForwardInfo>

Forwarding attribution (present when this message was forwarded from another user).

reply_context: Option<ReplyContext>

Quoted-reply context (present when this message quotes another).

Implementations

impl Message

pub fn new( sender: UserId, recipient: UserId, app_id: AppId, content: impl Into<String>, ) -> Self

Creates a new message.

Arguments

• sender - Sender’s user ID
• recipient - Recipient’s user ID
• app_id - Application ID
• content - Message content

pub fn builder( sender: UserId, recipient: UserId, app_id: AppId, ) -> MessageBuilder

Creates a message builder for more control over message creation.

pub fn increment_hop(&mut self) -> Result<()>

Increments the hop count.

Returns

Returns Ok(()) if successful, Err if hop count overflows.

pub fn decrement_ttl(&mut self) -> Result<()>

Decrements the TTL.

Returns

Returns Ok(()) if successful, Err if TTL is exhausted.

pub fn is_ttl_exhausted(&self) -> bool

Checks if the message’s TTL is exhausted.

pub fn to_json(&self) -> Result<String>

Serializes the message to JSON.

pub fn from_json(json: &str) -> Result<Self>

Deserializes a message from JSON.

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

Returns the transport-verified peer identity, if set.

pub fn wire_codec(&self) -> WireCodec

Returns the wire codec selected for this message’s next serialization.

pub fn to_bytes(&self) -> Result<Vec<u8>>

Serializes the message to binary (MessagePack-like JSON bytes).

pub fn from_bytes(bytes: &[u8]) -> Result<Self>

Deserializes a message from binary.

pub fn to_wire_v1_bytes(&self) -> Result<Vec<u8>>

Serializes the message using the compact binary wire codec (v1).

See crate::wire for the format. This is an additive alternative to to_bytes (JSON); the two are distinguishable by their first byte, so a receiver can accept either without negotiation.

pub fn from_wire_v1_bytes(data: &[u8]) -> Result<Self>

Deserializes a message from a compact binary wire frame (v1).

Runs the same identifier and Lamport-clock validation as the JSON path by routing every field through its validating constructor, so a hostile binary frame is rejected identically to a hostile JSON one. The transport-verified peer identity is never on the wire and is left unset.

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

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Message

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

where __S: Serializer,

Serialize this value into the given Serde serializer.