taq 1.2.0

A simple Tokio task abstraction.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use std::time::Duration;
use taq::*;
use tokio::time::sleep;

#[derive(Default)]
pub struct Interval {
    dur: Duration,
    cb: Option<Box<dyn FnMut() + Send>>,
}

impl Interval {
    pub fn set_interval<F>(&mut self, cb: F, dur: Duration)
    where
        F: FnMut() + Send + 'static,
    {
        self.dur = dur;
        self.cb = Some(Box::new(cb));
    }

    async fn interval(&mut self) -> ! {
        // will loop until future is cancelled
        if let Some(cb) = &mut self.cb {
            loop {
                sleep(self.dur).await;
                cb();
            }
        } else {
            futures::future::pending::<()>().await;
            unreachable!();
        }
    }
}

#[async_trait::async_trait]
impl Task for Interval {
    async fn task(mut self, mut manager: TaskManager<Self>) -> Option<()> {
        loop {
            tokio::select! {
                _ = self.interval() => unreachable!(),
                run = manager.poll() => run?.with(&mut self).await,
            }
        }
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let handle = taq::run(Interval::default());

    handle.run(job!(|interval| {
        interval.set_interval(|| println!("hello"), Duration::from_secs(1));
    }))?;

    let _ = handle.clone();

    futures::future::pending::<()>().await;

    unreachable!()
}