o3 0.43.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
139
140
141
142
143
144
145
146
147
148
149
150
151

//! Fixed direct-address maps.

use std::{marker, mem};

pub use error::Error;
pub use occupied::Occupied;
pub use vacant::Vacant;

use crate::{
    alloc::array,
    depot::{capacity, index::Initialized, map::direct, queue::links},
};

mod error;

mod occupied;
pub(in crate::depot) mod raw;
mod vacant;

/// One-allocation direct table for caller-owned exact keys.
pub struct Table<K: crate::depot::raw::Key, V> {
    pub(in crate::depot) block: array::Block<raw::Entry<K, V>, capacity::Count, capacity::Count>,
}

impl<K: crate::depot::raw::Key, V> Table<K, V> {
    /// Allocates and initializes one exact backing table.
    pub fn try_new(capacity: capacity::Count) -> Result<Self, crate::alloc::Error> {
        let block = array::Block::try_new(capacity, capacity::Count::EMPTY)?
            .repeat_with(raw::Entry::vacant);
        Ok(Self { block })
    }

    pub const fn capacity(&self) -> usize {
        self.block.extent().get()
    }

    pub const fn len(&self) -> usize {
        self.block.state().get()
    }

    pub const fn is_empty(&self) -> bool {
        self.len() == 0
    }
}

impl<K: crate::depot::raw::Key, V> Table<K, V> {
    /// # Safety
    /// `index` is occupied in this exact table for the retained borrow.
    pub(in crate::depot) unsafe fn value(&self, index: links::Index) -> &V {
        unsafe {
            self.block
                .get_unchecked(index.get())
                .value
                .assume_init_ref()
        }
    }

    /// # Safety
    /// `index` is occupied in this exact table for the retained exclusive borrow.
    pub(in crate::depot) unsafe fn vacate(
        &mut self,
        index: links::Index,
    ) -> &mut mem::MaybeUninit<V> {
        let (len, entries) = self.block.parts_mut();
        // SAFETY: the caller retains this table's exact occupied index.
        let slot = unsafe { entries.get_unchecked_mut(index.get()) };
        *len = capacity::Count::new((len.get() - 1) as u32);
        slot.key = K::VACANT;
        &mut slot.value
    }

    pub fn get(&self, key: K) -> Option<&V> {
        let slot = self.block.get(key.index())?;
        (slot.key == key.into_raw()).then(|| unsafe { slot.value.assume_init_ref() })
    }

    pub fn entry_at(&self, index: usize) -> Option<(K, &V)> {
        self.block.get(index)?.read()
    }

    pub fn key_at(&self, index: usize) -> Option<K> {
        self.block.get(index)?.read().map(|(key, _)| key)
    }

    pub fn iter(&self) -> impl Iterator<Item = (K, &V)> {
        self.block.iter().filter_map(raw::Entry::read)
    }

    /// Preserves the original value, complete identity, and operation plane.
    pub fn project<P>(
        live: crate::depot::raw::Proof<(&Self, links::Index), Initialized<P>>,
    ) -> crate::depot::raw::Proof<(&V, K), Initialized<P>> {
        unsafe {
            live.map(|(read, index)| {
                let slot = read.block.get_unchecked(index.get());
                let (key, value) = slot.live();
                (value, key)
            })
        }
    }
}

impl<K: crate::depot::raw::Key, V> Table<K, V> {
    pub fn entry(&mut self, key: K) -> Option<direct::Occupied<'_, K, V>> {
        let slot = self.block.get(key.index())?;
        (slot.key == key.into_raw()).then_some(direct::Occupied {
            table: self,
            key,
            plane: marker::PhantomData,
        })
    }

    pub fn try_vacant(&mut self, key: K) -> Result<direct::Vacant<'_, K, V>, direct::Error<K>> {
        let index = key.index();
        let slot = self.block.get(index).ok_or(direct::Error::Outside {
            key,
            index,
            capacity: self.capacity(),
        })?;
        if let Some((stored, _)) = slot.read() {
            return Err(direct::Error::Occupied { key, stored });
        }
        Ok(direct::Vacant {
            table: self,
            key,
            plane: marker::PhantomData,
        })
    }

    pub fn vacant(&mut self, key: K) -> Option<direct::Vacant<'_, K, V>> {
        let slot = self.block.get(key.index())?;
        (slot.key == K::VACANT).then_some(direct::Vacant {
            table: self,
            key,
            plane: marker::PhantomData,
        })
    }

    pub fn clear(&mut self) {
        if self.is_empty() {
            return;
        }
        let (len, entries) = self.block.parts_mut();
        for entry in entries {
            if entry.key != K::VACANT {
                *entry = raw::Entry::vacant();
            }
        }
        *len = capacity::Count::EMPTY;
    }
}