Struct Timer 

pub struct Timer<E: IsEvent<Event = E>> {
    pub duration: Duration,
    pub on_elapsed: fn(&SenderComponent<E>),
    /* private fields */
}

Fields

duration: Duration

on_elapsed: fn(&SenderComponent<E>)

Implementations

impl<E: IsEvent<Event = E>> Timer<E>

pub fn new(duration: Duration) -> Self

pub fn start(&mut self)

Schedule the timer to run once.

Examples found in repository

examples/blinky_without_macro/main.rs (line 41)

    pub fn on(&mut self, event: &Event) -> Response<Self, Event> {
        match event {

            Event::OnEntry => {
                self.light = true;
                self.counter += 1;
                if self.counter == 10 {
                    let id = self.get_id().unwrap();
                    self.publish(Event::Detach(id));
                    println!("{}: done", &id);
                }
                self.timer.start();
                Response::Handled
            }

            Event::TimerElapsed => {
                Response::Transition(Self::off)
            }

            _ => Response::Handled
        }
    }

    fn off(&mut self, event: &Event) -> Response<Self, Event> {
        match event {

            Event::OnEntry => {
                self.light = false;
                self.timer.start();
                Response::Handled
            }

            Event::TimerElapsed => {
                Response::Transition(Self::on)
            }

            _ => Response::Handled
        }
    }

examples/blinky/main.rs (line 44)

        pub fn on(&mut self, event: &Event) -> Response<Self, Event> {
            match event {

                Event::OnEntry => {
                    self.light = true;
                    self.counter += 1;
                    if self.counter == 10 {
                        let id = self.get_id().unwrap();
                        self.publish(Event::Detach(id));
                        println!("{}: done", &id);
                    }
                    self.timer.start();
                    Response::Handled
                }

                Event::TimerElapsed => {
                    Response::Transition(Self::off)
                }

                _ => Response::Handled

            }
        }

        fn off(&mut self, event: &Event) -> Response<Self, Event> {
            match event {

                Event::OnEntry => {
                    self.light = false;
                    self.timer.start();
                    Response::Handled
                }

                Event::TimerElapsed => {
                    Response::Transition(Self::on)
                }

                _ => Response::Handled

            }
        }

pub fn start_interval(&mut self)

Schedule the timer to run repeatedly.

pub fn cancel(&mut self)

Cancel the timer if it was running.

Trait Implementations

impl<E: Clone + IsEvent<Event = E>> Clone for Timer<E>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: IsEvent<Event = E>> Debug for Timer<E>

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

Formats the value using the given formatter.

impl<E: IsEvent<Event = E>> Default for Timer<E>

fn default() -> Self

Returns the “default value” for a type.

impl<E: IsEvent<Event = E>> Sender for Timer<E>

type Event = E

fn get_sender_component_mut(&mut self) -> &mut SenderComponent<Self::Event>

Get a mutable reference to the event sender component.

fn get_sender_component(&self) -> &SenderComponent<Self::Event>

Get an immutable reference to the event sender component.

fn set_sender_component( &mut self, sender_component: SenderComponent<Self::Event>, )

Set the event sender component.

fn get_sender(&self) -> UnboundedSender<Envelope<Self::Event>>

Get the event sender

fn set_sender(&mut self, sender: UnboundedSender<Envelope<Self::Event>>)

Set the event sender

fn clear_sender(&mut self)

Clear the event sender

fn set_associated_handler_id(&mut self, id: usize)

Get associated event handler id, this is the id of the event handler that owns the event sender.

fn get_associated_handler_id(&self) -> Option<usize>

Get the associated event handler id.

fn clear_associated_handler_id(&mut self)

Clear the associated event handler id.

fn publish(&self, event: Self::Event)

Publish an event to all handlers.

fn post(&self, event: Self::Event, handler_id: usize)

Post an event to a specific handler.

fn post_to_self(&self, event: Self::Event)

Post an event to event handler to which the event sender is attached.

fn send(&self, envelope: Envelope<Self::Event>)

Send an envelope