Struct CauseCapsuleParts 

pub struct CauseCapsuleParts<'a> {
    pub event_id: EventId,
    pub parents: &'a [EventId],
    pub relationship: RelationshipKind,
    pub cause_kind: CauseKind,
    pub action: OperationAction,
    pub authority: Option<CapabilityRef>,
    pub policy_epoch: Option<PolicyEpoch>,
}

Compact event capsule for causal parentage.

Fields

event_id: EventId

Local event identifier.

parents: &'a [EventId]

Parent event identifiers.

The compact capsule uses the same RelationshipKind for every parent. Use separate capsules when parents need different relationship meanings.

relationship: RelationshipKind

Relationship used for every parent in this compact capsule.

cause_kind: CauseKind

Observable cause class.

action: OperationAction

Requested action.

authority: Option<CapabilityRef>

Optional authority reference.

policy_epoch: Option<PolicyEpoch>

Optional policy epoch reference.

Trait Implementations

impl<'a> Clone for CauseCapsuleParts<'a>

fn clone(&self) -> CauseCapsuleParts<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for CauseCapsuleParts<'a>

impl<'a> Debug for CauseCapsuleParts<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for CauseCapsuleParts<'a>

impl<'a> PartialEq for CauseCapsuleParts<'a>

fn eq(&self, other: &CauseCapsuleParts<'a>) -> 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<'a> StructuralPartialEq for CauseCapsuleParts<'a>