Struct EventLedger 

pub struct EventLedger { /* private fields */ }

Ordered store of events grouped by run, allocating sequence numbers.

Examples

let mut ledger = EventLedger::new();
let run = Ref::Symbol(Symbol::new("run"));
let request = Ref::Symbol(Symbol::new("request"));
let started = ledger.started(run.clone(), request).unwrap();
let done = ledger.done(run.clone()).unwrap();
assert_eq!(started.seq, 0);
assert_eq!(done.seq, 1);
assert_eq!(ledger.len_for_run(&run), 2);

Implementations

impl EventLedger

pub fn new() -> Self

Create an empty ledger.

pub fn len(&self) -> usize

Total number of events across all runs.

pub fn is_empty(&self) -> bool

Whether the ledger holds no events.

pub fn len_for_run(&self, run: &Ref) -> usize

Number of events recorded for run.

pub fn events_for_run(&self, run: &Ref) -> &[Event]

Events recorded for run, in order.

pub fn iter(&self) -> impl Iterator<Item = &Event>

Iterate over all events across all runs.

pub fn push(&mut self, run: Ref, kind: EventKind) -> Result<Event>

Append an event of kind to run with no ticks.

pub fn push_with_ticks( &mut self, run: Ref, ticks: Vec<Tick>, kind: EventKind, ) -> Result<Event>

Append an event of kind to run carrying the given ticks.

pub fn started(&mut self, run: Ref, request: Ref) -> Result<Event>

Append a EventKind::Started event to run.

pub fn final_value(&mut self, run: Ref, value: Ref) -> Result<Event>

Append a EventKind::Final event to run.

pub fn failed(&mut self, run: Ref, error: Ref) -> Result<Event>

Append a EventKind::Failed event to run.

pub fn done(&mut self, run: Ref) -> Result<Event>

Append a EventKind::Done event to run.

Trait Implementations

impl Clone for EventLedger

fn clone(&self) -> EventLedger

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventLedger

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

Formats the value using the given formatter.

impl Default for EventLedger

fn default() -> EventLedger

Returns the “default value” for a type.