sark-http 0.29.3

HTTP wire types, semantics, codecs, and ownership invariants for Sark
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

use crate::{
    field::metadata::{
        block::{self, table::Entry},
        map::record::Span,
    },
    payload::compress::dynamic::Whole,
};

pub(super) const NAME_LEN_BITS: u32 = 27;
pub(super) const NAME_LEN_MASK: u32 = (1 << NAME_LEN_BITS) - 1;

#[derive(Clone, Copy, PartialEq, Eq)]
pub struct Field<'a> {
    pub(crate) name: Span<'a>,
    pub(crate) value: Span<'a>,
    pub(crate) proof: block::Name,
    pub(crate) validation: Whole,
}

impl<'a> Field<'a> {
    pub const fn name(self) -> block::Named<'a> {
        block::Named::from_scanned(self.name, self.proof)
    }

    pub const fn value(self) -> Span<'a> {
        self.value
    }

    /// Retains the entry's admission verdict, including rejection of its name.
    pub const fn valued(self) -> block::Valued<'a> {
        block::Valued::from_scanned(self.value, self.validation.validation())
    }

    pub const fn validation(self) -> Whole {
        self.validation
    }

    pub const fn data_len(self) -> usize {
        self.name.len() + self.value.len()
    }
}

impl<'a> From<Entry<'_, 'a>> for Field<'a> {
    fn from(entry: Entry<'_, 'a>) -> Self {
        let name = entry.name();
        Self {
            name: name.span(),
            value: Span::from_slice(entry.value()),
            proof: name.proof(),
            validation: Whole::valid(name.proof()),
        }
    }
}