o3 0.21.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
73
74
75
76
77
78
79
80
81
82

use std::marker;

use cycle::Policy;

use crate::depot::arena::slab::{
    entries,
    key::{self, cycle},
    lookup, storage,
};

/// Read access to the slots disjoint from one retained exclusive slot.
pub struct Rest<
    'a,
    T,
    Tag = (),
    const MAX: u32 = { u32::MAX },
    const RECYCLE: bool = false,
    const PARTITIONS: usize = 1,
    P = (),
    S = storage::Heap,
    I = storage::Eager,
> where
    cycle::Mode<RECYCLE>: Policy,
    S: storage::Storage,
    I: storage::Init,
{
    core: &'a entries::Core<T, MAX, entries::Exclusive<RECYCLE>, PARTITIONS, S, I>,
    excluded: entries::SlotIndex,
    plane: Domain<Tag, P>,
}

impl<'a, T, Tag, const MAX: u32, const RECYCLE: bool, const PARTITIONS: usize, P, S, I>
    Rest<'a, T, Tag, MAX, RECYCLE, PARTITIONS, P, S, I>
where
    cycle::Mode<RECYCLE>: Policy,
    S: storage::Storage,
    I: storage::Init,
{
    pub(in crate::depot::arena::slab) fn new(
        busy: &entries::Busy<'a, T, MAX, entries::Exclusive<RECYCLE>, PARTITIONS, P, S, I>,
    ) -> Self {
        Self {
            core: busy.core,
            excluded: entries::SlotIndex(busy.index()),
            plane: marker::PhantomData,
        }
    }

    pub fn try_get(
        &self,
        key: key::Handle<Tag, MAX>,
    ) -> Result<&'a T, key::Error<Tag, MAX, lookup::Busy, <cycle::Mode<RECYCLE> as Policy>::Retired>>
    {
        let entry = entries::Occupied::try_key(self.core, key).map_err(|error| match error {
            key::Error::Index { key, capacity } => key::Error::Index { key, capacity },
            key::Error::Free { key, actual } => key::Error::Free { key, actual },
            key::Error::Reserved { key, actual } => key::Error::Reserved { key, actual },
            key::Error::Retired {
                key,
                actual,
                retired,
            } => key::Error::Retired {
                key,
                actual,
                retired,
            },
            key::Error::Generation { key, actual } => key::Error::Generation { key, actual },
        })?;
        if key.index() == self.excluded.get() {
            return Err(key::Error::Busy {
                key,
                actual: key.generation(),
                borrow: lookup::Busy {
                    index: self.excluded.get(),
                },
            });
        }
        Ok(entry.read())
    }
}

type Domain<Tag, P> = marker::PhantomData<fn(Tag, P) -> (Tag, P)>;