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

use std::ops;

use crate::{
    buffer,
    buffer::{bytes::scope, storage::range},
};
/// One exclusive target paired with its original owner's selected range.
pub struct Slice<'a, 'id, S: ?Sized> {
    target: &'a mut S,
    range: scope::Range<'id>,
}

impl<'a, S: buffer::raw::Store> Slice<'a, '_, S> {
    /// Selections cannot escape the exclusive operation.
    pub fn try_with<T>(
        target: &'a mut S,
        bounds: ops::Range<usize>,
        run: impl for<'id> FnOnce(Slice<'a, 'id, S>) -> T,
    ) -> Result<T, range::Error> {
        scope::Owner::with(target, |owner| {
            let range = owner.borrow().try_get(bounds)?;
            Ok(run(Slice {
                target: owner.into_inner(),
                range,
            }))
        })
    }
}

impl<S: buffer::raw::Store> Slice<'_, '_, S> {
    pub(in crate::buffer) fn try_project(
        mut target: S,
        bounds: ops::Range<usize>,
    ) -> Result<S, crate::mem::Rejected<S, range::Error>> {
        match Slice::try_with(&mut target, bounds, S::project) {
            Ok(()) => Ok(target),
            Err(error) => Err(crate::mem::Rejected::new(target, error)),
        }
    }
}

impl<'a, 'id, S: ?Sized> Slice<'a, 'id, S> {
    /// # Safety
    /// `target` must expose the original operation's unchanged visible bytes and
    /// preserve its original owner.
    pub unsafe fn from_parts(target: &'a mut S, range: scope::Range<'id>) -> Self {
        Self { target, range }
    }

    pub fn into_parts(self) -> (&'a mut S, scope::Range<'id>) {
        (self.target, self.range)
    }

    /// # Safety
    /// The projected target must expose the original target's unchanged visible
    /// bytes and preserve its original owner.
    pub unsafe fn map<T: ?Sized>(
        self,
        project: impl FnOnce(&'a mut S) -> &'a mut T,
    ) -> Slice<'a, 'id, T> {
        Slice {
            target: project(self.target),
            range: self.range,
        }
    }
}

impl<S: buffer::raw::Store> Slice<'_, '_, S> {
    pub(in crate::buffer::raw) fn apply(self) {
        if self.range.is_empty()
            && let Some(empty) = S::empty()
        {
            *self.target = empty;
            return;
        }
        S::restrict(self);
    }
}

const _: () = {
    assert!(size_of::<Slice<'static, 'static, Vec<u8>>>() == 3 * size_of::<usize>());
    assert!(
        size_of::<Option<Slice<'static, 'static, Vec<u8>>>>()
            == size_of::<Slice<'static, 'static, Vec<u8>>>()
    );
};