Struct sim_by_fired_event::event::EventScheduler

pub struct EventScheduler<E: Event> { /* fields omitted */ }

event scheduler

Implementations

impl<E: Event> EventScheduler<E>

pub fn have_event(&self) -> bool

judge exist scheduled event

pub fn count(&self) -> usize

get length of scheduled events

pub fn clear(&mut self)

clear all scheduled events

pub fn remove_when<P>(&mut self, predicate: P) where
    P: FnMut(&(LocalEventTime, Schedule, Priority, E)) -> bool, 

remove scheduled events when predicate function is true

pub fn retain<P>(&mut self, predicate: P) where
    P: FnMut(&(LocalEventTime, Schedule, Priority, E)) -> bool, 

retains only the scheduled events specified by the predicate.

pub fn schedule<R: Rng + ?Sized>(
    &mut self,
    rng: &mut R,
    schedule: Schedule,
    priority: Priority,
    event: E
) -> Result<(), ScheduleEventError>

store event with scheduling

pub fn schedule_when<R: Rng + ?Sized, P>(
    &mut self,
    rng: &mut R,
    schedule: Schedule,
    priority: Priority,
    event: E,
    predicate: P
) -> Result<(), ScheduleEventError> where
    P: FnOnce(&Self) -> bool, 

store event with scheduling when user judge ok from all scheduled events

pub fn immediate<R: Rng + ?Sized>(
    &mut self,
    rng: &mut R,
    priority: Priority,
    event: E
) -> Result<(), ScheduleEventError>

store event which fire at immediate timing

pub fn timeout<R: Rng + ?Sized>(
    &mut self,
    rng: &mut R,
    timeout: EventTimer,
    priority: Priority,
    event: E
) -> Result<(), ScheduleEventError>

store event which fire after timeout

pub fn everytime<R: Rng + ?Sized>(
    &mut self,
    rng: &mut R,
    priority: Priority,
    event: E
) -> Result<(), ScheduleEventError>

store event which fire every time

pub fn every_interval<R: Rng + ?Sized>(
    &mut self,
    rng: &mut R,
    interval: EventTimer,
    priority: Priority,
    event: E
) -> Result<(), ScheduleEventError>

store event which fire every interval

pub fn repeat<R: Rng + ?Sized>(
    &mut self,
    rng: &mut R,
    count: u8,
    interval: EventTimer,
    priority: Priority,
    event: E
) -> Result<(), ScheduleEventError>

store event which fire every interval only count

Trait Implementations

impl<E: Clone + Event> Clone for EventScheduler<E>

fn clone(&self) -> EventScheduler<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug + Event> Debug for EventScheduler<E>

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

Formats the value using the given formatter.