o3 0.36.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
131
132
133
134
135
136
137
138

use std::marker;

use cycle::Policy;

use crate::{
    depot::{
        arena::slab::{
            self, entries,
            key::{self, cycle},
        },
        index::Initialized,
        queue::links,
    },
    mem::lease,
};

/// An initialized slot held through its exclusive native owner.
pub struct Occupied<B, Tag = (), const ROOT: bool = true> {
    pub(in crate::depot::arena::slab) entry: B,
    pub(in crate::depot::arena::slab) tag: marker::PhantomData<fn() -> Tag>,
}

impl<'a, T, Tag, const MAX: u32, const RECYCLE: bool, const PARTITIONS: usize>
    slab::Occupied<entries::Busy<'a, T, MAX, entries::Exclusive<RECYCLE>, PARTITIONS>, Tag>
where
    cycle::Mode<RECYCLE>: Policy,
{
    /// Consumes a live root projection into its selected exclusive slot.
    pub fn from_live<C, P>(
        live: Live<'a, T, Tag, C, P, MAX, RECYCLE, PARTITIONS>,
    ) -> (
        slab::Occupied<entries::Busy<'a, T, MAX, entries::Exclusive<RECYCLE>, PARTITIONS, P>, Tag>,
        C,
    ) {
        // SAFETY: the projection retains the original exclusive owner and context.
        let live = unsafe { live.map(|((slab, context), index)| ((&slab.core, context), index)) };
        let (busy, context) = live.into();
        (
            slab::Occupied {
                entry: busy,
                tag: marker::PhantomData,
            },
            context,
        )
    }

    pub(in crate::depot::arena::slab) fn new(
        entry: entries::Occupied<'a, T, MAX, entries::Exclusive<RECYCLE>, PARTITIONS>,
    ) -> Self {
        Self {
            entry: entry.take(),
            tag: marker::PhantomData,
        }
    }
}

impl<'a, T, Tag, const MAX: u32, const RECYCLE: bool, const PARTITIONS: usize, P, const ROOT: bool>
    slab::Occupied<entries::Busy<'a, T, MAX, entries::Exclusive<RECYCLE>, PARTITIONS, P>, Tag, ROOT>
where
    cycle::Mode<RECYCLE>: Policy,
{
    pub fn key(&self) -> key::Handle<Tag, MAX> {
        key::Handle::new(self.entry.index(), self.entry.generation())
    }

    pub fn get(&self) -> &T {
        self.entry.value()
    }

    pub fn get_mut(&mut self) -> &mut T {
        self.entry.value_mut()
    }

    pub fn into_mut(self) -> &'a mut T {
        self.entry.into_mut()
    }

    /// Withdraws the value while retaining its owner, identity, and operation plane.
    pub fn take(self) -> Withdrawn<'a, T, Tag, P, MAX, RECYCLE, PARTITIONS, ROOT> {
        let (pending, value) = self.entry.withdraw();
        (slab::Withdrawn::new(pending), value)
    }

    pub fn remove(self) -> T {
        self.entry.remove()
    }

    pub fn discard(self) {
        self.entry.discard();
    }
}

impl<'a, T, Tag, const MAX: u32, const RECYCLE: bool, const PARTITIONS: usize, P>
    slab::Occupied<entries::Busy<'a, T, MAX, entries::Exclusive<RECYCLE>, PARTITIONS, P>, Tag>
where
    cycle::Mode<RECYCLE>: Policy,
{
    /// Projects a live neighbor while retaining the whole storage owner's exclusive loan.
    pub fn project<Q>(
        live: crate::depot::raw::Proof<(&Self, links::Index), Initialized<Q>>,
    ) -> (key::Handle<Tag, MAX>, &T) {
        let index = *live.key();
        // SAFETY: the occupied guard owns this exact core for its full borrow.
        let live = unsafe { live.map(|(entry, index)| (&entry.entry, index)) };
        let (epoch, value) = entries::Busy::project(live);
        (key::Handle::new(index.raw(), epoch), value)
    }
}

type Live<'a, T, Tag, C, P, const MAX: u32, const RECYCLE: bool, const PARTITIONS: usize> =
    crate::depot::raw::Proof<
        (
            (&'a mut slab::Store<T, Tag, MAX, RECYCLE, PARTITIONS>, C),
            links::Index,
        ),
        Initialized<P>,
    >;

type Withdrawn<
    'a,
    T,
    Tag,
    P,
    const MAX: u32,
    const RECYCLE: bool,
    const PARTITIONS: usize,
    const ROOT: bool,
> = (
    slab::Withdrawn<
        crate::mem::Lease<
            entries::Pending<'a, T, MAX, entries::Exclusive<RECYCLE>, PARTITIONS, P>,
            lease::Open,
        >,
        Tag,
        ROOT,
    >,
    T,
);