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

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, C> {
        let Position { store, index } = self.insert_linked::<FRONT>(value).into_inner();
        // SAFETY: insertion established this exact initialized membership and exclusive owner.
        let entry = unsafe { tagged::Linked::new(crate::depot::raw::Proof::new((store, index))) };
        crate::mem::Lease::open(crate::depot::raw::LaneUndo(std::marker::PhantomData), entry)
    }
}

impl<'a, T, const N: usize, C: crate::depot::raw::Count> lanes::Rollback<'a, T, N, 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, capacity::Count>>()
            == 2 * mem::size_of::<usize>()
    );
    assert!(
        mem::size_of::<Option<lanes::Rollback<'static, (), 1, capacity::Count>>>()
            == 2 * mem::size_of::<usize>()
    );
};