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

use std::mem;

use crate::depot::{
    capacity,
    queue::{indexed::lanes, links, tagged},
};

pub struct Position<
    'a,
    T,
    const N: usize,
    const L: usize,
    C: crate::depot::raw::Count,
    const INITIALIZED: bool = false,
> {
    pub(in crate::depot) store: &'a mut lanes::Fifo<T, N, C>,
    pub(in crate::depot) index: links::Index,
}

impl<'a, T, const N: usize, const L: usize, C: crate::depot::raw::Count>
    tagged::Vacant<Position<'a, T, N, L, C>>
{
    /// # Safety
    /// The exclusive owner proves this initialized hook is detached and in bounds.
    pub(in crate::depot) unsafe fn detached(
        store: &'a mut lanes::Fifo<T, N, C>,
        index: links::Index,
    ) -> Self {
        const { assert!(L < N) };
        unsafe { tagged::Vacant::new(Position { store, index }) }
    }

    pub fn insert<const FRONT: bool>(self, value: T) -> lanes::Rollback<'a, T, N, L, C> {
        crate::mem::Lease::open(
            crate::depot::raw::LaneUndo(std::marker::PhantomData),
            self.insert_linked::<FRONT>(value),
        )
    }
}

impl<'a, T, const N: usize, const L: usize, C: crate::depot::raw::Count>
    lanes::Rollback<'a, T, N, L, C>
{
    pub fn commit(self) {
        self.into_parts();
    }

    pub fn remove(self) -> T {
        self.into_parts().1.remove()
    }
}

const _: () = {
    assert!(
        mem::size_of::<tagged::Vacant<Position<'static, (), 1, 0, capacity::Count>>>()
            == 2 * mem::size_of::<usize>()
    );
    assert!(
        mem::size_of::<lanes::Rollback<'static, (), 1, 0, capacity::Count>>()
            == 2 * mem::size_of::<usize>()
    );
    assert!(
        mem::size_of::<Option<lanes::Rollback<'static, (), 1, 0, capacity::Count>>>()
            == 2 * mem::size_of::<usize>()
    );
};

impl<T, const N: usize, const L: usize, C: crate::depot::raw::Count, const INITIALIZED: bool>
    Position<'_, T, N, L, C, INITIALIZED>
{
    pub(in crate::depot) fn parts(&self) -> (&lanes::Fifo<T, N, C>, links::Index) {
        (&*self.store, self.index)
    }
}