Enum StageTransition 

pub enum StageTransition {
    Create {
        sig_id: SigId,
        stage_id: StageId,
    },
    Replace {
        sig_id: SigId,
        from: StageId,
        to: StageId,
    },
    Remove {
        sig_id: SigId,
        last: StageId,
    },
    Rename {
        from: SigId,
        to: SigId,
        body_stage_id: StageId,
    },
    ImportOnly,
    Merge {
        entries: BTreeMap<SigId, Option<StageId>>,
    },
}

Effect of applying an operation on a stage’s content-addressed identity. Used as the produces field of an OperationRecord so consumers can answer “after this op, what’s the head stage for this SigId?” without rerunning the apply step.

Variants

Create

New SigId; produces a stage that didn’t exist before.

Fields

sig_id: SigId

stage_id: StageId

Replace

Existing SigId; replaces its head stage.

Fields

sig_id: SigId

from: StageId

to: StageId

Remove

SigId removed; no head stage afterwards.

Fields

sig_id: SigId

last: StageId

Rename

SigId renamed; same body hash, different signature identity.

Fields

from: SigId

to: SigId

body_stage_id: StageId

ImportOnly

Import-only change; doesn’t touch any stage.

Merge

Merge op result. entries lists only the sigs whose head changed relative to the merge op’s first parent (dst_head): Some(stage_id) sets the head; None removes the sig. Sigs unaffected by the merge are not listed.

Canonical-form contract: BTreeMap is load-bearing — iteration is sorted by SigId, so on-disk JSON for two callers that resolved the same conflicts in different orders produces byte-identical output. Switching to HashMap here would break canonical stability of the OperationRecord JSON file and is rejected by the canonical-form spec in crate::canonical.

Fields

entries: BTreeMap<SigId, Option<StageId>>

Implementations

impl StageTransition

pub fn stage_ids(&self) -> Vec<StageId>

Every stage id this transition references — the content-addressed blobs a peer needs alongside the op record to render or replay it. Used by op push/pull to sync stage objects, not just op records.

pub fn stage_pairs(&self) -> Vec<(SigId, StageId)>

Every (sig_id, stage_id) pair this transition references (#986).

A StageId hashes the structural signature plus the implementation and deliberately not the name (#826), so two functions differing only in name share one StageId while having two distinct SigIds — and two separate ASTs, one stored under each sig. Rendering therefore resolves a stage through crate’s (sig, stage) pair, never the id alone.

Self::stage_ids is consequently not enough for object sync: asking a peer “do you have this stage id?” can answer yes while the variant the head actually names is absent. Sync paths should use these pairs.

Trait Implementations

impl Clone for StageTransition

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 StageTransition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StageTransition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for StageTransition

impl PartialEq for StageTransition

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for StageTransition

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 StageTransition