o3 0.7.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

use super::{Mode, SlabCore, Slot, SlotIndex, State};
use crate::collections::slab::GenerationState;

pub(super) struct Busy<'a, T, G: GenerationState, M: Mode> {
    core: &'a SlabCore<T, G, M>,
    index: SlotIndex,
    generation: G,
    live: bool,
}

impl<'a, T, G: GenerationState, M: Mode> Busy<'a, T, G, M> {
    pub(super) fn take(core: &'a SlabCore<T, G, M>, index: u32) -> Option<Self> {
        let slot = core.slots.get(index as usize)?;
        let index = SlotIndex::new(index, core.slots.len())?;
        let state = if M::REENTRANT {
            slot.state.replace(State::Busy)
        } else {
            slot.state.get()
        };
        if state == State::Occupied {
            Some(Self {
                core,
                index,
                generation: slot.generation.get(),
                live: true,
            })
        } else {
            slot.state.set(state);
            None
        }
    }

    pub(super) fn take_key(core: &'a SlabCore<T, G, M>, index: u32, generation: G) -> Option<Self> {
        let busy = Self::take(core, index)?;
        (busy.generation == generation).then_some(busy)
    }

    pub(super) fn generation(&self) -> G {
        self.generation
    }

    pub(super) fn value_mut(&mut self) -> &mut T {
        unsafe {
            &mut *self
                .core
                .slots
                .get_unchecked(self.index.get() as usize)
                .value_ptr()
        }
    }

    fn slot(&self) -> &Slot<T, G> {
        unsafe { self.core.slots.get_unchecked(self.index.get() as usize) }
    }

    pub(super) fn commit_removal(mut self) -> (T, SlotIndex) {
        let next = self.generation.next();
        let value = unsafe { self.slot().take_value() };
        self.live = false;
        self.core.remove_occupied(self.index);
        match next {
            Some(generation) => self.core.release(self.index, generation),
            None => self.slot().state.set(State::Retired),
        }
        (value, self.index)
    }
}

impl<T, G: GenerationState, M: Mode> Drop for Busy<'_, T, G, M> {
    fn drop(&mut self) {
        if self.live && M::REENTRANT {
            self.slot().state.set(State::Occupied);
        }
    }
}