o3 0.23.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

use std::array;

use crate::depot::queue::{indexed::slab, links};
const END: u32 = links::Index::END;

/// Admitted capacity retained by the allocation's exclusive borrow.
pub(in crate::depot) struct Reserved<
    'a,
    T,
    Tag,
    const MAX: u32,
    H: crate::depot::raw::IndexedHook,
    const N: usize,
    const M: usize,
    C: crate::depot::raw::Count,
> {
    core: &'a mut slab::Slab<T, Tag, MAX, H, N, C>,
}

impl<
    'a,
    T,
    Tag,
    const MAX: u32,
    H: crate::depot::raw::IndexedHook,
    const N: usize,
    const M: usize,
    C: crate::depot::raw::Count,
> Reserved<'a, T, Tag, MAX, H, N, M, C>
{
    pub(in crate::depot) fn new(core: &'a mut slab::Slab<T, Tag, MAX, H, N, C>) -> Option<Self> {
        (M <= core.available()).then_some(Self { core })
    }

    pub(in crate::depot) fn into_parts(
        self,
    ) -> (&'a mut slab::Slab<T, Tag, MAX, H, N, C>, [links::Index; M]) {
        let core = self.core;
        let free = core.available();
        let slots = array::from_fn(|_| {
            let state = core.block.state();
            // SAFETY: the exclusive borrow preserves all M admitted vacancies.
            let index = if state.free == END {
                let index = state.initialized;
                unsafe {
                    core.block.metadata.add(index as usize).as_ptr().write(
                        crate::depot::raw::IndexedMeta {
                            generation: core.block.generation.min(),
                            hook: H::new(links::Index::new_raw(index), None),
                        },
                    );
                    core.block.state_mut().initialized += 1;
                }
                index
            } else {
                let index = state.free;
                let meta = unsafe { core.block.metadata.add(index as usize).as_mut() };
                let next = unsafe { meta.hook.next() };
                meta.hook = H::new(unsafe { links::Index::new_raw(index) }, None);
                unsafe { core.block.state_mut() }.free = next;
                index
            };
            unsafe { links::Index::new_raw(index) }
        });
        if M != 0 {
            unsafe { core.block.state_mut() }.available = (free - M) as u32;
        }
        (core, slots)
    }
}