Struct Executor

pub struct Executor { /* private fields */ }

Executor is used for simple execution of an entire simulation.

See the crate level documentation for examples.

Implementations

impl Executor

pub fn unbound() -> Self

Simulation will end only once there is no available events in the queue.

Examples found in repository

examples/simulation.rs (line 190)

fn main() {
    let messages = Rc::new(RefCell::new(Vec::<String>::new()));
    let mut simulation = Simulation::default();
    let queue = simulation.add_queue(Fifo::default());
    let working_on = simulation.state.insert::<Option<Product>>(None);
    let consumer = simulation.add_component(Consumer {
        incoming: queue,
        working_on,
        messages: messages.clone(),
    });
    let produced_count = simulation.state.insert(0_usize);
    let producer = simulation.add_component(Producer {
        outgoing: queue,
        consumer,
        produced_count,
        messages: messages.clone(),
    });
    simulation.schedule(Duration::new(0, 0), producer, ProducerEvent);
    // simulation.schedule(Duration::new(0, 0), consumer, ProducerEvent);
    // The above would fail with:                         ^^^^^^^^^^^^^ expected enum `ConsumerEvent`, found struct `ProducerEvent`
    {
        let messages = messages.clone();
        simulation.execute(Executor::unbound().side_effect(move |sim| {
            messages
                .borrow_mut()
                .push(format!("{:?}", sim.scheduler.time()));
        }));
    }
    assert_eq!(*messages.borrow(), EXPECTED.split('\n').collect::<Vec<_>>());
}

pub fn timed(time: Duration) -> Self

Simulation will be run no longer than the given time. It may terminate early if no events are available.

pub fn steps(steps: usize) -> Self

Simulation will execute exactly this many steps, unless we run out of events.

pub fn side_effect<F>(self, func: F) -> ExecutorWithSideEffect<F>

where F: Fn(&Simulation),

Registers a side effect that is called after each simulation step.

Examples found in repository

examples/simulation.rs (lines 190-194)

fn main() {
    let messages = Rc::new(RefCell::new(Vec::<String>::new()));
    let mut simulation = Simulation::default();
    let queue = simulation.add_queue(Fifo::default());
    let working_on = simulation.state.insert::<Option<Product>>(None);
    let consumer = simulation.add_component(Consumer {
        incoming: queue,
        working_on,
        messages: messages.clone(),
    });
    let produced_count = simulation.state.insert(0_usize);
    let producer = simulation.add_component(Producer {
        outgoing: queue,
        consumer,
        produced_count,
        messages: messages.clone(),
    });
    simulation.schedule(Duration::new(0, 0), producer, ProducerEvent);
    // simulation.schedule(Duration::new(0, 0), consumer, ProducerEvent);
    // The above would fail with:                         ^^^^^^^^^^^^^ expected enum `ConsumerEvent`, found struct `ProducerEvent`
    {
        let messages = messages.clone();
        simulation.execute(Executor::unbound().side_effect(move |sim| {
            messages
                .borrow_mut()
                .push(format!("{:?}", sim.scheduler.time()));
        }));
    }
    assert_eq!(*messages.borrow(), EXPECTED.split('\n').collect::<Vec<_>>());
}

Trait Implementations

impl Clone for Executor

fn clone(&self) -> Executor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Executor

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

Formats the value using the given formatter.

impl Execute for Executor

fn execute(self, sim: &mut Simulation)

Executes the simulation until some stopping condition is reached. The condition is implementation-specific.

impl PartialEq for Executor

fn eq(&self, other: &Executor) -> 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 Copy for Executor

impl Eq for Executor

impl StructuralPartialEq for Executor