Struct ExecutionReport 

#[non_exhaustive]
pub struct ExecutionReport {
    pub outcomes: Vec<CommandOutcomeRecord>,
    pub events: Vec<EventBatch>,
    pub committed: Vec<CommittedEvent<Value>>,
    pub changed: IndexMap<CaseKey, CaseRevision>,
    pub outbox: Vec<OutboxEntry>,
    pub completions: Vec<(CommandId, JournalOutcome)>,
    pub rejections: Vec<(CaseRef, DomainRejection)>,
}

What executing one turn’s batches produced.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

outcomes: Vec<CommandOutcomeRecord>

One record per envelope, in batch then envelope order.

events: Vec<EventBatch>

Event batches to append, one per committed command batch.

committed: Vec<CommittedEvent<Value>>

Every committed event, in commit order, for receipts (§17.3).

changed: IndexMap<CaseKey, CaseRevision>

Cases whose revision moved, with the revision they moved to.

outbox: Vec<OutboxEntry>

Outbox rows for the external effects that were accepted locally (§16.4).

completions: Vec<(CommandId, JournalOutcome)>

Journal completions for the commit bundle.

rejections: Vec<(CaseRef, DomainRejection)>

Domain rejections this stage decided, with the case each was aimed at. Some can only be decided here, such as a name no registry entry matches; each reaches the writing stage with the domain’s explanation, as a reducer refusal does, so the reply cannot claim it.

Implementations

impl ExecutionReport

pub fn absorb(&mut self, earlier: Self)

Folds an earlier report of the same turn into this one.

A turn that commits twice executed twice, and everything downstream of the commit reads one report: the receipts the writing stage may rest on, the refusals it must not contradict, and whether anything failed. So the halves are joined after the second commit and never before — a bundle built from a joined report would append the first half’s events a second time.

earlier goes first in every list, because commit order is the order receipts are read in. A case that moved in both halves keeps the later revision, which is the one it is at.

pub fn event_ids(&self) -> Vec<EventId>

Every event identifier the turn committed, in commit order.

pub fn all_committed(&self) -> bool

Returns true when every command committed.

pub fn any_committed(&self) -> bool

Returns true when at least one command committed.

pub fn has_unknown_outcome(&self) -> bool

Returns true when a command ended with an effect that may or may not have happened, so the turn must say “verification in progress” and a reconciler must settle it (I15).

pub fn pending_attempts(&self) -> Vec<AttemptId>

The attempts a reconciler has to settle.

pub fn failed_outright(&self) -> bool

Returns true when no command committed and at least one failed, which is what makes a receipt impossible.

pub fn any_uncommitted(&self) -> bool

Returns true when any command did not commit — a rejection, a conflict, a failure, or an outcome nobody knows yet.

This, rather than Self::failed_outright, is what makes a notice mandatory: a turn where two commands committed and a third did not is still a turn that has to say so, and receipts alone would let the user read the silence as success.

pub fn bundle(&self) -> CommitBundle

The bundle items this execution produced: journal completions, events and outbox rows.

The caller adds the card resolutions, the new cards, the replay record and the phase marker, then writes everything at once (§16.3).

Trait Implementations

impl Clone for ExecutionReport

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 ExecutionReport

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

Formats the value using the given formatter.

impl Default for ExecutionReport

fn default() -> Self

Returns the “default value” for a type.