o3 0.27.0

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

use slab::slot;

use crate::depot::{
    capacity,
    queue::{indexed::slab, links},
};

/// Two resolved positions retained under their exact allocation's exclusive borrow.
pub struct Cursor<
    'a,
    T,
    Tag = (),
    const MAX: u32 = { u32::MAX },
    C: crate::depot::raw::Count = capacity::Count,
> {
    pub(in crate::depot) entry: slab::Slot<'a, T, Tag, MAX, links::Hook, 0, C>,
    pub(in crate::depot) parent: Option<links::Index>,
}

impl<'a, T, Tag, const MAX: u32, C: crate::depot::raw::Count> Cursor<'a, T, Tag, MAX, C> {
    pub(in crate::depot) fn new(entry: slab::Slot<'a, T, Tag, MAX, links::Hook, 0, C>) -> Self {
        Self {
            entry,
            parent: None,
        }
    }

    pub fn try_insert(
        self,
        build: impl FnOnce(Option<&mut T>, slab::Handle<Tag, MAX>) -> T,
    ) -> Result<Self, C> {
        let parent = Some(self.entry.index);
        self.splice(parent, build)
    }

    pub fn try_prepend(
        self,
        build: impl FnOnce(Option<&mut T>, slab::Handle<Tag, MAX>) -> T,
    ) -> Result<Self, C> {
        let parent = self.parent;
        self.splice(parent, build)
    }

    fn splice(
        self,
        parent: Option<links::Index>,
        build: impl FnOnce(Option<&mut T>, slab::Handle<Tag, MAX>) -> T,
    ) -> Result<Self, C> {
        let (core, _) = self.entry.into_owner();
        let capacity = core.capacity();
        let Some(slot) = core.vacant() else {
            return Err(capacity);
        };
        // SAFETY: Cursor owns its initialized parent in the same allocation;
        // the newly reserved slot is distinct and retained until insertion.
        let splice = unsafe { slot::Splice::new(slot, parent) };
        Ok(Self {
            entry: splice.insert(build),
            parent,
        })
    }

    pub fn remove<R>(self, unlink: impl FnOnce(Option<&mut T>, T) -> R) -> R {
        let (value, slot) = self.entry.detach().into_spare();
        // SAFETY: suspension retains the exact allocation and reserved slot;
        // Cursor's distinct initialized parent remains live until unlink commits.
        let splice = unsafe { slot::Splice::new(slot, self.parent) };
        splice.remove(value, unlink)
    }
}

const _: () = assert!(size_of::<Cursor<'static, u64>>() == 3 * size_of::<usize>());