o3 0.34.4

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Compact head state over external linked slots.

use std::{cell, mem};

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

/// Compact head for one externally stored linked list.
#[repr(transparent)]
pub struct List<Tag = ()> {
    pub(in crate::depot::arena::linked) head: slots::Index<Tag>,
}

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

impl<Tag> List<Tag> {
    pub const fn new() -> Self {
        Self {
            head: slots::Index::NONE,
        }
    }
}

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

/// Interior-mutable head of a forward chain stored in external slots.
#[repr(transparent)]
pub struct Cell<L: crate::depot::raw::Link = u32>(pub(in crate::depot) cell::Cell<L>);

/// Owner-bound proof of one present exclusive head.
#[must_use = "a present head must be consumed or left linked"]
pub struct Front<'a, L: crate::depot::raw::Link = u32> {
    owner: &'a Cell<L>,
    present: L::Item,
}

impl<L: crate::depot::raw::Link> Front<'_, L> {
    pub fn item(&self) -> L::Item {
        self.present
    }

    /// # Safety
    /// The transition owns this exact head's storage and does not reenter the head.
    pub(in crate::depot) unsafe fn pop<I, P: depot::raw::HeadPop<L, I>>(
        self,
        pop: P,
        input: I,
    ) -> P::Output {
        let (next, result) = unsafe { pop.pop(self.present, input) };
        self.owner.0.set(next);
        result
    }
}

impl<L: crate::depot::raw::Link> Cell<L> {
    pub const fn new(first: L) -> Self {
        Self(cell::Cell::new(first))
    }

    pub fn raw(&self) -> L {
        self.0.get()
    }

    pub fn front(&self) -> Option<Front<'_, L>> {
        let present = self.raw().item()?;
        Some(Front {
            owner: self,
            present,
        })
    }
}

const _: () = {
    assert!(mem::size_of::<Cell>() == mem::size_of::<u32>());
    assert!(mem::size_of::<Cell<u16>>() == mem::size_of::<u16>());
    assert!(mem::size_of::<Front<'static>>() == 2 * mem::size_of::<usize>());
};

impl<Tag> List<Tag> {
    /// # Safety
    /// This state owns one acyclic live partition in this exact store.
    pub(in crate::depot) unsafe fn iter<'a, T>(
        &'a self,
        store: &'a slots::Store<T>,
    ) -> linked::Iter<'a, T, Tag> {
        unsafe { linked::Iter::new(store, self.head) }
    }

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

    /// # Safety
    /// This state owns one acyclic live partition in this exact store.
    pub(in crate::depot) unsafe fn front_entry<'a, 'b, T>(
        &'b mut self,
        store: &'a slots::Store<T>,
    ) -> Option<slots::Entry<'a, 'b, T, Tag>> {
        if self.head == slots::Index::NONE {
            return None;
        }
        Some(unsafe { slots::Entry::new(store, self) })
    }
}