Struct Timer

pub struct Timer { /* private fields */ }

A timer object that can be used to put the current thread to sleep or to start a callback after a given amount of time.

Implementations

impl Timer

pub fn new2() -> Result<(Self, Canceller)>

Create a Timer and its associated Canceller.

Examples found in repository

examples/example1.rs (line 6)

fn main() {
    let (mut timer, canceller) = Timer::new2().unwrap();

    println!("Wait 2s, uninterrupted.");
    let r = timer.sleep(Duration::from_secs(2));
    println!("Done: {:?}", r);

    println!("Wait 2s, cancelled at once.");
    canceller.cancel().unwrap();
    let r = timer.sleep(Duration::from_secs(2));
    println!("Done {:?}", r);

    println!("Wait 2s, not cancelled.");
    let r = timer.sleep(Duration::from_secs(2));
    println!("Done {:?}", r);

    println!("Wait 10s, cancel after 2s");
    let canceller2 = canceller.clone();
    std::thread::spawn(move || {
        std::thread::sleep(Duration::from_secs(2));
        canceller2.cancel().unwrap();
    });
    match timer.sleep(Duration::from_secs(10)) {
        Err(ref e) if e.kind() == io::ErrorKind::Interrupted => println!("Cancelled"),
        x => panic!("{:?}", x),
    };
}

pub fn sleep(&mut self, duration: Duration) -> Result<()>

Put the current thread to sleep until the given time has elapsed or the timer is cancelled.

Returns:

• Ok(()) if the given time has elapsed.
• An Error of kind ErrorKind::Interrupted if the timer has been cancelled.
• Some other Error if something goes wrong.

Examples found in repository

examples/example1.rs (line 9)

fn main() {
    let (mut timer, canceller) = Timer::new2().unwrap();

    println!("Wait 2s, uninterrupted.");
    let r = timer.sleep(Duration::from_secs(2));
    println!("Done: {:?}", r);

    println!("Wait 2s, cancelled at once.");
    canceller.cancel().unwrap();
    let r = timer.sleep(Duration::from_secs(2));
    println!("Done {:?}", r);

    println!("Wait 2s, not cancelled.");
    let r = timer.sleep(Duration::from_secs(2));
    println!("Done {:?}", r);

    println!("Wait 10s, cancel after 2s");
    let canceller2 = canceller.clone();
    std::thread::spawn(move || {
        std::thread::sleep(Duration::from_secs(2));
        canceller2.cancel().unwrap();
    });
    match timer.sleep(Duration::from_secs(10)) {
        Err(ref e) if e.kind() == io::ErrorKind::Interrupted => println!("Cancelled"),
        x => panic!("{:?}", x),
    };
}

pub fn after<F>(wait: Duration, callback: F) -> Result<Canceller>

where F: FnOnce(Result<()>) + Send + 'static,

Run a callback on a new thread after a specified amount of time. The callback is not run if after returns an error.

Otherwise, the callback is given:

• Ok(()) if the amount of time has elapsed.
• An Error of kind ErrorKind::Interrupted if the timer has been cancelled.
• Some other Error if something goes wrong.

Examples found in repository

examples/example2.rs (line 13)

fn main() {
    let callback = |status: io::Result<()>| match status {
        Ok(_) => println!("Called"),
        Err(ref e) if e.kind() == io::ErrorKind::Interrupted => println!("Cancelled"),
        Err(e) => eprintln!("Error: {:?}", e),
    };

    println!("Run callback after 2s");
    Timer::after(Duration::from_secs(2), callback).unwrap();

    println!("Wait 4s");
    std::thread::sleep(Duration::from_secs(4));

    println!("Run callback after 4s");
    let canceller = Timer::after(Duration::from_secs(4), callback).unwrap();

    std::thread::sleep(Duration::from_secs(2));
    println!("Cancel timer.");
    canceller.cancel().unwrap();

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