o3 0.28.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
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use std::{marker, num::NonZero};

use crate::{
    buffer,
    buffer::{segments, storage},
    mem::rc,
};
/// A strict prefix bound retaining its exclusive owner until consumption.
pub(in crate::buffer) struct Tail<'a, T, N = usize> {
    source: &'a mut T,
    amount: N,
}

impl<'a, T: buffer::raw::Segment> Tail<'a, T> {
    pub(in crate::buffer) fn new(source: &'a mut T, amount: usize) -> Option<Self> {
        if amount >= source.as_ref().len() {
            return None;
        }
        Some(Self { source, amount })
    }

    /// Retains this prefix before committing any change to the original owner.
    pub(in crate::buffer) fn try_commit(self) -> Result<T, rc::Error> {
        let prefix = self.view().try_retain()?;
        self.commit();
        Ok(prefix)
    }
}

impl<'a, T: buffer::raw::Segment> Tail<'a, T, NonZero<usize>> {
    pub(in crate::buffer) fn positive(
        source: &'a mut segments::Item<T>,
        amount: NonZero<usize>,
    ) -> Option<Self> {
        if amount >= source.len() {
            return None;
        }
        Some(Self {
            source: &mut source.value,
            amount,
        })
    }
}

impl<T: buffer::raw::Segment, N: marker::Copy + Into<usize>> Tail<'_, T, N> {
    pub(in crate::buffer) fn view(&self) -> buffer::View<'_, T> {
        // SAFETY: admission retains this exact owner and its strict prefix bound.
        let bytes = unsafe { self.source.as_ref().get_unchecked(..self.amount.into()) };
        buffer::View {
            source: self.source,
            bytes,
        }
    }

    pub(in crate::buffer) fn commit(self) {
        let amount = self.amount;
        // SAFETY: this strict prefix retains the original exclusive owner loan.
        let extent = unsafe { self.source.extent() };
        // SAFETY: admission leaves a nonempty suffix in this same backing.
        *extent = unsafe { extent.restrict(amount.into()..extent.len()) };
    }
}

impl<T, N> AsRef<T> for Tail<'_, T, N> {
    fn as_ref(&self) -> &T {
        self.source
    }
}

const _: () = {
    assert!(size_of::<Tail<'static, storage::Shared>>() == 2 * size_of::<usize>());
    assert!(size_of::<Option<Tail<'static, storage::Shared>>>() == 2 * size_of::<usize>());
    assert!(size_of::<Tail<'static, storage::Shared, NonZero<usize>>>() == 2 * size_of::<usize>());
    assert!(
        size_of::<Option<Tail<'static, storage::Shared, NonZero<usize>>>>()
            == 2 * size_of::<usize>()
    );
};