Struct Message 

pub struct Message<T> { /* private fields */ }

A message envelope that wraps a payload with an ID and metadata.

This is the primary type for exactly-once processing. It provides:

• A unique identifier for deduplication
• Metadata for tracking and routing
• The actual payload

Type Parameters

• T: The payload type

Example

use streamweave::message::{Message, MessageId, MessageMetadata};

// Create a simple message
let msg = Message::new(42, MessageId::new_uuid());

// Create a message with metadata
let msg = Message::with_metadata(
    "hello",
    MessageId::new_sequence(1),
    MessageMetadata::with_timestamp_now().source("my-source")
);

Implementations

impl<T> Message<T>

pub fn new(payload: T, id: MessageId) -> Self

Create a new message with the given payload and ID.

pub fn with_metadata( payload: T, id: MessageId, metadata: MessageMetadata, ) -> Self

Create a new message with payload, ID, and metadata.

pub fn id(&self) -> &MessageId

Get the message ID.

pub fn payload(&self) -> &T

Get the payload.

pub fn payload_mut(&mut self) -> &mut T

Get a mutable reference to the payload.

pub fn metadata(&self) -> &MessageMetadata

Get the metadata.

pub fn metadata_mut(&mut self) -> &mut MessageMetadata

Get a mutable reference to the metadata.

pub fn into_parts(self) -> (MessageId, T, MessageMetadata)

Consume the message and return its components.

pub fn into_payload(self) -> T

Consume the message and return just the payload.

pub fn map<U, F>(self, f: F) -> Message<U>

where F: FnOnce(T) -> U,

Map the payload to a new type.

pub fn map_with_id<U, F>(self, f: F) -> Message<U>

where F: FnOnce(&MessageId, T) -> U,

Map the payload to a new type, with access to the message ID.

pub fn with_payload<U>(self, payload: U) -> Message<U>

Replace the payload with a new value.

Trait Implementations

impl<T: Clone> Clone for Message<T>

fn clone(&self) -> Message<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Message<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Message<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Hash> Hash for Message<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq for Message<T>

fn eq(&self, other: &Self) -> 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<T: Eq> Eq for Message<T>