Struct State

pub struct State { /* private fields */ }

State of a simulation holding all queues and arbitrary values in a store value.

Implementations

impl State

pub fn insert<V: 'static>(&mut self, value: V) -> Key<V>

Inserts an arbitrary value to the value store. Learn more in the documentation for Key.

Examples found in repository

examples/simulation.rs (line 172)

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 remove<V: 'static>(&mut self, key: Key<V>) -> Option<V>

Removes a value of type V from the value store. Learn more in the documentation for Key.

pub fn get<V: 'static>(&self, key: Key<V>) -> Option<&V>

Gets a immutable reference to a value of a type V from the value store. Learn more in the documentation for Key.

Examples found in repository

examples/simulation.rs (line 63)

    fn process_event(
        &self,
        self_id: ComponentId<ProducerEvent>,
        _event: &ProducerEvent,
        scheduler: &mut Scheduler,
        state: &mut State,
    ) {
        let count = *state.get(self.produced_count).unwrap();
        if count < 10 {
            let _ = state.send(self.outgoing, self.produce());
            self.log();
            scheduler.schedule(self.interval(), self_id, ProducerEvent);
            scheduler.schedule(Duration::default(), self.consumer, ConsumerEvent::Received);
            *state.get_mut(self.produced_count).unwrap() = count + 1;
        }
    }
}

impl Component for Consumer {
    type Event = ConsumerEvent;

    fn process_event(
        &self,
        self_id: ComponentId<ConsumerEvent>,
        event: &ConsumerEvent,
        scheduler: &mut Scheduler,
        state: &mut State,
    ) {
        let busy = state.get(self.working_on).unwrap().is_some();
        match event {
            ConsumerEvent::Received => {
                if !busy {
                    if let Some(product) = state.recv(self.incoming) {
                        if let Some(w) = state.get_mut(self.working_on) {
                            *w = Some(product);
                        }
                        scheduler.schedule(self.interval(), self_id, ConsumerEvent::Finished);
                    }
                }
            }
            ConsumerEvent::Finished => {
                let product = state.get_mut(self.working_on).unwrap().take().unwrap();
                self.log(product);
                if state.len(self.incoming) > 0 {
                    scheduler.schedule(Duration::default(), self_id, ConsumerEvent::Received);
                }
            }
        }
    }

pub fn get_mut<V: 'static>(&mut self, key: Key<V>) -> Option<&mut V>

Gets a mutable reference to a value of a type V from the value store. Learn more in the documentation for Key.

Examples found in repository

examples/simulation.rs (line 69)

    fn process_event(
        &self,
        self_id: ComponentId<ProducerEvent>,
        _event: &ProducerEvent,
        scheduler: &mut Scheduler,
        state: &mut State,
    ) {
        let count = *state.get(self.produced_count).unwrap();
        if count < 10 {
            let _ = state.send(self.outgoing, self.produce());
            self.log();
            scheduler.schedule(self.interval(), self_id, ProducerEvent);
            scheduler.schedule(Duration::default(), self.consumer, ConsumerEvent::Received);
            *state.get_mut(self.produced_count).unwrap() = count + 1;
        }
    }
}

impl Component for Consumer {
    type Event = ConsumerEvent;

    fn process_event(
        &self,
        self_id: ComponentId<ConsumerEvent>,
        event: &ConsumerEvent,
        scheduler: &mut Scheduler,
        state: &mut State,
    ) {
        let busy = state.get(self.working_on).unwrap().is_some();
        match event {
            ConsumerEvent::Received => {
                if !busy {
                    if let Some(product) = state.recv(self.incoming) {
                        if let Some(w) = state.get_mut(self.working_on) {
                            *w = Some(product);
                        }
                        scheduler.schedule(self.interval(), self_id, ConsumerEvent::Finished);
                    }
                }
            }
            ConsumerEvent::Finished => {
                let product = state.get_mut(self.working_on).unwrap().take().unwrap();
                self.log(product);
                if state.len(self.incoming) > 0 {
                    scheduler.schedule(Duration::default(), self_id, ConsumerEvent::Received);
                }
            }
        }
    }

pub fn add_queue<Q: Queue + 'static>(&mut self, queue: Q) -> QueueId<Q>

Creates a new unbounded queue, returning its ID.

pub fn send<Q: Queue + 'static>( &mut self, queue: QueueId<Q>, value: Q::Item, ) -> Result<(), PushError>

Sends value to the queue. This is a shorthand for queue_mut(queue).push(value).

Errors

It returns an error if the queue is full.

Examples found in repository

examples/simulation.rs (line 65)

    fn process_event(
        &self,
        self_id: ComponentId<ProducerEvent>,
        _event: &ProducerEvent,
        scheduler: &mut Scheduler,
        state: &mut State,
    ) {
        let count = *state.get(self.produced_count).unwrap();
        if count < 10 {
            let _ = state.send(self.outgoing, self.produce());
            self.log();
            scheduler.schedule(self.interval(), self_id, ProducerEvent);
            scheduler.schedule(Duration::default(), self.consumer, ConsumerEvent::Received);
            *state.get_mut(self.produced_count).unwrap() = count + 1;
        }
    }

pub fn recv<Q: Queue + 'static>(&mut self, queue: QueueId<Q>) -> Option<Q::Item>

Pops the first value from the queue. It returns None if the queue is empty. This is a shorthand for queue_mut(queue).pop(value).

Examples found in repository

examples/simulation.rs (line 88)

    fn process_event(
        &self,
        self_id: ComponentId<ConsumerEvent>,
        event: &ConsumerEvent,
        scheduler: &mut Scheduler,
        state: &mut State,
    ) {
        let busy = state.get(self.working_on).unwrap().is_some();
        match event {
            ConsumerEvent::Received => {
                if !busy {
                    if let Some(product) = state.recv(self.incoming) {
                        if let Some(w) = state.get_mut(self.working_on) {
                            *w = Some(product);
                        }
                        scheduler.schedule(self.interval(), self_id, ConsumerEvent::Finished);
                    }
                }
            }
            ConsumerEvent::Finished => {
                let product = state.get_mut(self.working_on).unwrap().take().unwrap();
                self.log(product);
                if state.len(self.incoming) > 0 {
                    scheduler.schedule(Duration::default(), self_id, ConsumerEvent::Received);
                }
            }
        }
    }

pub fn len<Q: Queue + 'static>(&self, queue: QueueId<Q>) -> usize

Checks the number of elements in the queue. This is a shorthand for queue(queue).len().

Examples found in repository

examples/simulation.rs (line 99)

    fn process_event(
        &self,
        self_id: ComponentId<ConsumerEvent>,
        event: &ConsumerEvent,
        scheduler: &mut Scheduler,
        state: &mut State,
    ) {
        let busy = state.get(self.working_on).unwrap().is_some();
        match event {
            ConsumerEvent::Received => {
                if !busy {
                    if let Some(product) = state.recv(self.incoming) {
                        if let Some(w) = state.get_mut(self.working_on) {
                            *w = Some(product);
                        }
                        scheduler.schedule(self.interval(), self_id, ConsumerEvent::Finished);
                    }
                }
            }
            ConsumerEvent::Finished => {
                let product = state.get_mut(self.working_on).unwrap().take().unwrap();
                self.log(product);
                if state.len(self.incoming) > 0 {
                    scheduler.schedule(Duration::default(), self_id, ConsumerEvent::Received);
                }
            }
        }
    }

pub fn queue<Q: Queue + 'static>(&self, queue: QueueId<Q>) -> &Q

Returns a immutable reference to the queue by the given ID.

pub fn queue_mut<Q: Queue + 'static>(&mut self, queue: QueueId<Q>) -> &mut Q

Returns a mutable reference to the queue by the given ID.

Trait Implementations

impl Default for State

fn default() -> State

Returns the “default value” for a type.