Struct InMemoryJournal 

pub struct InMemoryJournal<M, E, C> { /* private fields */ }

Available on crate feature journal only.

An in-memory journal of TransitionRecord values.

Implementations

impl<M, E, C> InMemoryJournal<M, E, C>

pub const fn new() -> Self

Creates an empty journal.

Examples found in repository

examples/replay.rs (line 91)

fn main() {
    let instrument = LabInstrument;
    let mut runner = Runner::new(&instrument);

    let events = [
        Event::PowerOn,
        Event::SensorReady,
        Event::BeginMeasurement,
        Event::DataCollected,
        Event::DataCollected,
        Event::AnomalyDetected,
        Event::OperatorReset,
        Event::BeginMeasurement,
    ];

    // Record every transition in the journal
    let mut journal: InMemoryJournal<Mode, Event, Command> = InMemoryJournal::new();

    println!("--- Recording transitions ---\n");
    for event in events {
        let from = runner.mode().clone();
        let commands = runner.feed(&event);
        let to = runner.mode().clone();

        println!("  {from:?} + {event:?} => {to:?}");
        if !commands.is_empty() {
            println!("    commands: {commands:?}");
        }

        journal.record_step(&from, &to, &event, &commands);
    }

    println!("\n--- Journal: {} records ---\n", journal.len());
    for record in journal.records() {
        println!(
            "  step {}: {:?} => {:?} (via {:?})",
            record.step, record.from, record.to, record.event,
        );
    }

    // Replay: feed the same events through a fresh machine and verify
    println!("\n--- Replaying ---\n");
    match journal.replay(&instrument, instrument.initial_mode()) {
        Ok(final_mode) => {
            println!("  replay verified: final mode = {final_mode:?}");
            assert_eq!(final_mode, runner.mode().clone());
        }
        Err(err) => {
            println!("  {err}");
        }
    }
}

pub fn len(&self) -> usize

Returns the number of records in the journal.

Examples found in repository

examples/replay.rs (line 107)

fn main() {
    let instrument = LabInstrument;
    let mut runner = Runner::new(&instrument);

    let events = [
        Event::PowerOn,
        Event::SensorReady,
        Event::BeginMeasurement,
        Event::DataCollected,
        Event::DataCollected,
        Event::AnomalyDetected,
        Event::OperatorReset,
        Event::BeginMeasurement,
    ];

    // Record every transition in the journal
    let mut journal: InMemoryJournal<Mode, Event, Command> = InMemoryJournal::new();

    println!("--- Recording transitions ---\n");
    for event in events {
        let from = runner.mode().clone();
        let commands = runner.feed(&event);
        let to = runner.mode().clone();

        println!("  {from:?} + {event:?} => {to:?}");
        if !commands.is_empty() {
            println!("    commands: {commands:?}");
        }

        journal.record_step(&from, &to, &event, &commands);
    }

    println!("\n--- Journal: {} records ---\n", journal.len());
    for record in journal.records() {
        println!(
            "  step {}: {:?} => {:?} (via {:?})",
            record.step, record.from, record.to, record.event,
        );
    }

    // Replay: feed the same events through a fresh machine and verify
    println!("\n--- Replaying ---\n");
    match journal.replay(&instrument, instrument.initial_mode()) {
        Ok(final_mode) => {
            println!("  replay verified: final mode = {final_mode:?}");
            assert_eq!(final_mode, runner.mode().clone());
        }
        Err(err) => {
            println!("  {err}");
        }
    }
}

pub fn is_empty(&self) -> bool

Returns true if the journal is empty.

pub fn records(&self) -> &[TransitionRecord<M, E, C>]

Returns a slice of all records.

Examples found in repository

examples/replay.rs (line 108)

fn main() {
    let instrument = LabInstrument;
    let mut runner = Runner::new(&instrument);

    let events = [
        Event::PowerOn,
        Event::SensorReady,
        Event::BeginMeasurement,
        Event::DataCollected,
        Event::DataCollected,
        Event::AnomalyDetected,
        Event::OperatorReset,
        Event::BeginMeasurement,
    ];

    // Record every transition in the journal
    let mut journal: InMemoryJournal<Mode, Event, Command> = InMemoryJournal::new();

    println!("--- Recording transitions ---\n");
    for event in events {
        let from = runner.mode().clone();
        let commands = runner.feed(&event);
        let to = runner.mode().clone();

        println!("  {from:?} + {event:?} => {to:?}");
        if !commands.is_empty() {
            println!("    commands: {commands:?}");
        }

        journal.record_step(&from, &to, &event, &commands);
    }

    println!("\n--- Journal: {} records ---\n", journal.len());
    for record in journal.records() {
        println!(
            "  step {}: {:?} => {:?} (via {:?})",
            record.step, record.from, record.to, record.event,
        );
    }

    // Replay: feed the same events through a fresh machine and verify
    println!("\n--- Replaying ---\n");
    match journal.replay(&instrument, instrument.initial_mode()) {
        Ok(final_mode) => {
            println!("  replay verified: final mode = {final_mode:?}");
            assert_eq!(final_mode, runner.mode().clone());
        }
        Err(err) => {
            println!("  {err}");
        }
    }
}

pub fn append(&mut self, record: TransitionRecord<M, E, C>)

Appends a record.

pub fn last(&self) -> Option<&TransitionRecord<M, E, C>>

Returns the most recent record, if any.

pub fn record_step(&mut self, from: &M, to: &M, event: &E, commands: &[C])

where M: Clone, E: Clone, C: Clone,

Records a step by cloning the provided values.

This is a convenience for runtimes that keep Mode and Event by reference and want to capture an owned record.

Examples found in repository

examples/replay.rs (line 104)

fn main() {
    let instrument = LabInstrument;
    let mut runner = Runner::new(&instrument);

    let events = [
        Event::PowerOn,
        Event::SensorReady,
        Event::BeginMeasurement,
        Event::DataCollected,
        Event::DataCollected,
        Event::AnomalyDetected,
        Event::OperatorReset,
        Event::BeginMeasurement,
    ];

    // Record every transition in the journal
    let mut journal: InMemoryJournal<Mode, Event, Command> = InMemoryJournal::new();

    println!("--- Recording transitions ---\n");
    for event in events {
        let from = runner.mode().clone();
        let commands = runner.feed(&event);
        let to = runner.mode().clone();

        println!("  {from:?} + {event:?} => {to:?}");
        if !commands.is_empty() {
            println!("    commands: {commands:?}");
        }

        journal.record_step(&from, &to, &event, &commands);
    }

    println!("\n--- Journal: {} records ---\n", journal.len());
    for record in journal.records() {
        println!(
            "  step {}: {:?} => {:?} (via {:?})",
            record.step, record.from, record.to, record.event,
        );
    }

    // Replay: feed the same events through a fresh machine and verify
    println!("\n--- Replaying ---\n");
    match journal.replay(&instrument, instrument.initial_mode()) {
        Ok(final_mode) => {
            println!("  replay verified: final mode = {final_mode:?}");
            assert_eq!(final_mode, runner.mode().clone());
        }
        Err(err) => {
            println!("  {err}");
        }
    }
}

pub fn transitions_from<'a>( &'a self, mode: &'a M, ) -> impl Iterator<Item = &'a TransitionRecord<M, E, C>> + 'a

where M: PartialEq,

Returns an iterator over records whose from mode matches mode.

pub fn transitions_to<'a>( &'a self, mode: &'a M, ) -> impl Iterator<Item = &'a TransitionRecord<M, E, C>> + 'a

where M: PartialEq,

Returns an iterator over records whose to mode matches mode.

pub fn replay<Mac>( &self, machine: &Mac, initial_mode: M, ) -> Result<M, ReplayError>

where Mac: Machine<Mode = M, Event = E, Command = C>, M: Clone + PartialEq, C: PartialEq,

Replays all records through machine, starting from initial_mode.

On success, returns the final mode after applying all decisions.

Errors

Returns a ReplayError if replay diverges from the recorded history.

Examples found in repository

examples/replay.rs (line 117)

fn main() {
    let instrument = LabInstrument;
    let mut runner = Runner::new(&instrument);

    let events = [
        Event::PowerOn,
        Event::SensorReady,
        Event::BeginMeasurement,
        Event::DataCollected,
        Event::DataCollected,
        Event::AnomalyDetected,
        Event::OperatorReset,
        Event::BeginMeasurement,
    ];

    // Record every transition in the journal
    let mut journal: InMemoryJournal<Mode, Event, Command> = InMemoryJournal::new();

    println!("--- Recording transitions ---\n");
    for event in events {
        let from = runner.mode().clone();
        let commands = runner.feed(&event);
        let to = runner.mode().clone();

        println!("  {from:?} + {event:?} => {to:?}");
        if !commands.is_empty() {
            println!("    commands: {commands:?}");
        }

        journal.record_step(&from, &to, &event, &commands);
    }

    println!("\n--- Journal: {} records ---\n", journal.len());
    for record in journal.records() {
        println!(
            "  step {}: {:?} => {:?} (via {:?})",
            record.step, record.from, record.to, record.event,
        );
    }

    // Replay: feed the same events through a fresh machine and verify
    println!("\n--- Replaying ---\n");
    match journal.replay(&instrument, instrument.initial_mode()) {
        Ok(final_mode) => {
            println!("  replay verified: final mode = {final_mode:?}");
            assert_eq!(final_mode, runner.mode().clone());
        }
        Err(err) => {
            println!("  {err}");
        }
    }
}

pub fn replay_with_error<Err, Mac>( &self, machine: &Mac, initial_mode: M, ) -> Result<M, ReplayError>

where Mac: Machine<Err, Mode = M, Event = E, Command = C>, M: Clone + PartialEq, C: PartialEq,

Replays all records through machine when the machine uses a non-default error type.

This is identical to InMemoryJournal::replay, but works with machines that are implemented as Machine<Err> rather than Machine (where Err is the default core::convert::Infallible).

Errors

Returns a ReplayError if replay diverges from the recorded history.

Trait Implementations

impl<M: Debug, E: Debug, C: Debug> Debug for InMemoryJournal<M, E, C>

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

Formats the value using the given formatter.

impl<M: Default, E: Default, C: Default> Default for InMemoryJournal<M, E, C>

fn default() -> InMemoryJournal<M, E, C>

Returns the “default value” for a type.