Struct Message 

pub struct Message<H, P> {
    pub headers: H,
    pub body: P,
}

One incoming message together with its decoded typed header contract.

As a Handle input (Message<OrderHeaders, Order>), the core decodes the payload and the headers in the same stage, under the same on_failure(decode = ..) policy as the payload alone, and the body receives ready values. The pairing is structural: each consumer declares the contract it reads, so two subscribers of one subject may read different header sets.

As a reply type (Handle<In, Message<EventHeaders, Confirmation>>), the reply’s headers ride the value: the runtime serializes the contract into the outgoing headers and the payload through the reply codec.

Examples

use ruststream::memory::prelude::*;
use serde::Deserialize;

#[derive(Deserialize, schemars::JsonSchema)]
struct OrderHeaders {
    tenant: String,
}

#[derive(Deserialize, schemars::JsonSchema)]
struct Order {
    id: u64,
}

struct Bill;

/// The payload and its header contract arrive decoded together.
impl Handle<Message<OrderHeaders, Order>> for Bill {
    async fn handle(
        &self,
        msg: &Message<OrderHeaders, Order>,
        _outs: &(),
        _ctx: &mut Context<'_>,
    ) -> Result<(), HandlerOutcome> {
        tracing::info!(order = msg.body.id, tenant = msg.headers.tenant, "billed");
        Ok(())
    }
}

fn app() -> RustStream {
    RustStream::new(AppInfo::new("billing", "0.1.0")).with_broker(MemoryBroker::new(), |b| {
        b.include(subscriber("orders", Bill).build());
    })
}

Fields

headers: H

The decoded header contract.

body: P

The decoded payload.

Implementations

impl<H, P> Message<H, P>

pub const fn new(headers: H, body: P) -> Message<H, P>

Pairs a header contract with a payload.

Trait Implementations

impl<H, P> Clone for Message<H, P>

where H: Clone, P: Clone,

fn clone(&self) -> Message<H, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H, P> Debug for Message<H, P>

where H: Debug, P: Debug,

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

Formats the value using the given formatter.

impl<H, P> Eq for Message<H, P>

where H: Eq, P: Eq,

impl<H, P> Hash for Message<H, P>

where H: Hash, P: Hash,

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

where __H: Hasher,

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<H, P> Input for Message<H, P>

where H: DeserializeOwned + Send + Sync + 'static, P: DeserializeOwned + Send + Sync + 'static,

type Axis = SoloPair<H, P>

The lifetime-free marker every machinery projection hangs off.

impl<H, P> PartialEq for Message<H, P>

where H: PartialEq, P: PartialEq,

fn eq(&self, other: &Message<H, P>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<H, P> ReplyShape for Message<H, P>

where H: Serialize + Send + Sync, P: Serialize + Send + Sync,

type Wire = EncodedReply

The reply’s wire: EncodedReply or SerializedReply.

impl<H, P> StructuralPartialEq for Message<H, P>

where H: PartialEq, P: PartialEq,