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

//! Fixed-capacity locally shared immutable-value pool.

use std::{cell, mem};

use crate::depot::{
    arena::pool::{self, recycle},
    capacity,
};

#[derive(Debug)]
pub struct Resident<T> {
    pub(in crate::depot) references: crate::mem::raw::Count,
    pub(super) value: cell::UnsafeCell<mem::MaybeUninit<T>>,
}

pub type Header<T> = recycle::Header<Resident<T>>;

/// Fixed storage for locally shared immutable values.
#[repr(transparent)]
pub struct Store<T> {
    block: recycle::Store<Resident<T>>,
}

#[derive(Debug)]
pub struct Initialized;

impl<T> Resident<T> {
    const fn new() -> Self {
        Self {
            references: crate::mem::raw::Count::empty(),
            value: cell::UnsafeCell::new(mem::MaybeUninit::uninit()),
        }
    }
}

impl<T> Store<T> {
    pub fn try_new(capacity: capacity::Count) -> Result<Self, crate::alloc::Error> {
        Ok(Self {
            block: recycle::Store::try_from_fn(capacity, |_| Resident::new())?,
        })
    }

    pub fn vacancies(&self) -> &Header<T> {
        self.block.vacancies()
    }

    pub fn vacancy(&self) -> Option<pool::Vacant<'_, Resident<T>, Header<T>>> {
        self.vacancies().vacancy()
    }
}

impl<T> Header<T> {
    pub fn vacancy(&self) -> Option<pool::Vacant<'_, Resident<T>, Header<T>>> {
        pool::Vacant::new(self)
    }
}

const _: () = {
    assert!(mem::size_of::<Store<()>>() == mem::size_of::<usize>());
    assert!(mem::size_of::<&'static Header<()>>() == mem::size_of::<usize>());
    assert!(mem::size_of::<Option<&'static Header<()>>>() == mem::size_of::<usize>());
    assert!(
        mem::size_of::<pool::Vacant<'static, Resident<()>, Header<()>>>()
            == 2 * mem::size_of::<usize>()
    );
    assert!(
        mem::size_of::<Option<pool::Vacant<'static, Resident<()>, Header<()>>>>()
            == 2 * mem::size_of::<usize>()
    );
    assert!(
        mem::size_of::<pool::Unique<'static, Resident<()>, Header<()>>>()
            == mem::size_of::<usize>()
    );
    assert!(
        mem::size_of::<pool::Unique<'static, Resident<()>, Header<()>, Initialized>>()
            == mem::size_of::<usize>()
    );
    assert!(
        mem::size_of::<Option<pool::Unique<'static, Resident<()>, Header<()>, Initialized>>>()
            == mem::size_of::<usize>()
    );
    assert!(
        mem::size_of::<pool::Shared<'static, Resident<()>, Header<()>, Initialized>>()
            == mem::size_of::<usize>()
    );
    assert!(
        mem::size_of::<Option<pool::Shared<'static, Resident<()>, Header<()>, Initialized>>>()
            == mem::size_of::<usize>()
    );
};

// SAFETY: this policy is installed only after the resident value is initialized.
unsafe impl<T> crate::depot::raw::PoolPolicy<Resident<T>, Header<T>> for Initialized {
    fn retire(mut entry: pool::Terminal<'_, Resident<T>, Header<T>>) {
        // SAFETY: this policy is installed only after the resident value is initialized.
        unsafe { (*entry.get_mut().value.get()).assume_init_drop() };
        entry.recycle();
    }
}