dope 0.4.6

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::num::NonZeroU64;

pub const ROUTE_FRAMEWORK: u8 = 255;
pub const ROUTE_TASKS: u8 = 254;

pub const ROUTE_SHIFT: u32 = 56;
pub const KIND_SHIFT: u32 = 48;
const EPOCH_SHIFT: u32 = 24;
pub const SLOT_BITS: u32 = 24;
const EPOCH_BITS: u32 = 24;
pub const SLOT_MASK: u64 = (1 << SLOT_BITS) - 1;
pub const EPOCH_MASK: u64 = (1 << EPOCH_BITS) - 1;

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct Key {
    index: LocalIdx,
    epoch: Epoch,
}

impl Key {
    pub const fn new(index: LocalIdx, epoch: Epoch) -> Self {
        Self { index, epoch }
    }

    pub const fn index(self) -> LocalIdx {
        self.index
    }

    pub const fn epoch(self) -> Epoch {
        self.epoch
    }
}

pub mod kind {
    pub const ACCEPT: u8 = 1;
    pub const RECV: u8 = 2;
    pub const SEND: u8 = 3;
    pub const TIMER: u8 = 4;
    pub const SOCKET: u8 = 5;
    pub const CONNECT: u8 = 6;
    pub const SHUTDOWN: u8 = 7;
    pub const SETSOCKOPT: u8 = 8;
    pub const WRITE: u8 = 9;
    pub const SYNC: u8 = 10;
    pub const OPEN: u8 = 11;
    pub const READ: u8 = 12;
    pub const SPLICE: u8 = 13;
}

#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Default)]
#[repr(transparent)]
pub struct LocalIdx(u32);

impl LocalIdx {
    pub const fn new(raw: u32) -> Self {
        Self(raw)
    }

    pub const fn raw(self) -> u32 {
        self.0
    }
}

#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Default)]
#[repr(transparent)]
pub struct Epoch(u32);

impl Epoch {
    pub const INITIAL: Self = Self(1);
    pub const ZERO: Self = Self(0);

    pub const fn raw(self) -> u32 {
        self.0
    }

    pub const fn bump(self) -> Self {
        let e = self.0.wrapping_add(1) & (EPOCH_MASK as u32);
        Self(if e == 0 { 1 } else { e })
    }
}

#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
#[repr(transparent)]
pub struct Token(NonZeroU64);

impl Token {
    pub const fn new(route: u8, slot: LocalIdx, epoch: Epoch) -> Self {
        debug_assert!((slot.0 as u64) <= SLOT_MASK);
        let raw = ((route as u64) << ROUTE_SHIFT)
            | ((epoch.0 as u64) << EPOCH_SHIFT)
            | (slot.0 as u64 & SLOT_MASK);
        Self(NonZeroU64::new(raw).expect("Token::new: route/slot/epoch all zero"))
    }

    pub(super) const fn with_kind(self, kind: u8) -> Self {
        let cleared = self.0.get() & !((0xFFu64) << KIND_SHIFT);
        let raw = cleared | ((kind as u64) << KIND_SHIFT);
        Self(NonZeroU64::new(raw).expect("Token::with_kind: zero raw"))
    }

    pub const fn from_raw(raw: u64) -> Self {
        Self(NonZeroU64::new(raw).expect("Token::from_raw: zero raw"))
    }

    pub const fn try_from_raw(raw: u64) -> Option<Self> {
        match NonZeroU64::new(raw) {
            Some(v) => Some(Self(v)),
            None => None,
        }
    }

    pub const fn raw(self) -> u64 {
        self.0.get()
    }

    pub const fn route(self) -> u8 {
        (self.0.get() >> ROUTE_SHIFT) as u8
    }

    pub const fn slot(self) -> LocalIdx {
        LocalIdx((self.0.get() & SLOT_MASK) as u32)
    }

    pub const fn epoch(self) -> Epoch {
        Epoch(((self.0.get() >> EPOCH_SHIFT) & EPOCH_MASK) as u32)
    }

    pub const fn key(self) -> Key {
        Key::new(self.slot(), self.epoch())
    }

    pub const fn from_key(route: u8, key: Key) -> Self {
        Self::new(route, key.index(), key.epoch())
    }
}

pub const SHUTDOWN: Token =
    Token::new(ROUTE_FRAMEWORK, LocalIdx::new(0), Epoch::ZERO).with_kind(kind::SHUTDOWN);