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
51
52
53
54
55
56

use crate::time::Instant;
use crate::*;

test_fn!(
    fn share() {
        let now = Instant::now();
        let mut stakker = Stakker::new(now);
        let s = &mut stakker;

        let s1 = Share::new(s, 12345_u32);
        assert_eq!(*s1.ro(s), 12345);

        *s1.rw(s) += 11111;
        assert_eq!(*s1.ro(s), 23456);

        let s2 = Share::new(s, 98765_u32);
        assert_eq!(*s2.ro(s), 98765);

        let (p1, p2) = s.share_rw2(&s1, &s2);
        std::mem::swap(p1, p2);
        assert_eq!(*s1.ro(s), 98765);
        assert_eq!(*s2.ro(s), 23456);

        // Use a different type to check share_rw3 doesn't mind
        let s3 = Share::new(s, 13579_u64);
        assert_eq!(*s3.ro(s), 13579);

        let (p1, p2, p3) = s.share_rw3(&s1, &s2, &s3);
        *p3 += (*p2 * 3 + *p1) as u64;
        assert_eq!(*s3.ro(s), 13579 + 23456 * 3 + 98765);
    }
);

test_fn!(
    fn share_weak() {
        let now = Instant::now();
        let mut stakker = Stakker::new(now);
        let s = &mut stakker;

        let s1 = Share::new(s, 12345_u32);
        assert_eq!(*s1.ro(s), 12345);
        assert_eq!(s1.strong_count(), 1);
        assert_eq!(s1.weak_count(), 0);

        let w1 = s1.downgrade();
        assert_eq!(s1.strong_count(), 1);
        assert_eq!(s1.weak_count(), 1);
        assert_eq!(w1.strong_count(), 1);
        assert_eq!(w1.weak_count(), 1);
        assert_eq!(*w1.upgrade().unwrap().ro(s), 12345);

        drop(s1);
        assert_eq!(w1.strong_count(), 0);
        assert!(w1.upgrade().is_none());
    }
);