Skip to main content

utils/parser/
tinystr.rs

1use crate::parser::{Leaf, LeafResult, ParseError};
2use crate::str::{TinyStr, TinyStrInt, TinyStrLen};
3use std::num::NonZero;
4
5#[derive(Copy, Clone)]
6pub struct TinyStringParser<T: TinyStrInt> {
7    _phantom: std::marker::PhantomData<T>,
8    f: fn(&u8) -> bool,
9}
10impl<'i, T: TinyStrInt> Leaf<'i> for TinyStringParser<T> {
11    type Output = TinyStr<T>;
12
13    #[inline(always)]
14    fn parse(&self, input: &'i [u8]) -> LeafResult<'i, Self::Output> {
15        // Use a fixed-size chunk to avoid bounds checks
16        let Some(chunk) = input.get(..=T::LEN) else {
17            return tinystr_near_end(input, self.f)
18                .ok_or((ParseError::ExpectedAtLeastMatches(1, self.f), input));
19        };
20
21        let mut len = 0;
22        let mut mask = T::len_mask(0);
23        for b in chunk {
24            if !(self.f)(b) {
25                break;
26            }
27            len += 1;
28            // Compiled into a constant in the unrolled loop
29            mask = T::len_mask(len);
30        }
31
32        if len > T::LEN {
33            return Err((
34                ParseError::ExpectedAtMostMatches(T::LEN, self.f),
35                &input[T::LEN..],
36            ));
37        }
38
39        match T::from_bytes(chunk, mask) {
40            None => Err((ParseError::ExpectedAtLeastMatches(1, self.f), input)),
41            Some(v) => Ok((TinyStr::from_raw(v), &input[len..])),
42        }
43    }
44}
45
46#[cold]
47#[inline(never)]
48fn tinystr_near_end<T: TinyStrInt>(
49    input: &[u8],
50    f: fn(&u8) -> bool,
51) -> Option<(TinyStr<T>, &[u8])> {
52    // Always at most T::LEN
53    let len = input.iter().take_while(|&b| f(b)).count();
54    Some((TinyStr::new(&input[..len])?, &input[len..]))
55}
56
57/// [`Leaf`] parser for [`TinyStr`] strings between 1 and 2 bytes matching the provided function.
58///
59/// Similar to [`Parser::repeat_arrayvec`](crate::parser::Parser::repeat_arrayvec) if more than 2
60/// bytes match, it will return an error.
61///
62/// # Examples
63/// ```
64/// # use utils::parser::{self, Leaf};
65/// # use utils::str::TinyStr2;
66/// let parser = parser::tinystr2(u8::is_ascii_lowercase);
67/// assert_eq!(
68///     parser.parse(b"ab: 123"),
69///     Ok((TinyStr2::from_const(b"ab"), &b": 123"[..]))
70/// );
71/// assert!(parser.parse(b"abc: 123").is_err());
72/// assert!(parser.parse(b"ABC").is_err());
73/// ```
74#[inline]
75#[must_use]
76pub fn tinystr2(f: fn(&u8) -> bool) -> TinyStringParser<NonZero<u16>> {
77    TinyStringParser {
78        _phantom: std::marker::PhantomData,
79        f,
80    }
81}
82
83/// [`Leaf`] parser for [`TinyStr`] strings between 1 and 4 bytes matching the provided function.
84///
85/// Similar to [`Parser::repeat_arrayvec`](crate::parser::Parser::repeat_arrayvec) if more than 4
86/// bytes match, it will return an error.
87///
88/// # Examples
89/// ```
90/// # use utils::parser::{self, Leaf};
91/// # use utils::str::TinyStr4;
92/// let parser = parser::tinystr4(u8::is_ascii_lowercase);
93/// assert_eq!(
94///     parser.parse(b"abc: 123"),
95///     Ok((TinyStr4::from_const(b"abc"), &b": 123"[..]))
96/// );
97/// assert_eq!(
98///     parser.parse(b"abcd: 123"),
99///     Ok((TinyStr4::from_const(b"abcd"), &b": 123"[..]))
100/// );
101/// assert!(parser.parse(b"abcde: 123").is_err());
102/// assert!(parser.parse(b"ABC").is_err());
103/// ```
104#[inline]
105#[must_use]
106pub fn tinystr4(f: fn(&u8) -> bool) -> TinyStringParser<NonZero<u32>> {
107    TinyStringParser {
108        _phantom: std::marker::PhantomData,
109        f,
110    }
111}
112
113/// [`Leaf`] parser for [`TinyStr`] strings between 1 and 8 bytes matching the provided function.
114///
115/// Similar to [`Parser::repeat_arrayvec`](crate::parser::Parser::repeat_arrayvec) if more than 8
116/// bytes match, it will return an error.
117///
118/// # Examples
119/// ```
120/// # use utils::parser::{self, Leaf};
121/// # use utils::str::TinyStr8;
122/// let parser = parser::tinystr8(u8::is_ascii_lowercase);
123/// assert_eq!(
124///     parser.parse(b"abcde: 123"),
125///     Ok((TinyStr8::from_const(b"abcde"), &b": 123"[..]))
126/// );
127/// assert_eq!(
128///     parser.parse(b"abcdefgh: 123"),
129///     Ok((TinyStr8::from_const(b"abcdefgh"), &b": 123"[..]))
130/// );
131/// assert!(parser.parse(b"abcdefghi: 123").is_err());
132/// assert!(parser.parse(b"ABC").is_err());
133/// ```
134#[inline]
135#[must_use]
136pub fn tinystr8(f: fn(&u8) -> bool) -> TinyStringParser<NonZero<u64>> {
137    TinyStringParser {
138        _phantom: std::marker::PhantomData,
139        f,
140    }
141}
142
143#[derive(Copy, Clone)]
144pub struct TinyStringExact<const N: usize> {
145    f: fn(&u8) -> bool,
146}
147impl<'i, const N: usize> Leaf<'i> for TinyStringExact<N>
148where
149    (): TinyStrLen<N>,
150{
151    type Output = TinyStr<<() as TinyStrLen<N>>::Int>;
152
153    #[inline(always)]
154    fn parse(&self, input: &'i [u8]) -> LeafResult<'i, Self::Output> {
155        let mut accumulator = <<() as TinyStrLen<N>>::Int as TinyStrInt>::Raw::default();
156
157        for i in 0..N {
158            if let Some(&b) = input.get(i)
159                && (self.f)(&b)
160            {
161                accumulator =
162                    <<() as TinyStrLen<N>>::Int as TinyStrInt>::set_raw(accumulator, b, i);
163            } else {
164                return Err((ParseError::ExpectedExactlyMatches(N, self.f), &input[i..]));
165            }
166        }
167
168        match <<() as TinyStrLen<N>>::Int as TinyStrInt>::from_raw(accumulator) {
169            None => Err((ParseError::ExpectedExactlyMatches(N, self.f), input)),
170            Some(v) => Ok((TinyStr::from_raw(v), &input[N..])),
171        }
172    }
173}
174
175/// [`Leaf`] parser for [`TinyStr`] strings exactly `N` long matching the provided function.
176///
177/// # Examples
178/// ```
179/// # use utils::parser::{self, Leaf};
180/// # use utils::str::TinyStr4;
181/// let parser = parser::tinystr::<3>(u8::is_ascii_lowercase);
182/// assert_eq!(
183///     parser.parse(b"abc: 123"),
184///     Ok((TinyStr4::from_const(b"abc"), &b": 123"[..]))
185/// );
186/// assert_eq!(
187///     parser.parse(b"abcd: 123"),
188///     Ok((TinyStr4::from_const(b"abc"), &b"d: 123"[..]))
189/// );
190/// assert!(parser.parse(b"ab: 123").is_err());
191/// assert!(parser.parse(b"ABC").is_err());
192/// ```
193#[inline]
194#[must_use]
195pub fn tinystr<const N: usize>(f: fn(&u8) -> bool) -> TinyStringExact<N>
196where
197    (): TinyStrLen<N>,
198{
199    TinyStringExact { f }
200}