stakker 0.2.15

A lightweight low-level single-threaded actor runtime
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

use crate::task::*;
use crate::time::Instant;
use crate::*;
use std::cell::RefCell;
use std::pin::Pin;
use std::rc::Rc;

// This tests the Task mechanism, but without needing async/await
test_fn!(
    fn task_test() {
        let now = Instant::now();
        let mut stakker = Stakker::new(now);
        let s = &mut stakker;

        let progress0 = Rc::new(RefCell::new(Vec::new()));

        struct MyTask {
            deferrer: Deferrer,
            count: u32,
            progress: Rc<RefCell<Vec<u32>>>,
        }
        impl TaskTrait for MyTask {
            fn resume(mut self: Pin<&mut Self>, core: &mut Core) {
                self.progress.borrow_mut().push(self.count);
                self.count += 1;
                if self.count < 4 {
                    let mut task = Task::from_context(&self.deferrer).unwrap();
                    call!([core], |s| task.resume(s));
                }
            }
        }

        let my_task = MyTask {
            deferrer: s.deferrer(),
            count: 0,
            progress: progress0.clone(),
        };
        let mut task = Task::new(s, my_task);
        task.resume(s);

        // Task reference should now be held in item on queue
        drop(task);

        // Executing the queue causes the task to be repeatedly resumed
        // and queued until it is done
        s.run(now, false);

        assert_eq!(vec![0, 1, 2, 3], *progress0.borrow());
    }
);