dope 0.12.0

The manifold 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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

extern crate dope;
use o3::cell::{BrandCell, BrandToken};
use std::cell::Cell;
use std::marker::PhantomPinned;

struct Slot {
    inflight: Vec<u8>,
    close_after: bool,
}

struct Aux {
    scratch: Vec<u8>,
}

struct Timer {
    armed: u32,
}

struct Pinned {
    value: Cell<u32>,
    _pin: PhantomPinned,
}

struct Listener {
    pool: Vec<Slot>,
    app: App,
    aux: Aux,
}

struct App {
    seen: usize,
}

impl App {
    fn chunk<'id>(
        &mut self,
        slot: &mut Slot,
        chunk: &[u8],
        aux: &mut Aux,
        timer: &BrandCell<'id, Timer>,
        token: &mut BrandToken<'id>,
    ) -> bool {
        aux.scratch.clear();
        aux.scratch.extend_from_slice(chunk);
        slot.inflight.extend_from_slice(&aux.scratch);
        timer.borrow_mut(token).armed += 1;
        self.seen += 1;
        chunk.ends_with(b"\n")
    }
}

#[test]
fn dispatch_loop_shape_under_split_brands() {
    BrandToken::scope(|mut listener_token| {
        BrandToken::scope(|mut timer_token| {
            let listener = BrandCell::new(Listener {
                pool: vec![
                    Slot {
                        inflight: Vec::new(),
                        close_after: false,
                    },
                    Slot {
                        inflight: Vec::new(),
                        close_after: false,
                    },
                ],
                app: App { seen: 0 },
                aux: Aux {
                    scratch: Vec::new(),
                },
            });
            let timer = BrandCell::new(Timer { armed: 0 });
            let timer_handle = &timer;

            let events: [(usize, &[u8]); 3] = [(0, b"a"), (1, b"b\n"), (0, b"c\n")];
            for (idx, chunk) in events {
                let this = listener.borrow_mut(&mut listener_token);
                let (pool, app, aux) = (&mut this.pool, &mut this.app, &mut this.aux);
                let slot = &mut pool[idx];
                if app.chunk(slot, chunk, aux, timer_handle, &mut timer_token) {
                    slot.close_after = true;
                }
            }

            let this = listener.borrow(&listener_token);
            assert_eq!(this.app.seen, 3);
            assert_eq!(this.pool[0].inflight, b"ac\n");
            assert!(this.pool[0].close_after);
            assert!(this.pool[1].close_after);
            assert_eq!(timer.borrow(&timer_token).armed, 3);
        });
    });
}

#[test]
fn pinned_borrow_keeps_the_value_in_place() {
    BrandToken::scope(|mut token| {
        let cell = BrandCell::new(Pinned {
            value: Cell::new(0),
            _pin: PhantomPinned,
        });
        let cell = std::pin::pin!(cell);
        let first = {
            let value = cell.as_ref().borrow_pin_mut(&mut token);
            value.as_ref().get_ref().value.set(7);
            value.as_ref().get_ref() as *const Pinned
        };
        let value = cell.as_ref().borrow_pin(&token);
        assert_eq!(first, value.get_ref() as *const Pinned);
        assert_eq!(value.get_ref().value.get(), 7);
    });
}