Struct Scheduler 

pub struct Scheduler(/* private fields */);

A scheduler for events and queries meant to be processed at specified deadlines.

The Scheduler handle is Clone-able and can be shared or sent to other threads.

When scheduling an event or query, it is important to consider that its deadline must be in the future of the current simulation time and that stepping method such as Simulation::step or Simulation::run eagerly advance the simulation time to the deadline of the next scheduled event or simulation tick. If a stepping method is executed concurrently, therefore, events or queries can only be scheduled after the deadline associated with the next scheduler event or simulation tick.

Implementations

impl Scheduler

pub fn time(&self) -> MonotonicTime

Returns the current simulation time.

Examples

use nexosim::simulation::Scheduler;
use nexosim::time::MonotonicTime;

fn is_third_millennium(scheduler: &Scheduler) -> bool {
    let time = scheduler.time();
    time >= MonotonicTime::new(978307200, 0).unwrap()
        && time < MonotonicTime::new(32535216000, 0).unwrap()
}

pub fn schedule_event<T>( &self, deadline: impl Deadline, event_id: &EventId<T>, arg: T, ) -> Result<(), SchedulingError>

where T: Send + Clone + 'static,

Schedules an event at a future time.

An error is returned if the specified time is not in the future of the current simulation time.

Events scheduled for the same time and targeting the same model are guaranteed to be processed according to the scheduling order.

pub fn schedule_keyed_event<T>( &self, deadline: impl Deadline, event_id: &EventId<T>, arg: T, ) -> Result<EventKey, SchedulingError>

where T: Send + Clone + 'static,

Schedules a cancellable event at a future time and returns an event key.

An error is returned if the specified time is not in the future of the current simulation time.

Events scheduled for the same time and targeting the same model are guaranteed to be processed according to the scheduling order.

pub fn schedule_periodic_event<T>( &self, deadline: impl Deadline, period: Duration, event_id: &EventId<T>, arg: T, ) -> Result<(), SchedulingError>

where T: Send + Clone + 'static,

Schedules a periodically recurring event at a future time.

An error is returned if the specified time is not in the future of the current simulation time, or if the specified period is null.

Events scheduled for the same time and targeting the same model are guaranteed to be processed according to the scheduling order.

pub fn schedule_keyed_periodic_event<T>( &self, deadline: impl Deadline, period: Duration, event_id: &EventId<T>, arg: T, ) -> Result<EventKey, SchedulingError>

where T: Send + Clone + 'static,

Schedules a cancellable, periodically recurring event at a future time and returns an event key.

An error is returned if the specified time is not in the future of the current simulation time, or if the specified period is null.

Events scheduled for the same time and targeting the same model are guaranteed to be processed according to the scheduling order.

pub fn schedule_query<T, R>( &self, deadline: impl Deadline, query_id: &QueryId<T, R>, arg: T, ) -> Result<ReplyReader<R>, SchedulingError>

where T: Send + Clone + 'static, R: Send + 'static,

Schedules a query at a future time.

An error is returned if the specified time is not in the future of the current simulation.

Queries scheduled for the same time and targeting the same model are guaranteed to be processed according to the scheduling order.

pub fn halt(&self)

Requests the simulation to be interrupted at the earliest opportunity.

If a stepping method such as Simulation::step or Simulation::run is concurrently being executed, this will cause such method to return before it steps to next scheduler deadline or simulation tick (if any) with ExecutionError::Halted.

Otherwise, this will cause the next call to a Simulation::step* or Simulation::process* method to return immediately with ExecutionError::Halted.

In all cases, once ExecutionError::Halted is returned, the simulation can be resumed at any moment with another call to a stepping method or a Simulation::process_* methods.

Trait Implementations

impl Clone for Scheduler

fn clone(&self) -> Scheduler

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Scheduler

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

Formats the value using the given formatter.