Struct StandardRunner 

pub struct StandardRunner<CS> { /* private fields */ }

A standard runner that processes events sequentially in the order they were fired.

This runner executes the core simulation cycle (Source phase, Event phase) in a deterministic, serial fashion. If the skippable option is enabled, the simulation skips time periods where no events occur, ensuring efficient utilization of computational resources.

Deterministic Execution

As long as the implementations of Model, Source, and Hook are deterministic, simulations executed through this runner will demonstrate reproducible, deterministic behavior.

Implementations

impl StandardRunner<AlwaysContinueStrategy>

pub fn new(skippable: bool) -> Self

Creates a new StandardRunner using the default AlwaysContinueStrategy.

impl<CS> StandardRunner<CS>

pub fn new_with_continue_strategy( skippable: bool, continue_strategy: CS, ) -> Self

Creates a new StandardRunner with a custom ContinueStrategy.

Trait Implementations

impl<CS: Clone> Clone for StandardRunner<CS>

fn clone(&self) -> StandardRunner<CS>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E, M: Model<E>, CS: ContinueStrategy<E, M, ()>> Runner<E, M, CS> for StandardRunner<CS>

type Err = ()

Implementation-specific error type that may occur during simulation.

fn run<F>( &mut self, engine: Engine<E, M>, model: M, should_stop: F, ) -> SimulationResult<M, CS::Err>

where F: FnMut(&M, ExecutorStatus, TickStatus) -> bool,

The core, low-level method for driving the simulation.

fn run_playback<F>( &mut self, engine: Engine<E, M>, model: M, duration: Duration, should_stop: F, ) -> SimulationResult<M, CS::Err>

where F: FnMut(&M, ExecutorStatus, TickStatus) -> bool,

Advances the simulation while inserting a specified delay between ticks.

fn run_do_ticks( &mut self, engine: Engine<E, M>, model: M, tick_count: TimeTick, include_zero_tick: bool, ) -> SimulationResult<M, CS::Err>

Advances the simulation until a specific tick count is reached.

fn run_until_idle( &mut self, engine: Engine<E, M>, model: M, ) -> SimulationResult<M, CS::Err>

Automatically advances the simulation until the event queue is exhausted (idle).

fn run_until_model_condition<F>( &mut self, engine: Engine<E, M>, model: M, should_stop_model_condition: F, ) -> SimulationResult<M, CS::Err>

where F: FnMut(&M) -> bool,

Advances the simulation until the model’s internal state satisfies a condition.

fn run_batch_parallel<MF, EF, F>( &self, count: usize, engine_builder: EF, model_builder: MF, should_stop: F, ) -> Vec<SimulationResult<M, CS::Err>>

where Self: Clone + Sync, EF: Fn(usize) -> Engine<E, M> + Sync, M: Send, MF: Fn(usize) -> M + Sync, F: FnMut(&M, ExecutorStatus, TickStatus) -> bool + Clone + Sync, CS::Err: Send,

Executes multiple simulation trials in parallel across multiple CPU cores.