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
100
101

//! Counted FIFO state over external linked slots.

use std::mem;

use crate::{depot, depot::arena::linked::slots};

pub mod ends;

/// Compact counted FIFO state stored outside its linked node arena.
#[repr(transparent)]
pub struct Fifo<Tag = ()> {
    pub(in crate::depot::arena::linked) state: slots::State<Tag>,
}

impl<Tag> Default for Fifo<Tag> {
    fn default() -> Self {
        Self::new()
    }
}

impl<Tag> Fifo<Tag> {
    pub const fn new() -> Self {
        Self {
            state: slots::State::new(),
        }
    }

    pub const fn len(&self) -> usize {
        self.state.count().get()
    }

    pub const fn is_empty(&self) -> bool {
        self.state.is_empty()
    }

    pub fn back(&self) -> Option<Back<Tag>> {
        let index = slots::Index::new(self.state.back_index()?);
        Some(Back { index })
    }
}

const _: () = assert!(mem::size_of::<Fifo>() == 3 * mem::size_of::<u32>());

/// One observed live FIFO tail in a linked-node domain.
#[must_use]
#[repr(transparent)]
pub struct Back<Tag> {
    index: slots::Index<Tag>,
}

impl<Tag> Back<Tag> {
    pub(in crate::depot::arena::linked) const fn into_index(self) -> slots::Index<Tag> {
        self.index
    }
}

const _: () = assert!(mem::size_of::<Back<()>>() == mem::size_of::<u32>());

impl<Tag> Fifo<Tag> {
    /// # Safety
    /// This state owns one acyclic live partition in this exact store.
    pub(in crate::depot) unsafe fn queue<'a, T>(
        &'a mut self,
        store: &'a slots::Store<T>,
    ) -> slots::Bound<'a, T, Tag> {
        unsafe { self.state.bind(store) }
    }
}

/// The retained front is current, or the retained FIFO may be empty.
/// The callback detaches that exact stable front, returns its exact stored successor,
/// and neither reenters nor invalidates the retained endpoints during the operation.
#[derive(Debug)]
pub enum Detach {}

/// The retained index is a valid detached slot disjoint from the stable destination chain.
/// The callback stores the exact former front as its successor before publication,
/// without reentry or invalidating either the slot or destination endpoints.
#[derive(Debug)]
pub enum Prepend {}

/// The retained index is a valid detached tail slot disjoint from the stable destination chain.
/// The callback links the exact former tail to it before endpoint publication,
/// without reentry or invalidating either the slot or destination endpoints.
#[derive(Debug)]
pub enum Append {}

/// Both retained chains are stable, valid, disjoint partitions in one exact slot store.
/// The callback links the destination's exact former tail to the source's exact front,
/// without reentry or invalidating either chain before their endpoints are published.
#[derive(Debug)]
pub enum Join {}

impl depot::raw::Sealed for Detach {}
impl depot::Predicate for Detach {}
impl depot::raw::Sealed for Prepend {}
impl depot::Predicate for Prepend {}
impl depot::raw::Sealed for Append {}
impl depot::Predicate for Append {}
impl depot::raw::Sealed for Join {}
impl depot::Predicate for Join {}