Struct Timer

pub struct Timer { /* private fields */ }

Timer store all timeout callback base on binaryHeap; The callback function will be triggered when the time expires

Example

use swnb_timer::Timer;
use std::time::Duration;

let timer = Timer::new();

timer.set_timeout(||{
    println!("after 1 sec");
},Duration::from_secs(1));

std::thread::sleep(Duration::from_secs(2));

Implementations

impl Timer

pub fn new() -> Self

create new Timer, this method will create one thread to handle all task base on binaryHeap;

Examples

Basic usage:

use swnb_timer::Timer;
use std::time::Duration;

let timer = Timer::new();

timer.set_timeout(||{
    println!("after 1 sec");
},Duration::from_secs(1));

timer.set_timeout(||{
    println!("after 2 sec");
},Duration::from_secs(2));

std::thread::sleep(Duration::from_secs(3));

Async usage:

use swnb_timer::Timer;
use std::time::Duration;

let timer = Timer::new();

let async_block = async {
    timer.wait(Duration::from_secs(1)).await;
    println!("after 1 sec");
};
// blocking_on(async_block);

Examples found in repository

examples/async_timeout.rs (line 6)

fn main() {
    let timer = Timer::new();

    // this future print count every 1 sec
    let async_block = async {
        let mut count = 1;
        loop {
            timer.wait(Duration::from_secs(1)).await;
            count += 1;
            println!("{count}");
        }
    };
}

examples/interval.rs (line 12)

fn main() {
    let timer = Timer::new();
    let count: Arc<AtomicUsize> = Default::default();
    let count_clone = count.clone();
    // count will increase every 1 sec
    let _ = timer.set_interval(
        move || {
            count_clone.fetch_add(1, SeqCst);
            println!("run callback success");
        },
        Duration::from_secs(2),
    );

    sleep(Duration::from_secs(5));

    assert_eq!(count.load(SeqCst), 2);
}

examples/timeout.rs (line 15)

fn main() {
    let timer = Timer::new();
    let count = Arc::new(AtomicUsize::new(0));
    let count_clone = count.clone();
    // count will increase after 1 sec
    let _ = timer.set_timeout(
        move || {
            count_clone.fetch_add(1, SeqCst);
            println!("run callback success");
        },
        Duration::from_secs(1),
    );

    sleep(Duration::from_secs(1) + Duration::from_millis(20));

    assert_eq!(count.load(SeqCst), 1);

    let count_clone = count.clone();
    let cancel_timeout = timer.set_timeout(
        move || {
            count_clone.fetch_add(1, SeqCst);
            println!("run callback success");
        },
        Duration::from_secs(1),
    );

    sleep(Duration::from_millis(20));
    // cancel callback;
    cancel_timeout();
    sleep(Duration::from_secs(1));
    // count still be 1;
    assert_eq!(count.load(SeqCst), 1);
}

pub fn set_timeout( &self, callback: impl FnOnce() + 'static + Send, duration: Duration, ) -> impl FnOnce() + Sync + 'static

set_timeout accept two arguments, callback and duration; callback will run after duration; if you want to cancel callback before the deadline, set_timeout return cancel function, run it will cancel current timeout callback;

Examples

set_timeout:

use swnb_timer::Timer;
use std::time::Duration;

let timer = Timer::new();

timer.set_timeout(||{
    println!("after 1 sec");
},Duration::from_secs(1));

timer.set_timeout(||{
    println!("after 2 sec");
},Duration::from_secs(2));

std::thread::sleep(Duration::from_secs(3));

cancel_callback:

use swnb_timer::Timer;
use std::time::Duration;

let timer = Timer::new();

let cancel = timer.set_timeout(||{
    println!("after 2 sec");
},Duration::from_secs(2));

timer.set_timeout(move ||{
   cancel();
   println!("cancel previous timeout callback");
},Duration::from_secs(1));

std::thread::sleep(Duration::from_secs(3));

Examples found in repository

examples/timeout.rs (lines 19-25)

fn main() {
    let timer = Timer::new();
    let count = Arc::new(AtomicUsize::new(0));
    let count_clone = count.clone();
    // count will increase after 1 sec
    let _ = timer.set_timeout(
        move || {
            count_clone.fetch_add(1, SeqCst);
            println!("run callback success");
        },
        Duration::from_secs(1),
    );

    sleep(Duration::from_secs(1) + Duration::from_millis(20));

    assert_eq!(count.load(SeqCst), 1);

    let count_clone = count.clone();
    let cancel_timeout = timer.set_timeout(
        move || {
            count_clone.fetch_add(1, SeqCst);
            println!("run callback success");
        },
        Duration::from_secs(1),
    );

    sleep(Duration::from_millis(20));
    // cancel callback;
    cancel_timeout();
    sleep(Duration::from_secs(1));
    // count still be 1;
    assert_eq!(count.load(SeqCst), 1);
}

pub fn set_interval( &self, callback: impl FnMut() + 'static + Send, duration: Duration, ) -> impl FnOnce() + Sync + 'static

set_interval is basically consistent with set_timeout callback will run every duration; if you want to cancel interval, set_interval return cancel function, run it will cancel current interval callback;

Examples

set_interval:

use swnb_timer::Timer;
use std::time::Duration;

let timer = Timer::new();

timer.set_interval(||{
    println!("every 1 sec");
},Duration::from_secs(1));

timer.set_interval(||{
    println!("every 2 sec");
},Duration::from_secs(2));

std::thread::sleep(Duration::from_secs(3));

cancel_interval:

use swnb_timer::Timer;
use std::time::Duration;

let timer = Timer::new();

let cancel = timer.set_interval(||{
    println!("every 2 sec");
},Duration::from_secs(2));

timer.set_timeout(move ||{
   cancel();
   println!("cancel previous timeout callback");
},Duration::from_secs(1));

std::thread::sleep(Duration::from_secs(7));

Examples found in repository

examples/interval.rs (lines 16-22)

fn main() {
    let timer = Timer::new();
    let count: Arc<AtomicUsize> = Default::default();
    let count_clone = count.clone();
    // count will increase every 1 sec
    let _ = timer.set_interval(
        move || {
            count_clone.fetch_add(1, SeqCst);
            println!("run callback success");
        },
        Duration::from_secs(2),
    );

    sleep(Duration::from_secs(5));

    assert_eq!(count.load(SeqCst), 2);
}

pub async fn wait(&self, duration: Duration)

wait for duration time

Examples

use swnb_timer::Timer;
use std::time::Duration;

let timer = Timer::new();

let async_block = async {
    timer.wait(Duration::from_secs(1)).await;
};

// blocking_on(async_block);

Examples found in repository

examples/async_timeout.rs (line 12)

fn main() {
    let timer = Timer::new();

    // this future print count every 1 sec
    let async_block = async {
        let mut count = 1;
        loop {
            timer.wait(Duration::from_secs(1)).await;
            count += 1;
            println!("{count}");
        }
    };
}

Trait Implementations

impl Default for Timer

fn default() -> Self

Returns the “default value” for a type.