Struct Envelope 

pub struct Envelope<T: Serialize> {
    pub source: String,
    pub target: String,
    pub payload: T,
    pub correlation_id: Option<String>,
}

A typed message envelope for cross-machine communication.

Envelope wraps a payload of type T with routing metadata (source, target) and an optional correlation_id for request-response patterns. It is serializable so it can be transmitted across process or network boundaries.

Examples

use gust_runtime::prelude::*;

let envelope = Envelope::new("order-service", "payment-service", 42u64)
    .with_correlation("req-001");

assert_eq!(envelope.source, "order-service");
assert_eq!(envelope.target, "payment-service");
assert_eq!(envelope.payload, 42u64);
assert_eq!(envelope.correlation_id.as_deref(), Some("req-001"));

Fields

source: String

The identifier of the sending machine or service.

target: String

The identifier of the intended recipient machine or service.

payload: T

The message payload.

correlation_id: Option<String>

An optional correlation identifier for matching requests to responses.

Implementations

impl<T: Serialize> Envelope<T>

pub fn new( source: impl Into<String>, target: impl Into<String>, payload: T, ) -> Self

Creates a new envelope with the given source, target, and payload.

The correlation_id is initially None. Use with_correlation to set it.

pub fn with_correlation(self, id: impl Into<String>) -> Self

Sets the correlation identifier on this envelope (builder pattern).

Correlation IDs are useful for matching asynchronous responses back to the original request.

Trait Implementations

impl<T: Clone + Serialize> Clone for Envelope<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Serialize> Debug for Envelope<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Envelope<T>

where T: Deserialize<'de> + Serialize,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for Envelope<T>

where T: Serialize + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.