Struct ReplayedTransition 

pub struct ReplayedTransition<Record, Step> {
    pub record: Option<Record>,
    pub record_digest: Digest,
    pub committed_step: Option<Step>,
    pub step_seq: WireU64,
}

The answer to an input this operation already accepted.

Two strengths of answer, and §12.3 rule 10 is what decides which one a caller gets:

• reproduction — above a restored checkpoint’s base_step_seq the runtime still holds the record and the step it committed, so a redelivery is answered with both;
• acknowledgement — below it, the step was never durable (§22.12) and the record may already have been reclaimed under an acked checkpoint. What survives is the ledger entry, and that is what answers: this input is step N, record D. A caller retrying a lost response learns exactly what it needed to; nothing is fabricated to fill the other two fields.

record_digest is therefore the one field that is always present — it is the identity of the transition, where record and committed_step are the (possibly reclaimed) contents of it.

Fields

record: Option<Record>

record_digest: Digest

committed_step: Option<Step>

step_seq: WireU64

Trait Implementations

impl<Record: Clone, Step: Clone> Clone for ReplayedTransition<Record, Step>

fn clone(&self) -> ReplayedTransition<Record, Step>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Record: Debug, Step: Debug> Debug for ReplayedTransition<Record, Step>

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

Formats the value using the given formatter.

impl<'de, Record, Step> Deserialize<'de> for ReplayedTransition<Record, Step>

where Record: Deserialize<'de>, Step: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Record: PartialEq, Step: PartialEq> PartialEq for ReplayedTransition<Record, Step>

fn eq(&self, other: &ReplayedTransition<Record, Step>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<Record, Step> Serialize for ReplayedTransition<Record, Step>

where Record: Serialize, Step: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Record: PartialEq, Step: PartialEq> StructuralPartialEq for ReplayedTransition<Record, Step>