sark-http 0.27.0

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

use crate::field::{
    head,
    metadata::{block, map::record},
};

#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct Name(head::Name);

impl Default for Name {
    fn default() -> Self {
        Self::REGULAR
    }
}

impl Name {
    pub const REGULAR: Self = Self(head::Name::Regular);
    pub const INVALID: Self = Self(head::Name::Invalid);
    pub(crate) const COMPACT: [Self; 18] = [
        Self(head::Name::Invalid),
        Self(head::Name::Method),
        Self(head::Name::Scheme),
        Self(head::Name::Path),
        Self(head::Name::Status),
        Self(head::Name::Authority),
        Self(head::Name::Protocol),
        Self(head::Name::Host),
        Self(head::Name::Connection),
        Self(head::Name::ContentLength),
        Self(head::Name::TransferEncoding),
        Self(head::Name::Expect),
        Self(head::Name::AcceptEncoding),
        Self(head::Name::Te),
        Self(head::Name::KeepAlive),
        Self(head::Name::ProxyConnection),
        Self(head::Name::Upgrade),
        Self(head::Name::Regular),
    ];

    pub const fn from_head(name: head::Name) -> Self {
        Self(name)
    }

    pub const fn head(self) -> head::Name {
        self.0
    }

    pub const fn compact(self) -> u8 {
        self.0 as u8
    }

    pub const fn from_compact(value: u8) -> Option<Self> {
        if (value as usize) < Self::COMPACT.len() {
            Some(Self::COMPACT[value as usize])
        } else {
            None
        }
    }

    pub const fn is_forbidden(self) -> bool {
        matches!(
            self.0,
            head::Name::Invalid
                | head::Name::Connection
                | head::Name::TransferEncoding
                | head::Name::KeepAlive
                | head::Name::ProxyConnection
                | head::Name::Upgrade
        )
    }

    pub fn from_span(name: record::Span<'_>) -> Self {
        let mut scan = block::Scan::new();
        for byte in name.iter().copied() {
            scan.push(byte);
        }
        scan.finish()
    }

    pub const fn classify(name: &[u8]) -> Self {
        let mut scan = block::Scan::new();
        let mut index = 0;
        while index < name.len() {
            scan.push(name[index]);
            index += 1;
        }
        scan.finish()
    }
}

const _: () = assert!(core::mem::size_of::<Name>() == 1);