winnow/stream/
bytes.rs

Help
1use core::num::NonZeroUsize;
2
3use crate::error::Needed;
4use crate::lib::std::iter::{Cloned, Enumerate};
5use crate::lib::std::slice::Iter;
6use crate::lib::std::{cmp::Ordering, fmt, ops};
7use crate::stream::AsBytes;
8use crate::stream::Checkpoint;
9use crate::stream::Compare;
10use crate::stream::CompareResult;
11use crate::stream::FindSlice;
12use crate::stream::Offset;
13#[cfg(feature = "unstable-recover")]
14#[cfg(feature = "std")]
15use crate::stream::Recover;
16use crate::stream::SliceLen;
17use crate::stream::Stream;
18use crate::stream::StreamIsPartial;
19use crate::stream::UpdateSlice;
20
21/// Improved `Debug` experience for `&[u8]` byte streams
22#[allow(clippy::derived_hash_with_manual_eq)]
23#[derive(Hash)]
24#[repr(transparent)]
25pub struct Bytes([u8]);
26
27impl Bytes {
28    /// Make a stream out of a byte slice-like.
29    #[inline]
30    pub fn new<B: ?Sized + AsRef<[u8]>>(bytes: &B) -> &Self {
31        Self::from_bytes(bytes.as_ref())
32    }
33
34    #[inline]
35    fn from_bytes(slice: &[u8]) -> &Self {
36        unsafe { crate::lib::std::mem::transmute(slice) }
37    }
38
39    #[inline]
40    fn as_bytes(&self) -> &[u8] {
41        &self.0
42    }
43}
44
45impl SliceLen for &Bytes {
46    #[inline(always)]
47    fn slice_len(&self) -> usize {
48        self.len()
49    }
50}
51
52impl<'i> Stream for &'i Bytes {
53    type Token = u8;
54    type Slice = &'i [u8];
55
56    type IterOffsets = Enumerate<Cloned<Iter<'i, u8>>>;
57
58    type Checkpoint = Checkpoint<Self, Self>;
59
60    #[inline(always)]
61    fn iter_offsets(&self) -> Self::IterOffsets {
62        self.iter().cloned().enumerate()
63    }
64    #[inline(always)]
65    fn eof_offset(&self) -> usize {
66        self.len()
67    }
68
69    #[inline(always)]
70    fn next_token(&mut self) -> Option<Self::Token> {
71        if self.is_empty() {
72            None
73        } else {
74            let token = self[0];
75            *self = &self[1..];
76            Some(token)
77        }
78    }
79
80    #[inline(always)]
81    fn peek_token(&self) -> Option<Self::Token> {
82        if self.is_empty() {
83            None
84        } else {
85            Some(self[0])
86        }
87    }
88
89    #[inline(always)]
90    fn offset_for<P>(&self, predicate: P) -> Option<usize>
91    where
92        P: Fn(Self::Token) -> bool,
93    {
94        self.iter().position(|b| predicate(*b))
95    }
96    #[inline(always)]
97    fn offset_at(&self, tokens: usize) -> Result<usize, Needed> {
98        if let Some(needed) = tokens.checked_sub(self.len()).and_then(NonZeroUsize::new) {
99            Err(Needed::Size(needed))
100        } else {
101            Ok(tokens)
102        }
103    }
104    #[inline(always)]
105    fn next_slice(&mut self, offset: usize) -> Self::Slice {
106        let (slice, next) = self.0.split_at(offset);
107        *self = Bytes::from_bytes(next);
108        slice
109    }
110    #[inline(always)]
111    fn peek_slice(&self, offset: usize) -> Self::Slice {
112        let (slice, _next) = self.split_at(offset);
113        slice
114    }
115
116    #[inline(always)]
117    fn checkpoint(&self) -> Self::Checkpoint {
118        Checkpoint::<_, Self>::new(*self)
119    }
120    #[inline(always)]
121    fn reset(&mut self, checkpoint: &Self::Checkpoint) {
122        *self = checkpoint.inner;
123    }
124
125    #[inline(always)]
126    fn raw(&self) -> &dyn crate::lib::std::fmt::Debug {
127        self
128    }
129}
130
131#[cfg(feature = "unstable-recover")]
132#[cfg(feature = "std")]
133impl<E> Recover<E> for &Bytes {
134    #[inline(always)]
135    fn record_err(
136        &mut self,
137        _token_start: &Self::Checkpoint,
138        _err_start: &Self::Checkpoint,
139        err: E,
140    ) -> Result<(), E> {
141        Err(err)
142    }
143
144    /// Report whether the [`Stream`] can save off errors for recovery
145    #[inline(always)]
146    fn is_recovery_supported() -> bool {
147        false
148    }
149}
150
151impl StreamIsPartial for &Bytes {
152    type PartialState = ();
153
154    #[inline]
155    fn complete(&mut self) -> Self::PartialState {
156        // Already complete
157    }
158
159    #[inline]
160    fn restore_partial(&mut self, _state: Self::PartialState) {}
161
162    #[inline(always)]
163    fn is_partial_supported() -> bool {
164        false
165    }
166}
167
168impl Offset for &Bytes {
169    #[inline(always)]
170    fn offset_from(&self, start: &Self) -> usize {
171        self.as_bytes().offset_from(&start.as_bytes())
172    }
173}
174
175impl<'a> Offset<<&'a Bytes as Stream>::Checkpoint> for &'a Bytes {
176    #[inline(always)]
177    fn offset_from(&self, other: &<&'a Bytes as Stream>::Checkpoint) -> usize {
178        self.checkpoint().offset_from(other)
179    }
180}
181
182impl AsBytes for &Bytes {
183    #[inline(always)]
184    fn as_bytes(&self) -> &[u8] {
185        (*self).as_bytes()
186    }
187}
188
189impl<'a, T> Compare<T> for &'a Bytes
190where
191    &'a [u8]: Compare<T>,
192{
193    #[inline(always)]
194    fn compare(&self, t: T) -> CompareResult {
195        let bytes = (*self).as_bytes();
196        bytes.compare(t)
197    }
198}
199
200impl<'i, S> FindSlice<S> for &'i Bytes
201where
202    &'i [u8]: FindSlice<S>,
203{
204    #[inline(always)]
205    fn find_slice(&self, substr: S) -> Option<crate::lib::std::ops::Range<usize>> {
206        let bytes = (*self).as_bytes();
207        let offset = bytes.find_slice(substr);
208        offset
209    }
210}
211
212impl UpdateSlice for &Bytes {
213    #[inline(always)]
214    fn update_slice(self, inner: Self::Slice) -> Self {
215        Bytes::new(inner)
216    }
217}
218
219impl fmt::Display for Bytes {
220    #[inline]
221    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
222        <Self as fmt::UpperHex>::fmt(self, f)
223    }
224}
225
226impl fmt::Debug for Bytes {
227    #[inline]
228    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
229        <Self as fmt::UpperHex>::fmt(self, f)
230    }
231}
232
233impl fmt::LowerHex for Bytes {
234    #[inline]
235    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
236        for byte in self.as_bytes() {
237            write!(f, "{byte:0>2x}")?;
238        }
239        Ok(())
240    }
241}
242
243impl fmt::UpperHex for Bytes {
244    #[inline]
245    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
246        for (i, byte) in self.as_bytes().iter().enumerate() {
247            if 0 < i {
248                let absolute = (self.as_bytes().as_ptr() as usize) + i;
249                if f.alternate() && absolute != 0 && absolute % 4 == 0 {
250                    write!(f, "_")?;
251                }
252            }
253            write!(f, "{byte:0>2X}")?;
254        }
255        Ok(())
256    }
257}
258
259impl ops::Deref for Bytes {
260    type Target = [u8];
261
262    #[inline]
263    fn deref(&self) -> &[u8] {
264        self.as_bytes()
265    }
266}
267
268impl ops::Index<usize> for Bytes {
269    type Output = u8;
270
271    #[inline]
272    fn index(&self, idx: usize) -> &u8 {
273        &self.as_bytes()[idx]
274    }
275}
276
277impl ops::Index<ops::RangeFull> for Bytes {
278    type Output = Bytes;
279
280    #[inline]
281    fn index(&self, _: ops::RangeFull) -> &Bytes {
282        self
283    }
284}
285
286impl ops::Index<ops::Range<usize>> for Bytes {
287    type Output = Bytes;
288
289    #[inline]
290    fn index(&self, r: ops::Range<usize>) -> &Bytes {
291        Bytes::new(&self.as_bytes()[r.start..r.end])
292    }
293}
294
295impl ops::Index<ops::RangeInclusive<usize>> for Bytes {
296    type Output = Bytes;
297
298    #[inline]
299    fn index(&self, r: ops::RangeInclusive<usize>) -> &Bytes {
300        Bytes::new(&self.as_bytes()[*r.start()..=*r.end()])
301    }
302}
303
304impl ops::Index<ops::RangeFrom<usize>> for Bytes {
305    type Output = Bytes;
306
307    #[inline]
308    fn index(&self, r: ops::RangeFrom<usize>) -> &Bytes {
309        Bytes::new(&self.as_bytes()[r.start..])
310    }
311}
312
313impl ops::Index<ops::RangeTo<usize>> for Bytes {
314    type Output = Bytes;
315
316    #[inline]
317    fn index(&self, r: ops::RangeTo<usize>) -> &Bytes {
318        Bytes::new(&self.as_bytes()[..r.end])
319    }
320}
321
322impl ops::Index<ops::RangeToInclusive<usize>> for Bytes {
323    type Output = Bytes;
324
325    #[inline]
326    fn index(&self, r: ops::RangeToInclusive<usize>) -> &Bytes {
327        Bytes::new(&self.as_bytes()[..=r.end])
328    }
329}
330
331impl AsRef<[u8]> for Bytes {
332    #[inline]
333    fn as_ref(&self) -> &[u8] {
334        self.as_bytes()
335    }
336}
337
338impl AsRef<Bytes> for [u8] {
339    #[inline]
340    fn as_ref(&self) -> &Bytes {
341        Bytes::new(self)
342    }
343}
344
345impl AsRef<Bytes> for str {
346    #[inline]
347    fn as_ref(&self) -> &Bytes {
348        Bytes::new(self)
349    }
350}
351
352#[cfg(feature = "alloc")]
353impl crate::lib::std::borrow::ToOwned for Bytes {
354    type Owned = crate::lib::std::vec::Vec<u8>;
355
356    #[inline]
357    fn to_owned(&self) -> Self::Owned {
358        crate::lib::std::vec::Vec::from(self.as_bytes())
359    }
360}
361
362#[cfg(feature = "alloc")]
363impl crate::lib::std::borrow::Borrow<Bytes> for crate::lib::std::vec::Vec<u8> {
364    #[inline]
365    fn borrow(&self) -> &Bytes {
366        Bytes::from_bytes(self.as_slice())
367    }
368}
369
370impl<'a> Default for &'a Bytes {
371    fn default() -> &'a Bytes {
372        Bytes::new(b"")
373    }
374}
375
376impl<'a> From<&'a [u8]> for &'a Bytes {
377    #[inline]
378    fn from(s: &'a [u8]) -> &'a Bytes {
379        Bytes::new(s)
380    }
381}
382
383impl<'a> From<&'a Bytes> for &'a [u8] {
384    #[inline]
385    fn from(s: &'a Bytes) -> &'a [u8] {
386        Bytes::as_bytes(s)
387    }
388}
389
390impl<'a> From<&'a str> for &'a Bytes {
391    #[inline]
392    fn from(s: &'a str) -> &'a Bytes {
393        Bytes::new(s.as_bytes())
394    }
395}
396
397impl Eq for Bytes {}
398
399impl PartialEq<Bytes> for Bytes {
400    #[inline]
401    fn eq(&self, other: &Bytes) -> bool {
402        self.as_bytes() == other.as_bytes()
403    }
404}
405
406impl_partial_eq!(Bytes, [u8]);
407impl_partial_eq!(Bytes, &'a [u8]);
408impl_partial_eq!(Bytes, str);
409impl_partial_eq!(Bytes, &'a str);
410
411impl PartialOrd for Bytes {
412    #[inline]
413    fn partial_cmp(&self, other: &Bytes) -> Option<Ordering> {
414        Some(self.cmp(other))
415    }
416}
417
418impl Ord for Bytes {
419    #[inline]
420    fn cmp(&self, other: &Bytes) -> Ordering {
421        Ord::cmp(self.as_bytes(), other.as_bytes())
422    }
423}
424
425impl_partial_ord!(Bytes, [u8]);
426impl_partial_ord!(Bytes, &'a [u8]);
427impl_partial_ord!(Bytes, str);
428impl_partial_ord!(Bytes, &'a str);
429
430#[cfg(all(test, feature = "std"))]
431mod display {
432    use crate::stream::Bytes;
433
434    #[test]
435    fn clean() {
436        assert_eq!(&format!("{}", Bytes::new(b"abc")), "616263");
437        assert_eq!(&format!("{}", Bytes::new(b"\xf0\x28\x8c\xbc")), "F0288CBC");
438    }
439}
440
441#[cfg(all(test, feature = "std"))]
442mod debug {
443    use crate::stream::Bytes;
444
445    #[test]
446    fn test_debug() {
447        assert_eq!(
448            "000000206674797069736F6D0000020069736F6D69736F32617663316D70",
449            format!(
450                "{:?}",
451                Bytes::new(b"\0\0\0 ftypisom\0\0\x02\0isomiso2avc1mp")
452            ),
453        );
454    }
455
456    #[test]
457    fn test_pretty_debug() {
458        // Output can change from run-to-run
459        let _ = format!(
460            "{:#?}",
461            Bytes::new(b"\0\0\0 ftypisom\0\0\x02\0isomiso2avc1mp")
462        );
463    }
464
465    #[test]
466    fn test_sliced() {
467        // Output can change from run-to-run
468        let total = Bytes::new(b"12345678901234567890");
469        let _ = format!("{total:#?}");
470        let _ = format!("{:#?}", &total[1..]);
471        let _ = format!("{:#?}", &total[10..]);
472    }
473}
winnow/stream/bytes.rs

winnow/stream/
bytes.rs
