o3 0.26.2

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

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

#[must_use = "measured input must be consumed"]
pub(in crate::buffer) struct Measured<I> {
    input: I,
    len: usize,
}

pub(in crate::buffer) trait Input: Copy + buffer::raw::SliceExt {
    fn try_measure(self) -> Result<Measured<Self>, Error>;
}

impl<I> Measured<I> {
    pub(in crate::buffer) const fn len(&self) -> usize {
        self.len
    }

    pub(in crate::buffer) fn into_input(self) -> I {
        self.input
    }

    pub(in crate::buffer) const fn input(&self) -> &I {
        &self.input
    }
}

impl<'a> Measured<&'a [u8]> {
    pub(in crate::buffer) fn slice(input: &'a [u8]) -> Self {
        Self {
            len: input.len(),
            input,
        }
    }
}

impl<'a, const N: usize> Measured<[&'a [u8]; N]> {
    pub(in crate::buffer) fn try_slices(
        input: [&'a [u8]; N],
        capacity: usize,
    ) -> Result<Self, Error> {
        let len = Error::checked_end(0, capacity, &input)?;
        Ok(Self { input, len })
    }
}

impl Input for &[u8] {
    fn try_measure(self) -> Result<Measured<Self>, Error> {
        Ok(Measured::slice(self))
    }
}

impl<const N: usize> Input for [&[u8]; N] {
    fn try_measure(self) -> Result<Measured<Self>, Error> {
        Measured::try_slices(self, usize::MAX)
    }
}

impl<const P: usize, const N: usize> Input for ([u8; P], [&[u8]; N]) {
    fn try_measure(self) -> Result<Measured<Self>, Error> {
        let len = Error::checked_end(P, usize::MAX, &self.1)?;
        Ok(Measured { input: self, len })
    }
}