ntex-httparse 2.2.0

A tiny, safe, speedy, zero-copy HTTP/1.x parser.
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
102
103
104
105
106

#![allow(clippy::cast_sign_loss)]
use core::convert::TryInto;

use crate::{SlicePos, State};

#[allow(missing_docs)]
pub(crate) struct Bytes<'a, 'b> {
    slice: &'a [u8],
    pub(crate) st: &'b mut State,
}

#[allow(missing_docs)]
impl<'a, 'b> Bytes<'a, 'b> {
    #[inline]
    pub(crate) fn new(slice: &'a [u8], st: &'b mut State) -> Bytes<'a, 'b> {
        Bytes { slice, st }
    }

    #[inline]
    pub(crate) fn start(&self) -> usize {
        self.st.start
    }

    #[inline]
    pub(crate) fn cursor(&self) -> usize {
        self.st.cursor
    }

    #[inline]
    pub(crate) fn peek(&self) -> Option<u8> {
        self.slice.get(self.st.cursor).copied()
    }

    /// Peek at byte `n` ahead of cursor, `None` if it is past the end.
    #[inline]
    pub(crate) fn peek_ahead(&self, n: usize) -> Option<u8> {
        self.slice.get(self.st.cursor + n).copied()
    }

    #[inline]
    pub(crate) fn peek_behind(&self, n: usize) -> Option<u8> {
        if n > self.st.cursor {
            None
        } else {
            self.slice.get(self.st.cursor - n).copied()
        }
    }

    #[inline]
    pub(crate) fn peek_n<const N: usize>(&self) -> Option<[u8; N]> {
        self.as_ref().get(..N)?.try_into().ok()
    }

    /// Advance cursor by `n`
    ///
    /// The cursor must stay within the slice, otherwise later reads panic.
    #[inline]
    pub(crate) fn advance(&mut self, n: usize) {
        self.st.cursor += n;
        debug_assert!(self.st.cursor <= self.slice.len(), "overflow");
    }

    #[inline]
    pub(crate) fn rewind(&mut self, n: usize) {
        self.st.cursor -= n;
    }

    #[inline]
    pub(crate) fn slice_position(&mut self, skip: usize) -> SlicePos {
        let start = self.st.start;
        let end = self.st.cursor - skip;
        self.commit();
        SlicePos { start, end }
    }

    #[inline]
    pub(crate) fn commit(&mut self) {
        self.st.start = self.st.cursor;
    }

    /// Bytes from `pos` up to the cursor.
    #[inline]
    pub(crate) fn since(&self, pos: usize) -> &[u8] {
        &self.slice[pos..self.st.cursor]
    }
}

impl AsRef<[u8]> for Bytes<'_, '_> {
    #[inline]
    fn as_ref(&self) -> &[u8] {
        &self.slice[self.st.cursor..]
    }
}

impl Iterator for Bytes<'_, '_> {
    type Item = u8;

    #[inline]
    fn next(&mut self) -> Option<u8> {
        let b = self.slice.get(self.st.cursor).copied();
        if b.is_some() {
            self.advance(1);
        }
        b
    }
}