Struct ObserverProgressAdvanceTransaction 

pub struct ObserverProgressAdvanceTransaction { /* private fields */ }

Ownership barrier between a validated progress advance and its durable append.

The aggregate is unreachable while the transaction is pending, so no recovery batch can read the not-yet-durable progress and no other advance can race the fired-arm plan. Consuming Self::commit applies the progress write and removes the fired arm as ONE mutation — after the caller has confirmed the durable append of the progress row, the arm-row deletion, and the wake — and consuming Self::abort returns the aggregate byte-for-byte unchanged, arm still installed, so a failed append never leaves live progress ahead of durable state or a phantom-fired arm.

Implementations

impl ObserverProgressAdvanceTransaction

pub const fn conversation_id(&self) -> ConversationId

Returns the conversation whose progress row the durable append writes.

pub const fn presented_progress(&self) -> DeliverySeq

Returns the new hard observer progress for the durable append.

pub const fn fired_arm(&self) -> Option<ObserverRecoveryArm>

Returns the fired-arm plan for the durable append.

Some names the installed arm whose durable row the same append must delete and whose parked rows the same append must wake; None means the conversation carried no arm.

pub fn commit(self) -> (ObserverRecoveryAggregate, Option<ObserverRecoveryArm>)

Applies the advance after a confirmed durable append.

The progress write and the arm removal are one mutation: the returned arm is exactly Self::fired_arm, surrendered so the caller wakes the parked rows it durably committed to waking.

pub fn abort(self) -> ObserverRecoveryAggregate

Cancels a failed durable append; neither progress nor arm changes.

Trait Implementations

impl Debug for ObserverProgressAdvanceTransaction

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

Formats the value using the given formatter.

impl Eq for ObserverProgressAdvanceTransaction

impl PartialEq for ObserverProgressAdvanceTransaction

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ObserverProgressAdvanceTransaction