Enum TraceEntry 

pub enum TraceEntry {
    Suspend(Effect),
    Resume {
        stage: Name,
        response: StageResponse,
    },
    Clock(Instant),
    Input {
        stage: Name,
        input: Box<dyn SendData>,
    },
    State {
        stage: Name,
        state: Box<dyn SendData>,
    },
    Terminated {
        stage: Name,
        reason: TerminationReason,
    },
}

An owned entry can be serialized and deserialized.

However, we need the entries in the continuation of the running program and we cannot clone, so there is a variant of this enum with the very same structure the captures only references to work around this problem: TraceEntryRef.

Variants

Suspend(Effect)

Resume

Fields

stage: Name

response: StageResponse

Clock(Instant)

Input

Fields

stage: Name

input: Box<dyn SendData>

State

Fields

stage: Name

state: Box<dyn SendData>

Terminated

Fields

stage: Name

reason: TerminationReason

Implementations

impl TraceEntry

pub fn to_json(&self) -> Value

impl TraceEntry

pub fn suspend(effect: Effect) -> Self

Construct a suspend entry.

pub fn resume(stage: impl AsRef<str>, response: StageResponse) -> Self

Construct a resume entry.

pub fn clock(instant: Instant) -> Self

Construct a clock entry.

pub fn input(stage: impl AsRef<str>, input: Box<dyn SendData>) -> Self

Construct an input entry.

pub fn state(stage: impl AsRef<str>, state: Box<dyn SendData>) -> Self

Construct a state entry.

pub fn terminated(stage: impl AsRef<str>, reason: TerminationReason) -> Self

Construct a terminated entry.

pub fn at_stage<'a, 'b: 'a>(&'b self) -> Option<&'a Name>

Trait Implementations

impl Debug for TraceEntry

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

This debug instance does not output the runnable field in the Resume case. That field is only useful for display purposes.

impl<'de> Deserialize<'de> for TraceEntry

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TraceEntry

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

Formats the value using the given formatter.

impl PartialEq for TraceEntry

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TraceEntry

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 TraceEntry