Struct sim_by_fired_event::Simulator

pub struct Simulator<M, E, Rec> where
    M: Model<Rec, ModelEvent = E>,
    E: Event,  { /* fields omitted */ }

simulator

Implementations

impl<M, E, Rec> Simulator<M, E, Rec> where
    M: Model<Rec, ModelEvent = E>,
    E: Event, 

pub fn new<R: Rng + ?Sized>(rng: &mut R) -> Self where
    Rec: Default,
    M: Default, 

create as default

pub fn create_from<R: Rng + ?Sized>(
    rng: &mut R,
    model: M,
    recorder: Rec
) -> Self

create simulator from model

pub fn get_model(&self) -> &M

getter for model

pub fn get_scheduler(&self) -> &EventScheduler<E>

getter for scheduler

pub fn get_recorder(&self) -> &Rec

getter for recorder

pub fn get_recorder_as_mut(&mut self) -> &mut Rec

getter for recorder

pub fn swap_recorder(&mut self, new_recorder: Rec) -> Rec

swap new and old recorder with get old recorder.

pub fn run_step<R: Rng + ?Sized, H>(&mut self, rng: &mut R, handler: H) where
    H: FnMut(&mut R, &mut M, &mut Rec, &mut EventScheduler<E>, Vec<(Priority, E)>), 

run simulate for one frame

pub fn run_n<R: Rng + ?Sized, FC: FrameCounter, H>(
    &mut self,
    rng: &mut R,
    counter: FC,
    handler: H
) where
    H: FnMut(&mut R, &mut M, &mut Rec, &mut EventScheduler<E>, Vec<(Priority, E)>), 

run simulate for frames

pub fn run_until<R: Rng + ?Sized, F, H>(
    &mut self,
    rng: &mut R,
    can_continue: F,
    handler: H
) where
    F: Fn(&M) -> bool,
    H: FnMut(&mut R, &mut M, &mut Rec, &mut EventScheduler<E>, Vec<(Priority, E)>), 

run simulation until condition is true

pub fn run_with_state<R: Rng + ?Sized, F, P, H>(
    &mut self,
    rng: &mut R,
    update_state: F,
    can_continue: P,
    handler: H
) where
    F: Fn(&mut M),
    P: Fn(&M) -> bool,
    H: FnMut(&mut R, &mut M, &mut Rec, &mut EventScheduler<E>, Vec<(Priority, E)>), 

run simulation with update model’s state

impl<M, E, Rec> Simulator<M, E, Rec> where
    M: BulkEvents<Rec, E>,
    E: Event, 

simulate for fired event with calculate in bulk

pub fn run_step_in_bulk_event<R: Rng + ?Sized>(&mut self, rng: &mut R)

run simulate for one frame

pub fn run_n_in_bulk_event<R: Rng + ?Sized, FC: FrameCounter>(
    &mut self,
    rng: &mut R,
    counter: FC
)

run simulate for frames

pub fn run_until_in_bulk_event<R: Rng + ?Sized, F>(
    &mut self,
    rng: &mut R,
    can_continue: F
) where
    F: Fn(&M) -> bool, 

run simulation until condition is true

pub fn run_with_state_in_bulk_event<R: Rng + ?Sized, S, F, P>(
    &mut self,
    rng: &mut R,
    update_state: F,
    can_continue: P
) where
    F: Fn(&mut M),
    P: Fn(&M) -> bool, 

run simulation with update model’s state

impl<M, E, Rec> Simulator<M, E, Rec> where
    M: StepEachEvent<Rec, E>,
    E: Event, 

simulate for fired event with calculate each event

pub fn run_step_each_event<R: Rng + ?Sized>(&mut self, rng: &mut R)

run simulate for one frame

pub fn run_n_each_event<R: Rng + ?Sized, FC: FrameCounter>(
    &mut self,
    rng: &mut R,
    counter: FC
)

run simulate for frames

pub fn run_until_each_event<R: Rng + ?Sized, F>(
    &mut self,
    rng: &mut R,
    can_continue: F
) where
    F: Fn(&M) -> bool, 

run simulation until condition is true

pub fn run_with_state_each_event<R: Rng + ?Sized, S, F, P>(
    &mut self,
    rng: &mut R,
    update_state: F,
    can_continue: P
) where
    F: Fn(&mut M),
    P: Fn(&M) -> bool, 

run simulation with update model’s state

Trait Implementations

impl<M: Clone, E: Clone, Rec: Clone> Clone for Simulator<M, E, Rec> where
    M: Model<Rec, ModelEvent = E>,
    E: Event, 

fn clone(&self) -> Simulator<M, E, Rec>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Debug, E: Debug, Rec: Debug> Debug for Simulator<M, E, Rec> where
    M: Model<Rec, ModelEvent = E>,
    E: Event, 

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

Formats the value using the given formatter.