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}