o3 0.20.1

shared-nothing primitives
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

use std::{mem, num::NonZero};

#[repr(C)]
pub struct StagedValue<Key, Queued, Parked> {
    pub(in crate::depot) key: mem::ManuallyDrop<Key>,
    value: Value<Queued, Parked>,
}

#[repr(C)]
union Value<Queued, Parked> {
    queued: mem::ManuallyDrop<Queued>,
    parked: mem::ManuallyDrop<Parked>,
}

impl<Key, Queued, Parked> StagedValue<Key, Queued, Parked> {
    pub fn queued(key: Key, value: Queued) -> Self {
        Self {
            key: mem::ManuallyDrop::new(key),
            value: Value {
                queued: mem::ManuallyDrop::new(value),
            },
        }
    }

    pub fn parked(key: Key, value: Parked) -> Self {
        Self {
            key: mem::ManuallyDrop::new(key),
            value: Value {
                parked: mem::ManuallyDrop::new(value),
            },
        }
    }

    pub fn key(&self) -> &Key {
        &self.key
    }

    /// # Safety
    /// The union must retain its initialized `Queued` field for the returned borrow.
    pub(in crate::depot) unsafe fn queued_ref(&self) -> &Queued {
        // SAFETY: the caller proves the union's active member is `queued`.
        unsafe { &self.value.queued }
    }

    /// # Safety
    /// The union must currently hold its `Queued` variant and remain borrowed exclusively.
    pub(in crate::depot) unsafe fn queued_mut(&mut self) -> &mut Queued {
        // SAFETY: the caller proves the union's active member is `queued`.
        unsafe { &mut self.value.queued }
    }

    /// # Safety
    /// The union must currently hold its `Parked` variant and remain borrowed exclusively.
    pub(in crate::depot) unsafe fn parked_mut(&mut self) -> &mut Parked {
        // SAFETY: the caller proves the union's active member is `parked`.
        unsafe { &mut self.value.parked }
    }

    /// # Safety
    /// The union must retain its initialized `Parked` field for the returned borrow.
    pub unsafe fn parked_ref(&self) -> &Parked {
        // SAFETY: the caller proves the union's active member is `parked`.
        unsafe { &self.value.parked }
    }

    /// # Safety
    /// The retained key must be initialized and released exactly once through this call.
    pub(in crate::depot) unsafe fn take_key(&mut self) -> Key {
        // SAFETY: the caller takes the key once, consuming its initialized `ManuallyDrop`.
        unsafe { mem::ManuallyDrop::take(&mut self.key) }
    }

    /// # Safety
    /// The union must hold its `Queued` variant, taken exactly once through this call.
    pub(in crate::depot) unsafe fn take_queued(&mut self) -> Queued {
        // SAFETY: the caller proves and consumes the active `queued` member once.
        unsafe { mem::ManuallyDrop::take(&mut self.value.queued) }
    }

    /// # Safety
    /// The union must hold its `Parked` variant, taken exactly once through this call.
    pub(in crate::depot) unsafe fn take_parked(&mut self) -> Parked {
        // SAFETY: the caller proves and consumes the active `parked` member once.
        unsafe { mem::ManuallyDrop::take(&mut self.value.parked) }
    }

    /// # Safety
    /// The key and the union's `Queued` variant must each be initialized and dropped exactly once.
    pub(in crate::depot) unsafe fn clear_queued(&mut self) {
        // SAFETY: the caller drops the initialized key and active `queued` member once.
        unsafe {
            mem::ManuallyDrop::drop(&mut self.key);
            mem::ManuallyDrop::drop(&mut self.value.queued);
        }
    }

    /// # Safety
    /// The key and the union's `Parked` variant must each be initialized and dropped exactly once.
    pub(in crate::depot) unsafe fn clear_parked(&mut self) {
        // SAFETY: the caller drops the initialized key and active `parked` member once.
        unsafe {
            mem::ManuallyDrop::drop(&mut self.key);
            mem::ManuallyDrop::drop(&mut self.value.parked);
        }
    }

    pub(in crate::depot) fn write_parked(&mut self, value: Parked) {
        self.value.parked = mem::ManuallyDrop::new(value);
    }

    pub(in crate::depot) fn write_queued(&mut self, value: Queued) {
        self.value.queued = mem::ManuallyDrop::new(value);
    }
}

/// # Safety
/// This dropless node has a private one-based free link: new initializes all fields with next() == None, and reset preserves its link. Every safely constructible external node has no link; safe replacement, cloning and payload operations preserve an exposed live node's absent link, and shared references cannot change links.
/// set_next stores the exact supplied link. Hooks return normally without callbacks or storage reentry; only the storage owner links free nodes, live nodes have no link, and each free chain ends with a link to its own slot.
pub unsafe trait LinkedNode: Sized {
    type Input: Copy;

    fn new(input: Self::Input) -> Self;
    fn reset(&mut self, input: Self::Input);
    fn next(&self) -> Option<NonZero<u32>>;

    /// # Safety
    /// The exclusive storage owner retains this initialized node and preserves
    /// its exact free-chain membership, live state, and sole return rights.
    unsafe fn set_next(&mut self, next: Option<NonZero<u32>>);
}