o3 0.45.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

use storage::{backing, provided};

use crate::{
    buffer,
    buffer::{
        storage,
        storage::{provided::arena, regions},
    },
    mem::{raw, rc},
};

/// One edge retaining its concrete initialized registration and scope.
#[derive(Debug)]
pub struct Account<'d> {
    pub(super) registration: raw::Owner<arena::Registration<'d>>,
}

impl<'d> Account<'d> {
    pub(in crate::buffer) fn try_clone(&self) -> Result<Self, rc::Error> {
        Ok(Self {
            registration: self.registration.try_clone()?,
        })
    }
    pub(in crate::buffer) fn charge(&self) -> &buffer::resident::Charge<'d> {
        // SAFETY: the owner borrow retains this exact initialized registration.
        unsafe { (*self.registration.get().value.get()).assume_init_ref() }
    }
}

impl regions::End for Option<Account<'_>> {
    const EMPTY: Option<Self> = Some(None);
}

impl<'d> backing::Owner<'d> for Option<Account<'d>> {
    fn root<'a>(&'a self) -> Option<backing::Root<'a, 'd>>
    where
        'd: 'a,
    {
        self.as_ref()
            .map(|owner| backing::Root::Provided(owner.charge()))
    }
}

const _: () = assert!(size_of::<Account<'_>>() == size_of::<usize>());

impl<'d> backing::Owner<'d> for Account<'d> {
    fn root<'a>(&'a self) -> Option<backing::Root<'a, 'd>>
    where
        'd: 'a,
    {
        Some(backing::Root::Provided(self.charge()))
    }
}

impl buffer::Residency for Option<provided::Account<'_>> {
    fn resident(&self) -> usize {
        self.as_ref().map_or(0, |owner| owner.charge().capacity())
    }
}