bstr/
impls.rs

Help
1macro_rules! impl_partial_eq {
2    ($lhs:ty, $rhs:ty) => {
3        impl<'a> PartialEq<$rhs> for $lhs {
4            #[inline]
5            fn eq(&self, other: &$rhs) -> bool {
6                let other: &[u8] = other.as_ref();
7                PartialEq::eq(self.as_bytes(), other)
8            }
9        }
10
11        impl<'a> PartialEq<$lhs> for $rhs {
12            #[inline]
13            fn eq(&self, other: &$lhs) -> bool {
14                let this: &[u8] = self.as_ref();
15                PartialEq::eq(this, other.as_bytes())
16            }
17        }
18    };
19}
20
21macro_rules! impl_partial_eq_n {
22    ($lhs:ty, $rhs:ty) => {
23        impl<'a, const N: usize> PartialEq<$rhs> for $lhs {
24            #[inline]
25            fn eq(&self, other: &$rhs) -> bool {
26                let other: &[u8] = other.as_ref();
27                PartialEq::eq(self.as_bytes(), other)
28            }
29        }
30
31        impl<'a, const N: usize> PartialEq<$lhs> for $rhs {
32            #[inline]
33            fn eq(&self, other: &$lhs) -> bool {
34                let this: &[u8] = self.as_ref();
35                PartialEq::eq(this, other.as_bytes())
36            }
37        }
38    };
39}
40
41#[cfg(feature = "alloc")]
42macro_rules! impl_partial_eq_cow {
43    ($lhs:ty, $rhs:ty) => {
44        impl<'a> PartialEq<$rhs> for $lhs {
45            #[inline]
46            fn eq(&self, other: &$rhs) -> bool {
47                let other: &[u8] = (&**other).as_ref();
48                PartialEq::eq(self.as_bytes(), other)
49            }
50        }
51
52        impl<'a> PartialEq<$lhs> for $rhs {
53            #[inline]
54            fn eq(&self, other: &$lhs) -> bool {
55                let this: &[u8] = (&**self).as_ref();
56                PartialEq::eq(this, other.as_bytes())
57            }
58        }
59    };
60}
61
62macro_rules! impl_partial_ord {
63    ($lhs:ty, $rhs:ty) => {
64        impl<'a> PartialOrd<$rhs> for $lhs {
65            #[inline]
66            fn partial_cmp(&self, other: &$rhs) -> Option<Ordering> {
67                let other: &[u8] = other.as_ref();
68                PartialOrd::partial_cmp(self.as_bytes(), other)
69            }
70        }
71
72        impl<'a> PartialOrd<$lhs> for $rhs {
73            #[inline]
74            fn partial_cmp(&self, other: &$lhs) -> Option<Ordering> {
75                let this: &[u8] = self.as_ref();
76                PartialOrd::partial_cmp(this, other.as_bytes())
77            }
78        }
79    };
80}
81
82macro_rules! impl_partial_ord_n {
83    ($lhs:ty, $rhs:ty) => {
84        impl<'a, const N: usize> PartialOrd<$rhs> for $lhs {
85            #[inline]
86            fn partial_cmp(&self, other: &$rhs) -> Option<Ordering> {
87                let other: &[u8] = other.as_ref();
88                PartialOrd::partial_cmp(self.as_bytes(), other)
89            }
90        }
91
92        impl<'a, const N: usize> PartialOrd<$lhs> for $rhs {
93            #[inline]
94            fn partial_cmp(&self, other: &$lhs) -> Option<Ordering> {
95                let this: &[u8] = self.as_ref();
96                PartialOrd::partial_cmp(this, other.as_bytes())
97            }
98        }
99    };
100}
101
102#[cfg(feature = "alloc")]
103mod bstring {
104    use core::{cmp::Ordering, fmt, hash, ops, str::FromStr};
105
106    use alloc::{
107        borrow::{Borrow, BorrowMut, Cow, ToOwned},
108        string::String,
109        vec,
110        vec::Vec,
111    };
112
113    use crate::{
114        bstr::BStr, bstring::BString, ext_slice::ByteSlice, ext_vec::ByteVec,
115    };
116
117    impl fmt::Display for BString {
118        #[inline]
119        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
120            fmt::Display::fmt(self.as_bstr(), f)
121        }
122    }
123
124    impl fmt::Debug for BString {
125        #[inline]
126        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
127            fmt::Debug::fmt(self.as_bstr(), f)
128        }
129    }
130
131    impl FromStr for BString {
132        type Err = crate::Utf8Error;
133
134        #[inline]
135        fn from_str(s: &str) -> Result<BString, crate::Utf8Error> {
136            Ok(BString::from(s))
137        }
138    }
139
140    impl ops::Deref for BString {
141        type Target = Vec<u8>;
142
143        #[inline]
144        fn deref(&self) -> &Vec<u8> {
145            self.as_vec()
146        }
147    }
148
149    impl ops::DerefMut for BString {
150        #[inline]
151        fn deref_mut(&mut self) -> &mut Vec<u8> {
152            self.as_vec_mut()
153        }
154    }
155
156    impl AsRef<[u8]> for BString {
157        #[inline]
158        fn as_ref(&self) -> &[u8] {
159            self.as_bytes()
160        }
161    }
162
163    impl AsRef<BStr> for BString {
164        #[inline]
165        fn as_ref(&self) -> &BStr {
166            self.as_bstr()
167        }
168    }
169
170    impl AsMut<[u8]> for BString {
171        #[inline]
172        fn as_mut(&mut self) -> &mut [u8] {
173            self.as_bytes_mut()
174        }
175    }
176
177    impl AsMut<BStr> for BString {
178        #[inline]
179        fn as_mut(&mut self) -> &mut BStr {
180            self.as_mut_bstr()
181        }
182    }
183
184    impl Borrow<[u8]> for BString {
185        #[inline]
186        fn borrow(&self) -> &[u8] {
187            self.as_bytes()
188        }
189    }
190
191    impl Borrow<BStr> for BString {
192        #[inline]
193        fn borrow(&self) -> &BStr {
194            self.as_bstr()
195        }
196    }
197
198    impl Borrow<BStr> for Vec<u8> {
199        #[inline]
200        fn borrow(&self) -> &BStr {
201            self.as_slice().as_bstr()
202        }
203    }
204
205    impl Borrow<BStr> for String {
206        #[inline]
207        fn borrow(&self) -> &BStr {
208            self.as_bytes().as_bstr()
209        }
210    }
211
212    impl BorrowMut<[u8]> for BString {
213        #[inline]
214        fn borrow_mut(&mut self) -> &mut [u8] {
215            self.as_bytes_mut()
216        }
217    }
218
219    impl BorrowMut<BStr> for BString {
220        #[inline]
221        fn borrow_mut(&mut self) -> &mut BStr {
222            self.as_mut_bstr()
223        }
224    }
225
226    impl BorrowMut<BStr> for Vec<u8> {
227        #[inline]
228        fn borrow_mut(&mut self) -> &mut BStr {
229            BStr::new_mut(self.as_mut_slice())
230        }
231    }
232
233    impl ToOwned for BStr {
234        type Owned = BString;
235
236        #[inline]
237        fn to_owned(&self) -> BString {
238            BString::from(self)
239        }
240    }
241
242    impl Default for BString {
243        fn default() -> BString {
244            BString::from(vec![])
245        }
246    }
247
248    impl<'a, const N: usize> From<&'a [u8; N]> for BString {
249        #[inline]
250        fn from(s: &'a [u8; N]) -> BString {
251            BString::from(&s[..])
252        }
253    }
254
255    impl<const N: usize> From<[u8; N]> for BString {
256        #[inline]
257        fn from(s: [u8; N]) -> BString {
258            BString::from(&s[..])
259        }
260    }
261
262    impl<'a> From<&'a [u8]> for BString {
263        #[inline]
264        fn from(s: &'a [u8]) -> BString {
265            BString::from(s.to_vec())
266        }
267    }
268
269    impl From<Vec<u8>> for BString {
270        #[inline]
271        fn from(s: Vec<u8>) -> BString {
272            BString::new(s)
273        }
274    }
275
276    impl From<BString> for Vec<u8> {
277        #[inline]
278        fn from(s: BString) -> Vec<u8> {
279            s.into_vec()
280        }
281    }
282
283    impl<'a> From<&'a str> for BString {
284        #[inline]
285        fn from(s: &'a str) -> BString {
286            BString::from(s.as_bytes().to_vec())
287        }
288    }
289
290    impl From<String> for BString {
291        #[inline]
292        fn from(s: String) -> BString {
293            BString::from(s.into_bytes())
294        }
295    }
296
297    impl<'a> From<&'a BStr> for BString {
298        #[inline]
299        fn from(s: &'a BStr) -> BString {
300            BString::from(s.bytes.to_vec())
301        }
302    }
303
304    impl<'a> From<BString> for Cow<'a, BStr> {
305        #[inline]
306        fn from(s: BString) -> Cow<'a, BStr> {
307            Cow::Owned(s)
308        }
309    }
310
311    impl<'a> From<&'a BString> for Cow<'a, BStr> {
312        #[inline]
313        fn from(s: &'a BString) -> Cow<'a, BStr> {
314            Cow::Borrowed(s.as_bstr())
315        }
316    }
317
318    impl TryFrom<BString> for String {
319        type Error = crate::FromUtf8Error;
320
321        #[inline]
322        fn try_from(s: BString) -> Result<String, crate::FromUtf8Error> {
323            s.into_vec().into_string()
324        }
325    }
326
327    impl<'a> TryFrom<&'a BString> for &'a str {
328        type Error = crate::Utf8Error;
329
330        #[inline]
331        fn try_from(s: &'a BString) -> Result<&'a str, crate::Utf8Error> {
332            s.as_bytes().to_str()
333        }
334    }
335
336    impl FromIterator<char> for BString {
337        #[inline]
338        fn from_iter<T: IntoIterator<Item = char>>(iter: T) -> BString {
339            BString::from(iter.into_iter().collect::<String>())
340        }
341    }
342
343    impl FromIterator<u8> for BString {
344        #[inline]
345        fn from_iter<T: IntoIterator<Item = u8>>(iter: T) -> BString {
346            BString::from(iter.into_iter().collect::<Vec<u8>>())
347        }
348    }
349
350    impl<'a> FromIterator<&'a str> for BString {
351        #[inline]
352        fn from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> BString {
353            let mut buf = vec![];
354            for b in iter {
355                buf.push_str(b);
356            }
357            BString::from(buf)
358        }
359    }
360
361    impl<'a> FromIterator<&'a [u8]> for BString {
362        #[inline]
363        fn from_iter<T: IntoIterator<Item = &'a [u8]>>(iter: T) -> BString {
364            let mut buf = vec![];
365            for b in iter {
366                buf.push_str(b);
367            }
368            BString::from(buf)
369        }
370    }
371
372    impl<'a> FromIterator<&'a BStr> for BString {
373        #[inline]
374        fn from_iter<T: IntoIterator<Item = &'a BStr>>(iter: T) -> BString {
375            let mut buf = vec![];
376            for b in iter {
377                buf.push_str(b);
378            }
379            BString::from(buf)
380        }
381    }
382
383    impl FromIterator<BString> for BString {
384        #[inline]
385        fn from_iter<T: IntoIterator<Item = BString>>(iter: T) -> BString {
386            let mut buf = vec![];
387            for b in iter {
388                buf.push_str(b);
389            }
390            BString::from(buf)
391        }
392    }
393
394    impl Eq for BString {}
395
396    impl PartialEq for BString {
397        #[inline]
398        fn eq(&self, other: &BString) -> bool {
399            self[..] == other[..]
400        }
401    }
402
403    impl_partial_eq!(BString, Vec<u8>);
404    impl_partial_eq!(BString, [u8]);
405    impl_partial_eq!(BString, &'a [u8]);
406    impl_partial_eq!(BString, String);
407    impl_partial_eq!(BString, str);
408    impl_partial_eq!(BString, &'a str);
409    impl_partial_eq!(BString, BStr);
410    impl_partial_eq!(BString, &'a BStr);
411    impl_partial_eq_n!(BString, [u8; N]);
412    impl_partial_eq_n!(BString, &'a [u8; N]);
413
414    impl hash::Hash for BString {
415        #[inline]
416        fn hash<H: hash::Hasher>(&self, state: &mut H) {
417            self.as_bytes().hash(state);
418        }
419    }
420
421    impl PartialOrd for BString {
422        #[inline]
423        fn partial_cmp(&self, other: &BString) -> Option<Ordering> {
424            PartialOrd::partial_cmp(self.as_bytes(), other.as_bytes())
425        }
426    }
427
428    impl Ord for BString {
429        #[inline]
430        fn cmp(&self, other: &BString) -> Ordering {
431            self.partial_cmp(other).unwrap()
432        }
433    }
434
435    impl_partial_ord!(BString, Vec<u8>);
436    impl_partial_ord!(BString, [u8]);
437    impl_partial_ord!(BString, &'a [u8]);
438    impl_partial_ord!(BString, String);
439    impl_partial_ord!(BString, str);
440    impl_partial_ord!(BString, &'a str);
441    impl_partial_ord!(BString, BStr);
442    impl_partial_ord!(BString, &'a BStr);
443    impl_partial_ord_n!(BString, [u8; N]);
444    impl_partial_ord_n!(BString, &'a [u8; N]);
445}
446
447mod bstr {
448    use core::{
449        borrow::{Borrow, BorrowMut},
450        cmp::Ordering,
451        fmt, hash, ops,
452    };
453
454    #[cfg(feature = "alloc")]
455    use alloc::{borrow::Cow, boxed::Box, string::String, vec::Vec};
456
457    use crate::{bstr::BStr, ext_slice::ByteSlice};
458
459    impl fmt::Display for BStr {
460        #[inline]
461        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
462            /// Write the given bstr (lossily) to the given formatter.
463            fn write_bstr(
464                f: &mut fmt::Formatter<'_>,
465                bstr: &BStr,
466            ) -> Result<(), fmt::Error> {
467                for chunk in bstr.utf8_chunks() {
468                    f.write_str(chunk.valid())?;
469                    if !chunk.invalid().is_empty() {
470                        f.write_str("\u{FFFD}")?;
471                    }
472                }
473                Ok(())
474            }
475
476            /// Write 'num' fill characters to the given formatter.
477            fn write_pads(
478                f: &mut fmt::Formatter<'_>,
479                num: usize,
480            ) -> fmt::Result {
481                let fill = f.fill();
482                for _ in 0..num {
483                    f.write_fmt(format_args!("{}", fill))?;
484                }
485                Ok(())
486            }
487
488            if let Some(align) = f.align() {
489                let width = f.width().unwrap_or(0);
490                let nchars = self.chars().count();
491                let remaining_pads = width.saturating_sub(nchars);
492                match align {
493                    fmt::Alignment::Left => {
494                        write_bstr(f, self)?;
495                        write_pads(f, remaining_pads)?;
496                    }
497                    fmt::Alignment::Right => {
498                        write_pads(f, remaining_pads)?;
499                        write_bstr(f, self)?;
500                    }
501                    fmt::Alignment::Center => {
502                        let half = remaining_pads / 2;
503                        let second_half = if remaining_pads % 2 == 0 {
504                            half
505                        } else {
506                            half + 1
507                        };
508                        write_pads(f, half)?;
509                        write_bstr(f, self)?;
510                        write_pads(f, second_half)?;
511                    }
512                }
513                Ok(())
514            } else {
515                write_bstr(f, self)?;
516                Ok(())
517            }
518        }
519    }
520
521    impl fmt::Debug for BStr {
522        #[inline]
523        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
524            write!(f, "\"")?;
525            for (s, e, ch) in self.char_indices() {
526                match ch {
527                    '\0' => write!(f, "\\0")?,
528                    '\x01'..='\x7f' => {
529                        write!(f, "{}", (ch as u8).escape_ascii())?;
530                    }
531                    '\u{FFFD}' => {
532                        let bytes = self[s..e].as_bytes();
533                        if bytes == b"\xEF\xBF\xBD" {
534                            write!(f, "{}", ch.escape_debug())?;
535                        } else {
536                            for &b in self[s..e].as_bytes() {
537                                write!(f, "\\x{:02x}", b)?;
538                            }
539                        }
540                    }
541                    _ => {
542                        write!(f, "{}", ch.escape_debug())?;
543                    }
544                }
545            }
546            write!(f, "\"")?;
547            Ok(())
548        }
549    }
550
551    impl ops::Deref for BStr {
552        type Target = [u8];
553
554        #[inline]
555        fn deref(&self) -> &[u8] {
556            &self.bytes
557        }
558    }
559
560    impl ops::DerefMut for BStr {
561        #[inline]
562        fn deref_mut(&mut self) -> &mut [u8] {
563            &mut self.bytes
564        }
565    }
566
567    impl ops::Index<usize> for BStr {
568        type Output = u8;
569
570        #[inline]
571        fn index(&self, idx: usize) -> &u8 {
572            &self.as_bytes()[idx]
573        }
574    }
575
576    impl ops::Index<ops::RangeFull> for BStr {
577        type Output = BStr;
578
579        #[inline]
580        fn index(&self, _: ops::RangeFull) -> &BStr {
581            self
582        }
583    }
584
585    impl ops::Index<ops::Range<usize>> for BStr {
586        type Output = BStr;
587
588        #[inline]
589        fn index(&self, r: ops::Range<usize>) -> &BStr {
590            BStr::new(&self.as_bytes()[r.start..r.end])
591        }
592    }
593
594    impl ops::Index<ops::RangeInclusive<usize>> for BStr {
595        type Output = BStr;
596
597        #[inline]
598        fn index(&self, r: ops::RangeInclusive<usize>) -> &BStr {
599            BStr::new(&self.as_bytes()[*r.start()..=*r.end()])
600        }
601    }
602
603    impl ops::Index<ops::RangeFrom<usize>> for BStr {
604        type Output = BStr;
605
606        #[inline]
607        fn index(&self, r: ops::RangeFrom<usize>) -> &BStr {
608            BStr::new(&self.as_bytes()[r.start..])
609        }
610    }
611
612    impl ops::Index<ops::RangeTo<usize>> for BStr {
613        type Output = BStr;
614
615        #[inline]
616        fn index(&self, r: ops::RangeTo<usize>) -> &BStr {
617            BStr::new(&self.as_bytes()[..r.end])
618        }
619    }
620
621    impl ops::Index<ops::RangeToInclusive<usize>> for BStr {
622        type Output = BStr;
623
624        #[inline]
625        fn index(&self, r: ops::RangeToInclusive<usize>) -> &BStr {
626            BStr::new(&self.as_bytes()[..=r.end])
627        }
628    }
629
630    impl ops::IndexMut<usize> for BStr {
631        #[inline]
632        fn index_mut(&mut self, idx: usize) -> &mut u8 {
633            &mut self.bytes[idx]
634        }
635    }
636
637    impl ops::IndexMut<ops::RangeFull> for BStr {
638        #[inline]
639        fn index_mut(&mut self, _: ops::RangeFull) -> &mut BStr {
640            self
641        }
642    }
643
644    impl ops::IndexMut<ops::Range<usize>> for BStr {
645        #[inline]
646        fn index_mut(&mut self, r: ops::Range<usize>) -> &mut BStr {
647            BStr::from_bytes_mut(&mut self.bytes[r.start..r.end])
648        }
649    }
650
651    impl ops::IndexMut<ops::RangeInclusive<usize>> for BStr {
652        #[inline]
653        fn index_mut(&mut self, r: ops::RangeInclusive<usize>) -> &mut BStr {
654            BStr::from_bytes_mut(&mut self.bytes[*r.start()..=*r.end()])
655        }
656    }
657
658    impl ops::IndexMut<ops::RangeFrom<usize>> for BStr {
659        #[inline]
660        fn index_mut(&mut self, r: ops::RangeFrom<usize>) -> &mut BStr {
661            BStr::from_bytes_mut(&mut self.bytes[r.start..])
662        }
663    }
664
665    impl ops::IndexMut<ops::RangeTo<usize>> for BStr {
666        #[inline]
667        fn index_mut(&mut self, r: ops::RangeTo<usize>) -> &mut BStr {
668            BStr::from_bytes_mut(&mut self.bytes[..r.end])
669        }
670    }
671
672    impl ops::IndexMut<ops::RangeToInclusive<usize>> for BStr {
673        #[inline]
674        fn index_mut(&mut self, r: ops::RangeToInclusive<usize>) -> &mut BStr {
675            BStr::from_bytes_mut(&mut self.bytes[..=r.end])
676        }
677    }
678
679    impl AsRef<[u8]> for BStr {
680        #[inline]
681        fn as_ref(&self) -> &[u8] {
682            self.as_bytes()
683        }
684    }
685
686    impl AsRef<BStr> for BStr {
687        #[inline]
688        fn as_ref(&self) -> &BStr {
689            self
690        }
691    }
692
693    impl AsRef<BStr> for [u8] {
694        #[inline]
695        fn as_ref(&self) -> &BStr {
696            BStr::new(self)
697        }
698    }
699
700    impl AsRef<BStr> for str {
701        #[inline]
702        fn as_ref(&self) -> &BStr {
703            BStr::new(self)
704        }
705    }
706
707    impl AsMut<[u8]> for BStr {
708        #[inline]
709        fn as_mut(&mut self) -> &mut [u8] {
710            &mut self.bytes
711        }
712    }
713
714    impl AsMut<BStr> for [u8] {
715        #[inline]
716        fn as_mut(&mut self) -> &mut BStr {
717            BStr::new_mut(self)
718        }
719    }
720
721    impl Borrow<BStr> for [u8] {
722        #[inline]
723        fn borrow(&self) -> &BStr {
724            self.as_bstr()
725        }
726    }
727
728    impl Borrow<BStr> for str {
729        #[inline]
730        fn borrow(&self) -> &BStr {
731            self.as_bytes().as_bstr()
732        }
733    }
734
735    impl Borrow<[u8]> for BStr {
736        #[inline]
737        fn borrow(&self) -> &[u8] {
738            self.as_bytes()
739        }
740    }
741
742    impl BorrowMut<BStr> for [u8] {
743        #[inline]
744        fn borrow_mut(&mut self) -> &mut BStr {
745            BStr::new_mut(self)
746        }
747    }
748
749    impl BorrowMut<[u8]> for BStr {
750        #[inline]
751        fn borrow_mut(&mut self) -> &mut [u8] {
752            self.as_bytes_mut()
753        }
754    }
755
756    impl<'a> Default for &'a BStr {
757        fn default() -> &'a BStr {
758            BStr::from_bytes(b"")
759        }
760    }
761
762    impl<'a> Default for &'a mut BStr {
763        fn default() -> &'a mut BStr {
764            BStr::from_bytes_mut(&mut [])
765        }
766    }
767
768    impl<'a, const N: usize> From<&'a [u8; N]> for &'a BStr {
769        #[inline]
770        fn from(s: &'a [u8; N]) -> &'a BStr {
771            BStr::from_bytes(s)
772        }
773    }
774
775    impl<'a> From<&'a [u8]> for &'a BStr {
776        #[inline]
777        fn from(s: &'a [u8]) -> &'a BStr {
778            BStr::from_bytes(s)
779        }
780    }
781
782    impl<'a> From<&'a BStr> for &'a [u8] {
783        #[inline]
784        fn from(s: &'a BStr) -> &'a [u8] {
785            BStr::as_bytes(s)
786        }
787    }
788
789    impl<'a> From<&'a str> for &'a BStr {
790        #[inline]
791        fn from(s: &'a str) -> &'a BStr {
792            BStr::from_bytes(s.as_bytes())
793        }
794    }
795
796    #[cfg(feature = "alloc")]
797    impl<'a> From<&'a BStr> for Cow<'a, BStr> {
798        #[inline]
799        fn from(s: &'a BStr) -> Cow<'a, BStr> {
800            Cow::Borrowed(s)
801        }
802    }
803
804    #[cfg(feature = "alloc")]
805    impl From<Box<[u8]>> for Box<BStr> {
806        #[inline]
807        fn from(s: Box<[u8]>) -> Box<BStr> {
808            BStr::from_boxed_bytes(s)
809        }
810    }
811
812    #[cfg(feature = "alloc")]
813    impl From<Box<BStr>> for Box<[u8]> {
814        #[inline]
815        fn from(s: Box<BStr>) -> Box<[u8]> {
816            BStr::into_boxed_bytes(s)
817        }
818    }
819
820    impl<'a> TryFrom<&'a BStr> for &'a str {
821        type Error = crate::Utf8Error;
822
823        #[inline]
824        fn try_from(s: &'a BStr) -> Result<&'a str, crate::Utf8Error> {
825            s.as_bytes().to_str()
826        }
827    }
828
829    #[cfg(feature = "alloc")]
830    impl<'a> TryFrom<&'a BStr> for String {
831        type Error = crate::Utf8Error;
832
833        #[inline]
834        fn try_from(s: &'a BStr) -> Result<String, crate::Utf8Error> {
835            Ok(s.as_bytes().to_str()?.into())
836        }
837    }
838
839    #[cfg(feature = "alloc")]
840    impl Clone for Box<BStr> {
841        #[inline]
842        fn clone(&self) -> Self {
843            BStr::from_boxed_bytes(self.as_bytes().into())
844        }
845    }
846
847    impl Eq for BStr {}
848
849    impl PartialEq<BStr> for BStr {
850        #[inline]
851        fn eq(&self, other: &BStr) -> bool {
852            self.as_bytes() == other.as_bytes()
853        }
854    }
855
856    impl_partial_eq!(BStr, [u8]);
857    impl_partial_eq!(BStr, &'a [u8]);
858    impl_partial_eq!(BStr, str);
859    impl_partial_eq!(BStr, &'a str);
860    impl_partial_eq_n!(BStr, [u8; N]);
861    impl_partial_eq_n!(BStr, &'a [u8; N]);
862
863    #[cfg(feature = "alloc")]
864    impl_partial_eq!(BStr, Vec<u8>);
865    #[cfg(feature = "alloc")]
866    impl_partial_eq!(&'a BStr, Vec<u8>);
867    #[cfg(feature = "alloc")]
868    impl_partial_eq!(BStr, String);
869    #[cfg(feature = "alloc")]
870    impl_partial_eq!(&'a BStr, String);
871    #[cfg(feature = "alloc")]
872    impl_partial_eq_cow!(&'a BStr, Cow<'a, BStr>);
873    #[cfg(feature = "alloc")]
874    impl_partial_eq_cow!(&'a BStr, Cow<'a, str>);
875    #[cfg(feature = "alloc")]
876    impl_partial_eq_cow!(&'a BStr, Cow<'a, [u8]>);
877
878    impl hash::Hash for BStr {
879        #[inline]
880        fn hash<H: hash::Hasher>(&self, state: &mut H) {
881            self.as_bytes().hash(state);
882        }
883    }
884
885    impl PartialOrd for BStr {
886        #[inline]
887        fn partial_cmp(&self, other: &BStr) -> Option<Ordering> {
888            PartialOrd::partial_cmp(self.as_bytes(), other.as_bytes())
889        }
890    }
891
892    impl Ord for BStr {
893        #[inline]
894        fn cmp(&self, other: &BStr) -> Ordering {
895            self.partial_cmp(other).unwrap()
896        }
897    }
898
899    impl_partial_ord!(BStr, [u8]);
900    impl_partial_ord!(BStr, &'a [u8]);
901    impl_partial_ord!(BStr, str);
902    impl_partial_ord!(BStr, &'a str);
903    impl_partial_ord_n!(BStr, [u8; N]);
904    impl_partial_ord_n!(BStr, &'a [u8; N]);
905
906    #[cfg(feature = "alloc")]
907    impl_partial_ord!(BStr, Vec<u8>);
908    #[cfg(feature = "alloc")]
909    impl_partial_ord!(&'a BStr, Vec<u8>);
910    #[cfg(feature = "alloc")]
911    impl_partial_ord!(BStr, String);
912    #[cfg(feature = "alloc")]
913    impl_partial_ord!(&'a BStr, String);
914}
915
916#[cfg(feature = "serde")]
917mod bstr_serde {
918    use core::fmt;
919
920    use serde::{
921        de::Error, de::Visitor, Deserialize, Deserializer, Serialize,
922        Serializer,
923    };
924
925    use crate::bstr::BStr;
926
927    impl Serialize for BStr {
928        #[inline]
929        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
930        where
931            S: Serializer,
932        {
933            serializer.serialize_bytes(self.as_bytes())
934        }
935    }
936
937    impl<'a, 'de: 'a> Deserialize<'de> for &'a BStr {
938        #[inline]
939        fn deserialize<D>(deserializer: D) -> Result<&'a BStr, D::Error>
940        where
941            D: Deserializer<'de>,
942        {
943            struct BStrVisitor;
944
945            impl<'de> Visitor<'de> for BStrVisitor {
946                type Value = &'de BStr;
947
948                fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
949                    f.write_str("a borrowed byte string")
950                }
951
952                #[inline]
953                fn visit_borrowed_bytes<E: Error>(
954                    self,
955                    value: &'de [u8],
956                ) -> Result<&'de BStr, E> {
957                    Ok(BStr::new(value))
958                }
959
960                #[inline]
961                fn visit_borrowed_str<E: Error>(
962                    self,
963                    value: &'de str,
964                ) -> Result<&'de BStr, E> {
965                    Ok(BStr::new(value))
966                }
967            }
968
969            deserializer.deserialize_bytes(BStrVisitor)
970        }
971    }
972}
973
974#[cfg(all(feature = "serde", feature = "alloc"))]
975mod bstring_serde {
976    use core::{cmp, fmt};
977
978    use alloc::{boxed::Box, string::String, vec::Vec};
979
980    use serde::{
981        de::Error, de::SeqAccess, de::Visitor, Deserialize, Deserializer,
982        Serialize, Serializer,
983    };
984
985    use crate::{bstr::BStr, bstring::BString};
986
987    impl Serialize for BString {
988        #[inline]
989        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
990        where
991            S: Serializer,
992        {
993            serializer.serialize_bytes(self.as_bytes())
994        }
995    }
996
997    impl<'de> Deserialize<'de> for BString {
998        #[inline]
999        fn deserialize<D>(deserializer: D) -> Result<BString, D::Error>
1000        where
1001            D: Deserializer<'de>,
1002        {
1003            struct BStringVisitor;
1004
1005            impl<'de> Visitor<'de> for BStringVisitor {
1006                type Value = BString;
1007
1008                fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
1009                    f.write_str("a byte string")
1010                }
1011
1012                #[inline]
1013                fn visit_seq<V: SeqAccess<'de>>(
1014                    self,
1015                    mut visitor: V,
1016                ) -> Result<BString, V::Error> {
1017                    let len = cmp::min(visitor.size_hint().unwrap_or(0), 256);
1018                    let mut bytes = Vec::with_capacity(len);
1019                    while let Some(v) = visitor.next_element()? {
1020                        bytes.push(v);
1021                    }
1022                    Ok(BString::from(bytes))
1023                }
1024
1025                #[inline]
1026                fn visit_bytes<E: Error>(
1027                    self,
1028                    value: &[u8],
1029                ) -> Result<BString, E> {
1030                    Ok(BString::from(value))
1031                }
1032
1033                #[inline]
1034                fn visit_byte_buf<E: Error>(
1035                    self,
1036                    value: Vec<u8>,
1037                ) -> Result<BString, E> {
1038                    Ok(BString::from(value))
1039                }
1040
1041                #[inline]
1042                fn visit_str<E: Error>(
1043                    self,
1044                    value: &str,
1045                ) -> Result<BString, E> {
1046                    Ok(BString::from(value))
1047                }
1048
1049                #[inline]
1050                fn visit_string<E: Error>(
1051                    self,
1052                    value: String,
1053                ) -> Result<BString, E> {
1054                    Ok(BString::from(value))
1055                }
1056            }
1057
1058            deserializer.deserialize_byte_buf(BStringVisitor)
1059        }
1060    }
1061
1062    impl<'de> Deserialize<'de> for Box<BStr> {
1063        #[inline]
1064        fn deserialize<D>(deserializer: D) -> Result<Box<BStr>, D::Error>
1065        where
1066            D: Deserializer<'de>,
1067        {
1068            struct BoxedBStrVisitor;
1069
1070            impl<'de> Visitor<'de> for BoxedBStrVisitor {
1071                type Value = Box<BStr>;
1072
1073                fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
1074                    f.write_str("a boxed byte string")
1075                }
1076
1077                #[inline]
1078                fn visit_seq<V: SeqAccess<'de>>(
1079                    self,
1080                    mut visitor: V,
1081                ) -> Result<Box<BStr>, V::Error> {
1082                    let len = cmp::min(visitor.size_hint().unwrap_or(0), 256);
1083                    let mut bytes = Vec::with_capacity(len);
1084                    while let Some(v) = visitor.next_element()? {
1085                        bytes.push(v);
1086                    }
1087                    Ok(BStr::from_boxed_bytes(bytes.into_boxed_slice()))
1088                }
1089
1090                #[inline]
1091                fn visit_bytes<E: Error>(
1092                    self,
1093                    value: &[u8],
1094                ) -> Result<Box<BStr>, E> {
1095                    Ok(BStr::from_boxed_bytes(
1096                        value.to_vec().into_boxed_slice(),
1097                    ))
1098                }
1099
1100                #[inline]
1101                fn visit_byte_buf<E: Error>(
1102                    self,
1103                    value: Vec<u8>,
1104                ) -> Result<Box<BStr>, E> {
1105                    Ok(BStr::from_boxed_bytes(value.into_boxed_slice()))
1106                }
1107
1108                #[inline]
1109                fn visit_str<E: Error>(
1110                    self,
1111                    value: &str,
1112                ) -> Result<Box<BStr>, E> {
1113                    Ok(BStr::from_boxed_bytes(
1114                        value.as_bytes().to_vec().into_boxed_slice(),
1115                    ))
1116                }
1117
1118                #[inline]
1119                fn visit_string<E: Error>(
1120                    self,
1121                    value: String,
1122                ) -> Result<Box<BStr>, E> {
1123                    Ok(BStr::from_boxed_bytes(
1124                        value.into_bytes().into_boxed_slice(),
1125                    ))
1126                }
1127            }
1128
1129            deserializer.deserialize_byte_buf(BoxedBStrVisitor)
1130        }
1131    }
1132}
1133
1134#[cfg(all(test, feature = "std"))]
1135mod display {
1136    use alloc::format;
1137
1138    #[cfg(not(miri))]
1139    use crate::bstring::BString;
1140    use crate::ByteSlice;
1141
1142    #[test]
1143    fn clean() {
1144        assert_eq!(&format!("{}", &b"abc".as_bstr()), "abc");
1145        assert_eq!(&format!("{}", &b"\xf0\x28\x8c\xbc".as_bstr()), "�(��");
1146    }
1147
1148    #[test]
1149    fn from_str() {
1150        let s: BString = "abc".parse().unwrap();
1151        assert_eq!(s, BString::new(b"abc".to_vec()));
1152    }
1153
1154    #[test]
1155    fn width_bigger_than_bstr() {
1156        assert_eq!(&format!("{:<7}!", &b"abc".as_bstr()), "abc    !");
1157        assert_eq!(&format!("{:>7}!", &b"abc".as_bstr()), "    abc!");
1158        assert_eq!(&format!("{:^7}!", &b"abc".as_bstr()), "  abc  !");
1159        assert_eq!(&format!("{:^6}!", &b"abc".as_bstr()), " abc  !");
1160        assert_eq!(&format!("{:-<7}!", &b"abc".as_bstr()), "abc----!");
1161        assert_eq!(&format!("{:->7}!", &b"abc".as_bstr()), "----abc!");
1162        assert_eq!(&format!("{:-^7}!", &b"abc".as_bstr()), "--abc--!");
1163        assert_eq!(&format!("{:-^6}!", &b"abc".as_bstr()), "-abc--!");
1164
1165        assert_eq!(
1166            &format!("{:<7}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1167            "�(��   !"
1168        );
1169        assert_eq!(
1170            &format!("{:>7}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1171            "   �(��!"
1172        );
1173        assert_eq!(
1174            &format!("{:^7}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1175            " �(��  !"
1176        );
1177        assert_eq!(
1178            &format!("{:^6}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1179            " �(�� !"
1180        );
1181
1182        assert_eq!(
1183            &format!("{:-<7}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1184            "�(��---!"
1185        );
1186        assert_eq!(
1187            &format!("{:->7}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1188            "---�(��!"
1189        );
1190        assert_eq!(
1191            &format!("{:-^7}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1192            "-�(��--!"
1193        );
1194        assert_eq!(
1195            &format!("{:-^6}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1196            "-�(��-!"
1197        );
1198    }
1199
1200    #[test]
1201    fn width_lesser_than_bstr() {
1202        assert_eq!(&format!("{:<2}!", &b"abc".as_bstr()), "abc!");
1203        assert_eq!(&format!("{:>2}!", &b"abc".as_bstr()), "abc!");
1204        assert_eq!(&format!("{:^2}!", &b"abc".as_bstr()), "abc!");
1205        assert_eq!(&format!("{:-<2}!", &b"abc".as_bstr()), "abc!");
1206        assert_eq!(&format!("{:->2}!", &b"abc".as_bstr()), "abc!");
1207        assert_eq!(&format!("{:-^2}!", &b"abc".as_bstr()), "abc!");
1208
1209        assert_eq!(
1210            &format!("{:<3}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1211            "�(��!"
1212        );
1213        assert_eq!(
1214            &format!("{:>3}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1215            "�(��!"
1216        );
1217        assert_eq!(
1218            &format!("{:^3}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1219            "�(��!"
1220        );
1221        assert_eq!(
1222            &format!("{:^2}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1223            "�(��!"
1224        );
1225
1226        assert_eq!(
1227            &format!("{:-<3}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1228            "�(��!"
1229        );
1230        assert_eq!(
1231            &format!("{:->3}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1232            "�(��!"
1233        );
1234        assert_eq!(
1235            &format!("{:-^3}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1236            "�(��!"
1237        );
1238        assert_eq!(
1239            &format!("{:-^2}!", &b"\xf0\x28\x8c\xbc".as_bstr()),
1240            "�(��!"
1241        );
1242    }
1243
1244    #[cfg(not(miri))]
1245    quickcheck::quickcheck! {
1246        fn total_length(bstr: BString) -> bool {
1247            let size = bstr.chars().count();
1248            format!("{:<1$}", bstr.as_bstr(), size).chars().count() >= size
1249        }
1250    }
1251}
1252
1253#[cfg(all(test, feature = "alloc"))]
1254mod bstring_arbitrary {
1255    use alloc::{boxed::Box, vec::Vec};
1256
1257    use crate::bstring::BString;
1258
1259    use quickcheck::{Arbitrary, Gen};
1260
1261    impl Arbitrary for BString {
1262        fn arbitrary(g: &mut Gen) -> BString {
1263            BString::from(Vec::<u8>::arbitrary(g))
1264        }
1265
1266        fn shrink(&self) -> Box<dyn Iterator<Item = BString>> {
1267            Box::new(self.as_vec().shrink().map(BString::from))
1268        }
1269    }
1270}
1271
1272#[test]
1273#[cfg(feature = "std")]
1274fn test_debug() {
1275    use alloc::format;
1276
1277    use crate::{ByteSlice, B};
1278
1279    assert_eq!(
1280        r#""\0\0\0 ftypisom\0\0\x02\0isomiso2avc1mp""#,
1281        format!("{:?}", b"\0\0\0 ftypisom\0\0\x02\0isomiso2avc1mp".as_bstr()),
1282    );
1283
1284    // Tests that if the underlying bytes contain the UTF-8 encoding of the
1285    // replacement codepoint, then we emit the codepoint just like other
1286    // non-printable Unicode characters.
1287    assert_eq!(
1288        b"\"\\xff\xef\xbf\xbd\\xff\"".as_bstr(),
1289        // Before fixing #72, the output here would be:
1290        //   \\xFF\\xEF\\xBF\\xBD\\xFF
1291        B(&format!("{:?}", b"\xff\xef\xbf\xbd\xff".as_bstr())).as_bstr(),
1292    );
1293
1294    // Tests that all ASCII control characters are in lower case.
1295    assert_eq!(
1296        b"\"\\xed\\xa0\\x80Aa\\x7f\\x0b\"".as_bstr(),
1297        // Before fixing #188, the output here would be:
1298        //   \\xED\\xA0\\x80Aa\\x7f\\x0b
1299        B(&format!("{:?}", b"\xed\xa0\x80Aa\x7f\x0b".as_bstr())).as_bstr(),
1300    );
1301
1302    assert_eq!(
1303        r#""\0\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x11\x12\r\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f \x7f\x80\x81\xfe\xff""#,
1304        format!("{:?}", b"\0\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x11\x12\r\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f \x7f\x80\x81\xfe\xff".as_bstr()),
1305    );
1306}
1307
1308// See: https://github.com/BurntSushi/bstr/issues/82
1309#[test]
1310#[cfg(feature = "std")]
1311fn test_cows_regression() {
1312    use std::borrow::Cow;
1313
1314    use crate::ByteSlice;
1315
1316    let c1 = Cow::from(b"hello bstr".as_bstr());
1317    let c2 = b"goodbye bstr".as_bstr();
1318    assert_ne!(c1, c2);
1319
1320    let c3 = Cow::from("hello str");
1321    let c4 = "goodbye str";
1322    assert_ne!(c3, c4);
1323}
1324
1325#[test]
1326#[cfg(feature = "alloc")]
1327fn test_eq_ord() {
1328    use core::cmp::Ordering;
1329
1330    use crate::{BStr, BString};
1331
1332    let b = BStr::new("hello");
1333    assert_eq!(b, b"hello");
1334    assert_ne!(b, b"world");
1335    assert_eq!(b.partial_cmp(b"hello"), Some(Ordering::Equal));
1336    assert_eq!(b.partial_cmp(b"world"), Some(Ordering::Less));
1337
1338    let b = BString::from("hello");
1339    assert_eq!(b, b"hello");
1340    assert_ne!(b, b"world");
1341    assert_eq!(b.partial_cmp(b"hello"), Some(Ordering::Equal));
1342    assert_eq!(b.partial_cmp(b"world"), Some(Ordering::Less));
1343}
bstr/impls.rs

bstr/
impls.rs
