o3 0.33.2

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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use std::mem;

use crate::{
    buffer,
    buffer::{
        segments,
        segments::{
            Chain, Handle, Key,
            chain::{view, view::iter::Iter},
            handles::{self, Occupied},
        },
    },
    depot::arena::linked::{self, slots},
};

impl<T, H: Handle<T>> Chain<T, H> {
    pub fn clear(&mut self) {
        let key = mem::replace(&mut self.key, Key::EMPTY);
        Self::release(&self.handle, &key);
    }

    fn release(handle: &H, key: &Key) {
        let nodes = handles::nodes(handle);
        let index = match key.state() {
            None => return,
            Some(Occupied::Single(index)) => {
                // SAFETY: this detached key retains its exact initialized node.
                drop(unsafe { nodes.detached(index) });
                return;
            }
            Some(Occupied::Multi(index)) => index,
        };
        let descs = handles::descriptors(handle);
        // SAFETY: this detached multi key uniquely owns its exact descriptor.
        let (mut desc, retired) = unsafe { descs.detached(index) }.take();
        // SAFETY: the descriptor owns this exact tracked node-store partition.
        unsafe { desc.links.clear(nodes) };
        retired.release();
    }
}

impl<T, H: Handle<T>> Drop for Chain<T, H> {
    fn drop(&mut self) {
        Self::release(&self.handle, &self.key);
    }
}

impl<T: buffer::raw::Segment, H: Handle<T>> Chain<T, H> {
    pub(in crate::buffer::segments) fn state(&self) -> view::State<'_, T> {
        if self.key.is_empty() {
            return view::State::Empty;
        }
        // SAFETY: this unchanged owner has a nonempty key.
        match unsafe { self.occupied() } {
            view::Occupied::Single(index, item) => view::State::Single(index, item),
            view::Occupied::Multi(desc) => view::State::Multi(desc),
        }
    }

    /// # Safety
    /// This unchanged sequence owns a nonempty chain.
    pub(in crate::buffer::segments) unsafe fn occupied(&self) -> view::Occupied<'_, T> {
        // SAFETY: the caller's nonempty owner proof excludes the empty key.
        match unsafe { self.key.occupied() } {
            handles::Occupied::Single(index) => {
                // SAFETY: this shared owner retains its exact initialized single node.
                let node = unsafe { handles::nodes(&self.handle).value(index) };
                view::Occupied::Single(index, node)
            }
            handles::Occupied::Multi(index) => {
                // SAFETY: this shared owner retains its exact initialized descriptor.
                let desc = unsafe { handles::descriptors(&self.handle).value(index) };
                view::Occupied::Multi(desc)
            }
        }
    }
    pub(in crate::buffer::segments) fn totals(&self) -> (segments::Count, usize, usize) {
        match self.state() {
            view::State::Empty => (segments::Count::EMPTY, 0, 0),
            view::State::Single(_, item) => (
                segments::Count::ONE,
                item.len().get(),
                buffer::Residency::resident(item),
            ),
            view::State::Multi(desc) => (
                segments::Count::new(desc.count.get()),
                desc.len,
                desc.resident_bytes,
            ),
        }
    }

    pub fn len(&self) -> usize {
        match self.state() {
            view::State::Empty => 0,
            view::State::Single(_, item) => item.len().get(),
            view::State::Multi(desc) => desc.len,
        }
    }

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

    pub fn count(&self) -> segments::Count {
        match self.state() {
            view::State::Empty => segments::Count::EMPTY,
            view::State::Single(_, _) => segments::Count::ONE,
            view::State::Multi(desc) => segments::Count::new(desc.count.get()),
        }
    }

    pub fn resident(&self) -> usize {
        match self.state() {
            view::State::Empty => 0,
            view::State::Single(_, item) => buffer::Residency::resident(item),
            view::State::Multi(desc) => desc.resident_bytes,
        }
    }

    pub fn segments(&self) -> Iter<'_, T> {
        let (head, left) = match self.state() {
            view::State::Empty => (slots::Index::NONE, segments::Count::EMPTY),
            view::State::Single(index, _) => (index, segments::Count::ONE),
            view::State::Multi(desc) => (
                desc.links.head_raw(),
                segments::Count::new(desc.count.get()),
            ),
        };
        // SAFETY: this sequence borrow retains the exact immutable live chain.
        let cursor = unsafe { linked::Iter::new(handles::nodes(&self.handle), head) };
        Iter::new(cursor, left)
    }

    pub fn contiguous(&self) -> Option<&[u8]> {
        match self.state() {
            view::State::Empty => Some(&[]),
            view::State::Single(_, item) => Some(item.as_ref().as_ref()),
            view::State::Multi(_) => None,
        }
    }

    pub(in crate::buffer::segments) fn is_same(&self, other: &Self) -> bool {
        self.handle.is_same(&other.handle)
    }
}