o3 0.34.2

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

use std::marker;

use crate::depot::{map::direct, queue::links, raw::Live};

/// A direct-address slot validated occupied for one exact key.
pub struct Occupied<'a, K: crate::depot::raw::Key, V, P = ()> {
    pub(in crate::depot::map::direct) table: &'a mut direct::Table<K, V>,
    pub(in crate::depot::map::direct) key: K,
    pub(in crate::depot::map::direct) plane: marker::PhantomData<fn(P) -> P>,
}

impl<'a, K: crate::depot::raw::Key, V> Occupied<'a, K, V> {
    pub fn from_live<C, P>(
        live: Live<(&'a mut direct::Table<K, V>, C), links::Index, P>,
    ) -> (Occupied<'a, K, V, P>, C) {
        let ((table, context), index) = live.into_inner();
        let slot = unsafe { table.block.get_unchecked(index.get()) };
        let key = K::from_live(unsafe { slot.key.live() });
        (
            Occupied {
                table,
                key,
                plane: marker::PhantomData,
            },
            context,
        )
    }
}

impl<'a, K: crate::depot::raw::Key, V, P> Occupied<'a, K, V, P> {
    pub fn key(&self) -> K {
        self.key
    }

    pub(in crate::depot) fn index(&self) -> usize {
        self.key.index()
    }

    pub(in crate::depot) fn table(&self) -> &direct::Table<K, V> {
        self.table
    }

    fn slot(&self) -> &direct::raw::Entry<K, V> {
        unsafe { self.table.block.get_unchecked(self.key.index()) }
    }

    fn slot_mut(&mut self) -> &mut direct::raw::Entry<K, V> {
        unsafe { self.table.block.get_unchecked_mut(self.key.index()) }
    }

    fn into_slot(self) -> &'a mut direct::raw::Entry<K, V> {
        unsafe { self.table.block.get_unchecked_mut(self.key.index()) }
    }

    pub fn get(&self) -> &V {
        unsafe { self.slot().value.assume_init_ref() }
    }

    pub(in crate::depot) fn get_mut(&mut self) -> &mut V {
        unsafe { self.slot_mut().value.assume_init_mut() }
    }

    pub fn into_mut(self) -> &'a mut V {
        unsafe { self.into_slot().value.assume_init_mut() }
    }

    pub fn remove(self) -> V {
        self.take().1
    }

    pub fn take(self) -> (direct::Vacant<'a, K, V, P>, V) {
        // SAFETY: this exact occupied key was admitted within its u32-sized table.
        let index = unsafe { links::Index::new_usize(self.index()) };
        unsafe { self.take_at(index) }
    }

    /// # Safety
    /// `index` is this occupied entry's previously resolved exact table position.
    pub(in crate::depot) unsafe fn take_at(
        self,
        index: links::Index,
    ) -> (direct::Vacant<'a, K, V, P>, V) {
        let value = unsafe { self.table.vacate(index).assume_init_read() };
        (
            direct::Vacant {
                table: self.table,
                key: self.key,
                plane: marker::PhantomData,
            },
            value,
        )
    }

    pub fn discard(self) {
        // SAFETY: this exact occupied key was admitted within its u32-sized table.
        let index = unsafe { links::Index::new_usize(self.index()) };
        unsafe { self.discard_at(index) };
    }

    /// # Safety
    /// `index` is this occupied entry's previously resolved exact table position.
    pub(in crate::depot) unsafe fn discard_at(self, index: links::Index) {
        unsafe { self.table.vacate(index).assume_init_drop() };
    }
}