sark-http 0.28.7

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
92
93
94
95
96
97
98
99
100
101

use core::{num::NonZero, ops::ControlFlow};

use crate::h1::chunk::{Error, Framer, Limit, Run, scan::state};

/// The exact trailer phase, with no body or size-line alternatives.
#[derive(Clone, Copy)]
pub(in crate::h1) struct Trailer {
    pub(in crate::h1) cursor: Cursor,
    limits: Limit,
}

/// Mutable scan progress; limits remain with the original trailer owner.
#[derive(Clone, Copy)]
pub(in crate::h1) struct Cursor {
    pub(super) state: state::State,
    pub(super) wire: usize,
}

pub(in crate::h1) enum Progress {
    More {
        next: Cursor,
        consumed: Option<NonZero<usize>>,
    },
    Complete {
        wire: usize,
        consumed: NonZero<usize>,
        trailers: NonZero<u32>,
    },
}

/// The current input's exact admitted trailer prefix and its continuation.
pub(in crate::h1) struct Partial<'input> {
    bytes: &'input [u8],
    consumed: NonZero<usize>,
    next: Trailer,
}

impl Trailer {
    pub(super) const fn new(state: state::State, wire: usize, limits: Limit) -> Self {
        Self {
            cursor: Cursor { state, wire },
            limits,
        }
    }

    pub(in crate::h1) const fn capacity(&self) -> usize {
        self.limits.trailers()
    }

    pub(in crate::h1) fn scan(mut self, input: &[u8]) -> Result<(Progress, &[u8]), Error> {
        let mut consumed = None;
        for (offset, &byte) in input.iter().enumerate() {
            let wire = Framer::wire(self.cursor.wire, 1, &self.limits)?;
            let progress = self
                .cursor
                .state
                .scan(byte, self.cursor.wire, &self.limits)?;
            self.cursor.wire = wire;
            let next = NonZero::<usize>::MIN.saturating_add(offset);
            match progress {
                ControlFlow::Continue(state) => self.cursor.state = state,
                ControlFlow::Break(trailers) => {
                    return Ok((
                        Progress::Complete {
                            wire,
                            consumed: next,
                            trailers,
                        },
                        Run::complete(input, next.get()).into_slice(),
                    ));
                }
            }
            consumed = Some(next);
        }
        Ok((
            Progress::More {
                next: self.cursor,
                consumed,
            },
            input,
        ))
    }
}

impl<'input> Partial<'input> {
    pub(super) fn new(bytes: &'input [u8], consumed: NonZero<usize>, next: Trailer) -> Self {
        Self {
            bytes,
            consumed,
            next,
        }
    }

    pub(in crate::h1) const fn consumed(&self) -> NonZero<usize> {
        self.consumed
    }

    pub(in crate::h1) fn into_parts(self) -> (&'input [u8], NonZero<usize>, Trailer) {
        (self.bytes, self.consumed, self.next)
    }
}