o3 0.30.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
79
80
81
82
83
84

use std::fmt;

use crate::{
    buffer,
    buffer::{hold, resident, segments::Item, storage, storage::regions, write::consume},
    mem::rc,
};

pub trait Seal: Sized {
    type Retention: Default + fmt::Debug;

    const EMPTY: Self;

    fn try_copy(
        source: Result<buffer::raw::Slices<'_, 1>, consume::Error>,
        domain: &Self::Retention,
    ) -> Result<Item<Self>, hold::CopyError>;
    fn try_share(view: regions::NonEmpty<'_, '_, Self>) -> Result<Item<Self>, rc::Error>;
}

impl Seal for storage::Shared {
    type Retention = ();

    const EMPTY: Self = Self::new();

    fn try_copy(
        source: Result<buffer::raw::Slices<'_, 1>, consume::Error>,
        (): &Self::Retention,
    ) -> Result<Item<Self>, hold::CopyError> {
        let source = source
            .map_err(storage::AllocError::Capacity)
            .map_err(hold::CopyError::Storage)?;
        let value = source
            .try_owned()
            .map_err(storage::AllocError::Exhausted)
            .map_err(hold::CopyError::Storage)?
            .into_shared();
        Ok(Item {
            value,
            nonempty: (),
        })
    }

    fn try_share(view: regions::NonEmpty<'_, '_, Self>) -> Result<Item<Self>, rc::Error> {
        Ok(Item {
            value: view.view().try_clone()?,
            nonempty: (),
        })
    }
}

impl<'d> Seal for resident::Shared<'d> {
    type Retention = Option<resident::Budget<'d>>;

    const EMPTY: Self = Self::new();

    fn try_copy(
        source: Result<buffer::raw::Slices<'_, 1>, consume::Error>,
        domain: &Self::Retention,
    ) -> Result<Item<Self>, hold::CopyError> {
        let source = source
            .map_err(resident::AllocError::Capacity)
            .map_err(hold::CopyError::Resident)?;
        let budget = domain
            .as_ref()
            .ok_or(hold::CopyError::Authority(resident::BindError::Unbound))?;
        let value = source
            .try_copy(budget)
            .map_err(resident::AllocError::from)
            .map_err(hold::CopyError::Resident)?
            .into_shared();
        Ok(Item {
            value,
            nonempty: (),
        })
    }

    fn try_share(view: regions::NonEmpty<'_, '_, Self>) -> Result<Item<Self>, rc::Error> {
        Ok(Item {
            value: resident::Shared::try_share(view)?,
            nonempty: (),
        })
    }
}