o3 0.34.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::{cell, convert};

use crate::depot::{
    arena::slab::{
        self, entries,
        external::{self, errors, shared},
        lookup,
    },
    capacity,
    index::Initialized,
};

impl<'a, T, G: external::Generation, Tag> Borrowed<'a, T, G, Tag> {
    pub fn key(&self) -> external::Key<G, Tag> {
        external::Key::new(
            self.inner.entry.index(),
            self.inner.entry.value().generation,
        )
    }

    pub(super) fn try_epoch(self, epoch: G) -> Result<Self, errors::Lookup<G, Tag, ()>> {
        let actual = self.inner.entry.value().generation;
        if actual != epoch {
            let key = external::Key::new(self.inner.entry.index(), epoch);
            return Err(errors::Lookup::Generation { key, actual });
        }
        Ok(self)
    }

    pub fn take(self) -> T {
        self.inner.remove().value
    }

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

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

impl<'a, T, G: external::Generation, Tag>
    crate::depot::raw::Proof<(&'a shared::Storage<T, G, Tag>, u32), Initialized<entries::Allocated>>
{
    pub fn vacancy(self) -> Result<Vacancy<'a, T, G, Tag>, slab::Vacancy> {
        let owner = *self.source();
        owner.issue(|| slab::Cell::reserve(self.into_native()))
    }

    pub fn try_entry(
        self,
    ) -> Result<Borrowed<'a, T, G, Tag>, lookup::Error<(), convert::Infallible>> {
        Ok(slab::Cell::current(self.into_native())?.into_external())
    }

    pub fn try_key(self, epoch: G) -> Result<Borrowed<'a, T, G, Tag>, errors::Lookup<G, Tag, ()>> {
        let key = external::Key::new(*self.key(), epoch);
        let current = self
            .try_entry()
            .map_err(|cause| errors::Lookup::Physical { key, cause })?;
        current.try_epoch(epoch)
    }

    fn into_native(self) -> Allocated<'a, T, G, Tag> {
        // SAFETY: this projection retains the same admitted backing allocation.
        unsafe { self.map(|(owner, index)| (&owner.inner, index)) }
    }
}

/// Shared interior-mutable storage with independent non-wrapping logical identities.
pub struct Storage<T, G: external::Generation, Tag = ()> {
    pub(in crate::depot::arena::slab::external::shared) inner:
        slab::Cell<external::Stamped<T, G>, Tag, 1, true>,
    pub(in crate::depot::arena::slab::external::shared) next: cell::Cell<Option<G>>,
}

impl<T, G: external::Generation, Tag> Storage<T, G, Tag> {
    pub fn try_new(cap: capacity::Count) -> Result<Self, crate::alloc::Error> {
        let inner = slab::Cell::<external::Stamped<T, G>, Tag, 1, true>::try_new(cap)?;
        Ok(Self {
            inner,
            next: cell::Cell::new(Some(G::INITIAL)),
        })
    }

    fn issue<'a>(
        &'a self,
        acquire: impl FnOnce() -> Option<slab::Vacant<Pending<'a, T, G>, Tag>>,
    ) -> Result<Vacancy<'a, T, G, Tag>, slab::Vacancy> {
        let epoch = self.next.get().ok_or(slab::Vacancy::IdentityExhausted)?;
        let inner = acquire().ok_or(slab::Vacancy::Full)?;
        self.next.set(epoch.next());
        Ok(inner.with_state(epoch))
    }

    pub fn is_empty(&self) -> bool {
        self.inner.is_empty()
    }

    pub fn vacancy_at(&self, index: u32) -> Result<Vacancy<'_, T, G, Tag>, slab::Vacancy> {
        self.issue(|| self.inner.vacancy_at(index))
    }

    pub fn vacancy(&self) -> Result<Vacancy<'_, T, G, Tag>, slab::Vacancy> {
        self.issue(|| self.inner.vacancy())
    }

    /// Acquires one exact logical identity and retains its physical borrow.
    pub fn try_entry(
        &self,
        key: external::Key<G, Tag>,
    ) -> Result<Borrowed<'_, T, G, Tag>, errors::Lookup<G, Tag, ()>> {
        self.try_entry_at(key.index())
            .map_err(|cause| errors::Lookup::Physical { key, cause })?
            .try_epoch(key.generation())
    }

    /// Acquires the logical identity currently occupying one physical slot.
    pub fn try_entry_at(
        &self,
        index: u32,
    ) -> Result<Borrowed<'_, T, G, Tag>, lookup::Error<(), convert::Infallible>> {
        Ok(self.inner.try_entry_at(index)?.into_external())
    }
}

/// Shared slot phases preserve the same physical allocation and logical epoch owner.
type Pending<'a, T, G> = entries::Pending<'a, external::Stamped<T, G>, 1, entries::Interior<true>>;
type Busy<'a, T, G> = entries::Busy<'a, external::Stamped<T, G>, 1, entries::Interior<true>>;
pub type Vacancy<'a, T, G, Tag = ()> = external::Vacant<Pending<'a, T, G>, Tag, true, G>;
pub type Borrowed<'a, T, G, Tag = ()> = external::Borrowed<Busy<'a, T, G>, Tag, true>;

/// Physical allocation proof is retained before checking logical generation.
type Allocated<'a, T, G, Tag> = crate::depot::raw::Proof<
    (&'a slab::Cell<external::Stamped<T, G>, Tag, 1, true>, u32),
    Initialized<entries::Allocated>,
>;