[−][src]Trait async_timer::timer::SyncTimer

pub trait SyncTimer: Timer {
    fn init<R, F: Fn(&TimerState) -> R>(&mut self, init: F) -> R;

    fn tick(&mut self) -> bool { ... }
}

Describes timer interface that doesn't require async event loop.

In most cases these timers are implemented by OS calling back a provided callback.

As notification is not done via event loop, timer has to store callback in its own state.

Whenever async timer relies on async event loop to handle notifications

Usage

use async_timer::timer::{Timer, SyncTimer, new_sync_timer};

use core::sync::atomic::{AtomicBool, Ordering};
use core::time;

use std::thread;

static EXPIRED: AtomicBool = AtomicBool::new(false);
fn on_expire() {
    EXPIRED.store(true, Ordering::Release);
}

let mut work = new_sync_timer(time::Duration::from_secs(1));
assert!(!work.is_ticking());
assert!(!work.is_expired());

work.init(|state| state.register(on_expire as fn()));
work.tick();

assert!(work.is_ticking());
assert!(!work.is_expired());
thread::sleep(time::Duration::from_millis(1250)); //timer is not necessary expires immediately

assert!(work.is_expired());
assert!(EXPIRED.load(Ordering::Acquire));

Required methods

fn init<R, F: Fn(&TimerState) -> R>(&mut self, init: F) -> R

Initializes timer state, performing initial arming and allowing to access TimerState during initialization

The state can be used to register callback and check whether timer has notified user using configured callback

If Timer is already armed, then TimerState is granted as it is.

Loading content...

Provided methods

fn tick(&mut self) -> bool

Ticks timer.

If timer is not started yet, starts returning false. Otherwise performs necessary actions, if any, to drive timer and returns whether it is expired.

Default implementation initializes timer state, if necessary, and returns whether timer has expired or not.

Loading content...

Implementors

impl SyncTimer for DummyTimer[src]

impl SyncTimer for PosixTimer[src]

Loading content...