o3 0.21.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
102
103
104
105
106
107

use std::marker;

use crate::{
    buffer,
    buffer::{bytes::scope, pool, pool::owners, resident, storage},
    mem::rc,
};

/// Immutable storage whose selections retain this exact owner's identity.
///
/// Selections cannot escape their owner scope.
/// Source views remain on the owner's thread.
#[repr(transparent)]
pub struct Owner<'id, S> {
    pub(in crate::buffer::bytes::scope) storage: S,
    pub(in crate::buffer::bytes::scope) brand: marker::PhantomData<*mut &'id ()>,
}

impl<'id, S: buffer::raw::Source> Owner<'id, S> {
    pub fn view(&self) -> scope::View<'_, 'id> {
        scope::View {
            bytes: self.storage.as_ref(),
            brand: self.brand,
        }
    }
}

impl<'a, 'id, S: buffer::raw::Source + ?Sized> Owner<'id, &'a S> {
    /// Preserves the original shared borrow beyond this temporary scope owner.
    pub fn borrow(&self) -> scope::View<'a, 'id> {
        scope::View {
            bytes: self.storage.as_ref(),
            brand: self.brand,
        }
    }
}

impl<'id, S: buffer::raw::Store> Owner<'id, &mut S> {
    pub fn borrow(&self) -> scope::View<'_, 'id> {
        scope::View {
            bytes: self.storage.as_ref(),
            brand: self.brand,
        }
    }
}

impl<'id, 'd> Owner<'id, resident::Shared<'d>> {
    /// Retains this same immutable extent and identity through the exact clone.
    pub fn try_clone(&self) -> Result<Self, rc::Error> {
        Ok(Self {
            storage: self.storage.try_clone()?,
            brand: self.brand,
        })
    }
}

impl<S> Owner<'_, S> {
    pub fn with<T>(storage: S, run: impl for<'id> FnOnce(Owner<'id, S>) -> T) -> T {
        run(Owner {
            storage,
            brand: marker::PhantomData,
        })
    }

    pub fn into_inner(self) -> S {
        self.storage
    }
}

impl<'id, L> Owner<'id, pool::Span<owners::Plain<L>, pool::Owned, pool::Frozen>> {
    pub fn into_shared(self) -> Owner<'id, storage::Shared> {
        Owner {
            storage: self.storage.into_shared(),
            brand: self.brand,
        }
    }
}

impl<'id, S: buffer::raw::Store> Owner<'id, S> {
    pub fn project(mut self, range: scope::Range<'id>) -> S {
        // SAFETY: this invariant owner identity binds the range to its unchanged storage.
        S::project(unsafe { buffer::raw::Slice::from_parts(&mut self.storage, range) });
        self.storage
    }
}

impl<S: AsRef<[u8]>> AsRef<[u8]> for Owner<'_, S> {
    fn as_ref(&self) -> &[u8] {
        self.storage.as_ref()
    }
}

const _: () = {
    assert!(
        size_of::<Owner<'static, pool::Span<owners::Plain<pool::Layout>, pool::Owned, pool::Frozen>>>(
        ) == size_of::<pool::Span<owners::Plain<pool::Layout>, pool::Owned, pool::Frozen>>()
    );
    assert!(
        size_of::<
            Option<
                Owner<'static, pool::Span<owners::Plain<pool::Layout>, pool::Owned, pool::Frozen>>,
            >,
        >() == size_of::<Option<pool::Span<owners::Plain<pool::Layout>, pool::Owned, pool::Frozen>>>(
        )
    );
    assert!(size_of::<Owner<'static, storage::Shared>>() == size_of::<storage::Shared>());
};