Struct CeremonyDefinition

Source

pub struct CeremonyDefinition { /* private fields */ }

Implementations§

Source §

impl CeremonyDefinition

Source

pub fn new( name: CeremonyName, version: CeremonyVersion, description: Option<CeremonyDescription>, inputs: impl IntoIterator<Item = CeremonyInputDefinition>, outputs: impl IntoIterator<Item = CeremonyOutputDefinition>, states: impl IntoIterator<Item = CeremonyState>, transitions: impl IntoIterator<Item = CeremonyTransition>, steps: impl IntoIterator<Item = CeremonyStep>, guards: impl IntoIterator<Item = CeremonyGuard>, roles: impl IntoIterator<Item = CeremonyRole>, ) -> Result<Self, DomainError>

Source

pub fn steps_in_declaration_order( &self, ) -> impl Iterator<Item = &CeremonyStep> + '_

Iterate over every step in its declaration order.

Step identifiers remain indexed separately for efficient lookup; execution order is an explicit part of the ceremony definition.

Source

pub fn guards(&self) -> &BTreeMap<GuardName, CeremonyGuard>

Source

pub fn roles(&self) -> &BTreeMap<RoleId, CeremonyRole>

Source

pub fn initial_state_id(&self) -> &StateId

Source

pub fn state(&self, state_id: &StateId) -> Option<&CeremonyState>

Source

pub fn step(&self, step_id: &StepId) -> Option<&CeremonyStep>

Source

pub fn role(&self, role_id: &RoleId) -> Option<&CeremonyRole>

Source

pub fn steps_for_state( &self, state_id: &StateId, ) -> impl Iterator<Item = &CeremonyStep> + '_

Source

pub fn is_terminal_state(&self, state_id: &StateId) -> bool

Source

pub fn transition_for_trigger( &self, state_id: &StateId, trigger: &TransitionTrigger, ) -> Option<&CeremonyTransition>

Source

pub fn available_transitions( &self, state_id: &StateId, ) -> impl Iterator<Item = &CeremonyTransition> + '_

Source

pub fn role_allows(&self, role_id: &RoleId, action: &RoleAction) -> bool

Source

pub fn guards_are_satisfied( &self, transition: &CeremonyTransition, records: &BTreeMap<StepId, StepExecutionRecord>, context: &CeremonyContext, ) -> bool

Source

pub fn role_for_action(&self, action: &RoleAction) -> Option<&CeremonyRole>

Find the role authorised to perform action, if any.

Roles are scanned in id order and the first whose action set permits action is returned. Yields None when no declared role is allowed to perform it.

Source

pub fn role_id_for_step(&self, step_id: &StepId) -> Result<RoleId, DomainError>

Resolve the role authorised to execute step_id.

Fails fast with DomainError::InvariantViolated when no role is allowed to run the step — a ceremony cannot execute a step nobody owns.

Source

pub fn role_id_for_transition( &self, trigger: &TransitionTrigger, ) -> Result<RoleId, DomainError>

Resolve the role authorised to apply the transition fired by trigger.

Fails fast with DomainError::InvariantViolated when no role is allowed to apply it — a ceremony cannot advance through a transition nobody owns.

Source

pub fn next_satisfied_transition( &self, state_id: &StateId, records: &BTreeMap<StepId, StepExecutionRecord>, context: &CeremonyContext, ) -> Option<&CeremonyTransition>

Select the next transition out of state_id whose guards are all currently satisfied by records and context.

Outgoing transitions are evaluated in declaration order and the first one that is fully enabled is returned. Yields None when the state has no outgoing transition whose guards hold — either because the state is terminal or because the ceremony is not yet ready to advance.

Source

pub fn digest(&self) -> Result<CeremonyDefinitionDigest, DomainError>

The identity of this definition’s content.

Computed over canonical JSON of the whole aggregate rather than over the document it arrived in: two YAML files differing in whitespace, key order or comments describe the same working session and must agree, while any material difference must not.

Encoding the aggregate through serde rather than by hand is deliberate. A hand-written encoder that forgets a field produces two materially different definitions with one digest, and nothing would report it; here a field cannot be left out, and a field added later changes the digest, which is correct because it is material.

Canonical because serde_json maps are ordered — see serde_json_emits_sorted_keys for the guard that keeps that assumption from being silently withdrawn.

Source

pub fn choreographer_v1_digest_migration( &self, ) -> Result<CeremonyDefinitionDigestMigration, DomainError>

The verified identity transition used by the pre-rename state importer. Both identities are derived from this exact aggregate.

Source

pub fn analyze(&self) -> CeremonyValidationReport

Collect every defect in the definition instead of stopping at the first one.

A single error is enough to reject a definition but not enough to correct one. An author — human or agent — needs the full set to fix a draft in one pass.

Findings are emitted in check order, so the first blocking one is exactly the error Self::new raises.