o3 0.26.3

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

use pool::state;

use crate::buffer::{pool, pool::owners, write::consume::Error};

/// A cursor and the remaining write budget admitted by that exact cursor.
pub struct Limit<T, B> {
    target: T,
    remaining: u32,
    brand: B,
}

impl<T: AsRef<[u8]>, B> AsRef<[u8]> for Limit<T, B> {
    fn as_ref(&self) -> &[u8] {
        self.target.as_ref()
    }
}

impl<T, B> Limit<T, B> {
    pub const fn remaining(&self) -> usize {
        self.remaining as usize
    }

    pub fn brand(&self) -> &B {
        &self.brand
    }

    pub fn into_parts(self) -> (T, B) {
        (self.target, self.brand)
    }
}

impl<L, M, B> Limit<pool::Cursor<L, M>, B> {
    pub fn try_from(
        target: pool::Cursor<L, M>,
        bytes: usize,
        brand: B,
    ) -> Result<Self, (pool::Cursor<L, M>, B, Error)> {
        if let Err(error) = Error::check(bytes, target.spare_len()) {
            return Err((target, brand, error));
        }
        Ok(Self {
            target,
            remaining: bytes as u32,
            brand,
        })
    }

    pub fn try_extend(&mut self, src: &[u8]) -> Result<(), Error> {
        let input = owners::Measured::slice(src);
        Error::check(input.len(), self.remaining as usize)?;
        self.target.compact_for(input.len());
        self.remaining -= input.len() as u32;
        pool::Append {
            target: &mut self.target,
            input,
        }
        .commit();
        Ok(())
    }
}

impl<L, B> Limit<pool::Cursor<L>, B> {
    pub fn try_acquire(
        pool: &pool::Pool<state::Uninit, owners::Plain<L>>,
        bytes: usize,
        brand: B,
    ) -> Result<Self, (B, pool::Error)> {
        if let Err(error) = Error::check(bytes, pool.capacity().get() as usize) {
            return Err((brand, pool::Error::Capacity(error)));
        }
        let Some(target) = pool.cursor() else {
            return Err((brand, pool::Error::Empty));
        };
        Ok(Self {
            target,
            remaining: bytes as u32,
            brand,
        })
    }
}

impl<'pool, L, B> Limit<pool::Cursor<L, pool::Borrowed<'pool>>, B> {
    pub fn try_borrow(
        pool: &'pool pool::Pool<state::Uninit, owners::Plain<L>>,
        bytes: usize,
        brand: B,
    ) -> Result<Self, (B, pool::Error)> {
        if let Err(error) = Error::check(bytes, pool.capacity().get() as usize) {
            return Err((brand, pool::Error::Capacity(error)));
        }
        let Some(target) = pool.view() else {
            return Err((brand, pool::Error::Empty));
        };
        Ok(Self {
            target,
            remaining: bytes as u32,
            brand,
        })
    }
}

const _: () = {
    assert!(size_of::<Limit<pool::Cursor, u8>>() == size_of::<pool::Cursor>() + size_of::<usize>());
    assert!(size_of::<Option<Limit<pool::Cursor, u8>>>() == size_of::<Limit<pool::Cursor, u8>>());
};