Enum ActAddress 

pub enum ActAddress {
    FutureSelf {
        entity: Uuid,
    },
    Peer {
        lct_id: Uuid,
    },
    Citizen {
        lct_id: Uuid,
    },
    Role {
        role: String,
    },
    Society {
        lct_id: Uuid,
    },
}

Where an act is addressed — the recipient and its MRH relevance horizon in one typed field: “the MRH scope is the addressing” (HUB). This mirrors the hub-track HubEvent::ReferencedAct { to: ActAddress, .. } so the core act and the hub envelope agree on the recipient model. A hub→citizen notification is just this act reversed (from = hub, to = Citizen).

Variants

FutureSelf

Another instance of the plural self (next wake / post-compaction) — a memory write. MRH = temporal.

Fields

entity: Uuid

Peer

A peer cell (machine/track LCT) — a handoff. MRH = lateral.

Fields

lct_id: Uuid

Citizen

A specific citizen of this society — the notification case (hub→citizen). MRH = lateral.

Fields

lct_id: Uuid

Role

A role; fans out to its current holders. MRH = broad.

Fields

role: String

Society

The society at large — a forum post. (Contributed back: HUB’s draft has no all-citizens variant; forum-to-everyone isn’t Role fan-out.)

Fields

lct_id: Uuid

Implementations

impl ActAddress

pub fn mrh_direction(&self) -> MrhDirection

The coarse MRH axis this address reaches across.

Trait Implementations

impl Clone for ActAddress

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ActAddress

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ActAddress

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ActAddress

impl PartialEq for ActAddress

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ActAddress

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 ActAddress