o3 0.26.3

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

use std::mem;

use crate::{
    base::num::bounded,
    depot::queue::{links, round},
};

/// A resident resolved against one exact allocation.
pub struct Slot<'a, T, const G: usize, const N: usize = 0> {
    pub(in crate::depot::queue::round) owner: &'a round::Lanes<T, G, N>,
    pub(in crate::depot::queue::round) index: links::Index,
}

impl<'a, T, const G: usize, const N: usize> Slot<'a, T, G, N> {
    pub fn get(&self) -> &'a T {
        // SAFETY: this slot retains the allocation against which its index was admitted.
        unsafe {
            &self
                .owner
                .block
                .as_ref()
                .get_unchecked(self.index.get())
                .value
        }
    }

    pub const fn index(&self) -> usize {
        self.index.get()
    }

    pub fn is_linked(&self) -> bool {
        let node = unsafe { self.owner.block.as_ref().get_unchecked(self.index.get()) };
        self.index.is_linked(&node.hook)
    }

    /// Removes the resident from its current lane, if any.
    pub fn clear(&self) -> &'a T {
        let node = unsafe { self.owner.block.as_ref().get_unchecked(self.index.get()) };
        if self.index.is_linked(&node.hook) {
            let lane = unsafe { self.owner.block.values().get_unchecked(self.index.get()) }.get();
            return round::Location::<_, round::Linked>::new(
                self.owner,
                round::Position {
                    lane,
                    index: self.index,
                },
            )
            .remove()
            .get();
        }
        self.get()
    }

    /// Admits a destination while retaining this resident's original owner.
    pub fn try_lane(
        &self,
        index: usize,
    ) -> Result<round::Snapshot<&'a round::Lanes<T, G, N>, round::Place>, round::Bounds> {
        let lane = round::Lane::try_new(self.owner, index)?;
        Ok(round::Snapshot::new(
            lane.owner,
            round::Position {
                lane: lane.index,
                index: self.index,
            },
        ))
    }

    /// Keeps the allocation's static lane extent through destination selection.
    pub fn lane<const MAX: u32>(
        &self,
        index: bounded::U32<0, MAX>,
    ) -> round::Snapshot<&'a round::Lanes<T, G, N>, round::Place> {
        let lane = self.owner.lane(index);
        round::Snapshot::new(
            lane.owner,
            round::Position {
                lane: lane.index,
                index: self.index,
            },
        )
    }
}

const _: () = assert!(mem::size_of::<Slot<'static, (), 1>>() == 2 * mem::size_of::<usize>());