Struct Simulation

pub struct Simulation {
    pub state: State,
    pub scheduler: Scheduler,
    pub components: Components,
}

Simulation struct that puts different parts of the simulation together.

See the crate-level documentation for more information.

Fields

state: State

Simulation state.

scheduler: Scheduler

Event scheduler.

components: Components

Component container.

Implementations

impl Simulation

pub fn step(&mut self) -> bool

Performs one step of the simulation. Returns true if there was in fact an event available to process, and false otherwise, which signifies that the simulation ended.

pub fn run<F: Fn(&Simulation)>(&mut self, step_function: F)

👎Deprecated since 0.2.0: Handling this in Simulation is susceptible to API breaks and/or making it messy. Use execute instead, which delegates the logic to an external executor.

Runs the entire simulation from start to end. This function might not terminate if the end condition is not satisfied.

pub fn execute<E: Execute>(&mut self, executor: E)

Runs the entire simulation.

The stopping condition and other execution details depend on the executor used. See Execute and Executor for more details.

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<_>>());
}

pub fn add_component<E: Debug + 'static, C: Component<Event = E> + 'static>( &mut self, component: C, ) -> ComponentId<E>

Adds a new component.

Examples found in repository

examples/simulation.rs (lines 173-177)

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 add_queue<Q: Queue + 'static>(&mut self, queue: Q) -> QueueId<Q>

Adds a new unbounded queue.

Examples found in repository

examples/simulation.rs (line 171)

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 schedule<E: Debug + 'static>( &mut self, time: Duration, component: ComponentId<E>, event: E, )

Schedules a new event to be executed at time time in component component.

Examples found in repository

examples/simulation.rs (line 185)

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 Default for Simulation

fn default() -> Simulation

Returns the “default value” for a type.