sark-http 0.22.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

use crate::{
    field,
    field::{
        storage::encoded,
        text::percent::{Error, Length, octet, scan},
    },
};

pub struct Encoder<'a> {
    text: &'a str,
    length: Length,
}

impl<'a> Encoder<'a> {
    pub fn new(text: &'a str) -> Result<Self, Error> {
        Ok(Self {
            text,
            length: Length::measure(text.as_bytes())?,
        })
    }

    /// Reuses the encoded length admitted for this exact immutable text.
    /// # Safety
    /// `length` must describe these same text bytes, measured by this codec.
    pub const unsafe fn from_length(text: &'a str, length: Length) -> Self {
        Self { text, length }
    }

    pub const fn length(&self) -> Length {
        self.length
    }
}

impl encoded::Encoded for Encoder<'_> {}

impl field::Encode for Encoder<'_> {
    fn encoded_len(&self) -> usize {
        self.length.get()
    }

    fn try_write<E>(self, mut emit: impl FnMut(&[u8]) -> Result<(), E>) -> Result<(), E> {
        let mut bytes = self.text.as_bytes();
        while !bytes.is_empty() {
            let (literal, suffix) = scan::Scan::new(bytes).plain();
            emit(literal)?;
            let Some((&byte, tail)) = suffix.split_first() else {
                return Ok(());
            };
            emit(&octet::encode(byte))?;
            bytes = tail;
        }
        Ok(())
    }
}

const _: () = assert!(core::mem::size_of::<Encoder<'_>>() == 3 * core::mem::size_of::<usize>());