o3 0.43.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 std::{num::NonZero, pin::Pin};

use o3::{
    base::cell::region,
    buffer::{
        self, Complete as _,
        bytes::bounded,
        resident,
        storage::{self, provided},
    },
};

use crate::common::buffer::provided::Error;

/// Capacity of a scoped resident test domain.
pub struct Capacity(pub usize);

impl Capacity {
    pub fn try_scope<R>(
        self,
        op: impl for<'d> FnOnce(resident::Budget<'d>) -> R,
    ) -> Result<R, resident::Reuse> {
        let mut domain = resident::Domain::new();
        region::Token::scope_pinned(Pin::new(&mut domain), |token, domain| {
            let budget = domain.get_mut().try_budget(self.0, token.proof())?;
            Ok(op(budget))
        })
    }

    pub fn try_bytes<const N: usize>(
        self,
        bytes: [u8; N],
        apply: impl for<'a, 'd> FnOnce(
            bounded::Value<buffer::View<'a, storage::Shared<provided::Owner<'d>>>>,
            resident::Budget<'d>,
        ),
    ) -> Result<(usize, Option<[u8; N]>), Error> {
        let mut arena = provided::Arena::<_, _>::try_allocate(NonZero::<u32>::MIN)
            .map_err(Error::Allocation)?(());
        let mut domain = resident::Domain::new();
        arena.scope(Pin::new(&mut domain), |token, arena, domain| {
            let budget = domain
                .get_mut()
                .try_budget(self.0, token.proof())
                .map_err(Error::Budget)?;
            let resident = {
                let slot = arena.vacant().ok_or(Error::SlotEmpty)?;
                let source = slot.try_insert(bytes, N as u32, <[u8; N]>::as_mut_slice);
                let source = source.map_err(|rejected| Error::Projection(rejected.discard()))?;

                let source = bounded::Value::try_new(source.into_shared());
                let source = source.map_err(|rejected| Error::Bounded(rejected.into_parts().1))?;
                apply(source.view(), budget);
                budget.resident()
            };
            Ok((resident, arena.pop_returned()))
        })
    }
}