core/bstr/
traits.rs

Help
1//! Trait implementations for `ByteStr`.
2
3use crate::bstr::ByteStr;
4use crate::cmp::Ordering;
5use crate::slice::SliceIndex;
6use crate::{hash, ops, range};
7
8#[unstable(feature = "bstr", issue = "134915")]
9impl Ord for ByteStr {
10    #[inline]
11    fn cmp(&self, other: &ByteStr) -> Ordering {
12        Ord::cmp(&self.0, &other.0)
13    }
14}
15
16#[unstable(feature = "bstr", issue = "134915")]
17impl PartialOrd for ByteStr {
18    #[inline]
19    fn partial_cmp(&self, other: &ByteStr) -> Option<Ordering> {
20        PartialOrd::partial_cmp(&self.0, &other.0)
21    }
22}
23
24#[unstable(feature = "bstr", issue = "134915")]
25impl PartialEq<ByteStr> for ByteStr {
26    #[inline]
27    fn eq(&self, other: &ByteStr) -> bool {
28        &self.0 == &other.0
29    }
30}
31
32#[unstable(feature = "bstr", issue = "134915")]
33impl Eq for ByteStr {}
34
35#[unstable(feature = "bstr", issue = "134915")]
36impl hash::Hash for ByteStr {
37    #[inline]
38    fn hash<H: hash::Hasher>(&self, state: &mut H) {
39        self.0.hash(state);
40    }
41}
42
43#[doc(hidden)]
44#[macro_export]
45#[unstable(feature = "bstr_internals", issue = "none")]
46macro_rules! impl_partial_eq {
47    ($lhs:ty, $rhs:ty) => {
48        #[allow(unused_lifetimes)]
49        impl<'a> PartialEq<$rhs> for $lhs {
50            #[inline]
51            fn eq(&self, other: &$rhs) -> bool {
52                let other: &[u8] = other.as_ref();
53                PartialEq::eq(self.as_bytes(), other)
54            }
55        }
56
57        #[allow(unused_lifetimes)]
58        impl<'a> PartialEq<$lhs> for $rhs {
59            #[inline]
60            fn eq(&self, other: &$lhs) -> bool {
61                let this: &[u8] = self.as_ref();
62                PartialEq::eq(this, other.as_bytes())
63            }
64        }
65    };
66}
67
68#[doc(hidden)]
69#[unstable(feature = "bstr_internals", issue = "none")]
70pub use impl_partial_eq;
71
72#[doc(hidden)]
73#[macro_export]
74#[unstable(feature = "bstr_internals", issue = "none")]
75macro_rules! impl_partial_eq_ord {
76    ($lhs:ty, $rhs:ty) => {
77        $crate::bstr::impl_partial_eq!($lhs, $rhs);
78
79        #[allow(unused_lifetimes)]
80        #[unstable(feature = "bstr", issue = "134915")]
81        impl<'a> PartialOrd<$rhs> for $lhs {
82            #[inline]
83            fn partial_cmp(&self, other: &$rhs) -> Option<Ordering> {
84                let other: &[u8] = other.as_ref();
85                PartialOrd::partial_cmp(self.as_bytes(), other)
86            }
87        }
88
89        #[allow(unused_lifetimes)]
90        #[unstable(feature = "bstr", issue = "134915")]
91        impl<'a> PartialOrd<$lhs> for $rhs {
92            #[inline]
93            fn partial_cmp(&self, other: &$lhs) -> Option<Ordering> {
94                let this: &[u8] = self.as_ref();
95                PartialOrd::partial_cmp(this, other.as_bytes())
96            }
97        }
98    };
99}
100
101#[doc(hidden)]
102#[unstable(feature = "bstr_internals", issue = "none")]
103pub use impl_partial_eq_ord;
104
105#[doc(hidden)]
106#[macro_export]
107#[unstable(feature = "bstr_internals", issue = "none")]
108macro_rules! impl_partial_eq_n {
109    ($lhs:ty, $rhs:ty) => {
110        #[allow(unused_lifetimes)]
111        #[unstable(feature = "bstr", issue = "134915")]
112        impl<const N: usize> PartialEq<$rhs> for $lhs {
113            #[inline]
114            fn eq(&self, other: &$rhs) -> bool {
115                let other: &[u8] = other.as_ref();
116                PartialEq::eq(self.as_bytes(), other)
117            }
118        }
119
120        #[allow(unused_lifetimes)]
121        #[unstable(feature = "bstr", issue = "134915")]
122        impl<const N: usize> PartialEq<$lhs> for $rhs {
123            #[inline]
124            fn eq(&self, other: &$lhs) -> bool {
125                let this: &[u8] = self.as_ref();
126                PartialEq::eq(this, other.as_bytes())
127            }
128        }
129    };
130}
131
132#[doc(hidden)]
133#[unstable(feature = "bstr_internals", issue = "none")]
134pub use impl_partial_eq_n;
135
136// PartialOrd with `[u8]` omitted to avoid inference failures
137impl_partial_eq!(ByteStr, [u8]);
138// PartialOrd with `&[u8]` omitted to avoid inference failures
139impl_partial_eq!(ByteStr, &[u8]);
140// PartialOrd with `str` omitted to avoid inference failures
141impl_partial_eq!(ByteStr, str);
142// PartialOrd with `&str` omitted to avoid inference failures
143impl_partial_eq!(ByteStr, &str);
144// PartialOrd with `[u8; N]` omitted to avoid inference failures
145impl_partial_eq_n!(ByteStr, [u8; N]);
146// PartialOrd with `[u8; N]` omitted to avoid inference failures
147impl_partial_eq_n!(ByteStr, &[u8; N]);
148
149#[unstable(feature = "bstr", issue = "134915")]
150impl<I> ops::Index<I> for ByteStr
151where
152    I: SliceIndex<ByteStr>,
153{
154    type Output = I::Output;
155
156    #[inline]
157    fn index(&self, index: I) -> &I::Output {
158        index.index(self)
159    }
160}
161
162#[unstable(feature = "bstr", issue = "134915")]
163impl<I> ops::IndexMut<I> for ByteStr
164where
165    I: SliceIndex<ByteStr>,
166{
167    #[inline]
168    fn index_mut(&mut self, index: I) -> &mut I::Output {
169        index.index_mut(self)
170    }
171}
172
173#[unstable(feature = "bstr", issue = "134915")]
174unsafe impl SliceIndex<ByteStr> for ops::RangeFull {
175    type Output = ByteStr;
176    #[inline]
177    fn get(self, slice: &ByteStr) -> Option<&Self::Output> {
178        Some(slice)
179    }
180    #[inline]
181    fn get_mut(self, slice: &mut ByteStr) -> Option<&mut Self::Output> {
182        Some(slice)
183    }
184    #[inline]
185    unsafe fn get_unchecked(self, slice: *const ByteStr) -> *const Self::Output {
186        slice
187    }
188    #[inline]
189    unsafe fn get_unchecked_mut(self, slice: *mut ByteStr) -> *mut Self::Output {
190        slice
191    }
192    #[inline]
193    fn index(self, slice: &ByteStr) -> &Self::Output {
194        slice
195    }
196    #[inline]
197    fn index_mut(self, slice: &mut ByteStr) -> &mut Self::Output {
198        slice
199    }
200}
201
202#[unstable(feature = "bstr", issue = "134915")]
203unsafe impl SliceIndex<ByteStr> for usize {
204    type Output = u8;
205    #[inline]
206    fn get(self, slice: &ByteStr) -> Option<&Self::Output> {
207        self.get(slice.as_bytes())
208    }
209    #[inline]
210    fn get_mut(self, slice: &mut ByteStr) -> Option<&mut Self::Output> {
211        self.get_mut(slice.as_bytes_mut())
212    }
213    #[inline]
214    unsafe fn get_unchecked(self, slice: *const ByteStr) -> *const Self::Output {
215        // SAFETY: the caller has to uphold the safety contract for `get_unchecked`.
216        unsafe { self.get_unchecked(slice as *const [u8]) }
217    }
218    #[inline]
219    unsafe fn get_unchecked_mut(self, slice: *mut ByteStr) -> *mut Self::Output {
220        // SAFETY: the caller has to uphold the safety contract for `get_unchecked_mut`.
221        unsafe { self.get_unchecked_mut(slice as *mut [u8]) }
222    }
223    #[inline]
224    fn index(self, slice: &ByteStr) -> &Self::Output {
225        self.index(slice.as_bytes())
226    }
227    #[inline]
228    fn index_mut(self, slice: &mut ByteStr) -> &mut Self::Output {
229        self.index_mut(slice.as_bytes_mut())
230    }
231}
232
233macro_rules! impl_slice_index {
234    ($index:ty) => {
235        #[unstable(feature = "bstr", issue = "134915")]
236        unsafe impl SliceIndex<ByteStr> for $index {
237            type Output = ByteStr;
238            #[inline]
239            fn get(self, slice: &ByteStr) -> Option<&Self::Output> {
240                self.get(slice.as_bytes()).map(ByteStr::from_bytes)
241            }
242            #[inline]
243            fn get_mut(self, slice: &mut ByteStr) -> Option<&mut Self::Output> {
244                self.get_mut(slice.as_bytes_mut()).map(ByteStr::from_bytes_mut)
245            }
246            #[inline]
247            unsafe fn get_unchecked(self, slice: *const ByteStr) -> *const Self::Output {
248                // SAFETY: the caller has to uphold the safety contract for `get_unchecked`.
249                unsafe { self.get_unchecked(slice as *const [u8]) as *const ByteStr }
250            }
251            #[inline]
252            unsafe fn get_unchecked_mut(self, slice: *mut ByteStr) -> *mut Self::Output {
253                // SAFETY: the caller has to uphold the safety contract for `get_unchecked_mut`.
254                unsafe { self.get_unchecked_mut(slice as *mut [u8]) as *mut ByteStr }
255            }
256            #[inline]
257            fn index(self, slice: &ByteStr) -> &Self::Output {
258                ByteStr::from_bytes(self.index(slice.as_bytes()))
259            }
260            #[inline]
261            fn index_mut(self, slice: &mut ByteStr) -> &mut Self::Output {
262                ByteStr::from_bytes_mut(self.index_mut(slice.as_bytes_mut()))
263            }
264        }
265    };
266}
267
268impl_slice_index!(ops::IndexRange);
269impl_slice_index!(ops::Range<usize>);
270impl_slice_index!(range::Range<usize>);
271impl_slice_index!(ops::RangeTo<usize>);
272impl_slice_index!(ops::RangeFrom<usize>);
273impl_slice_index!(range::RangeFrom<usize>);
274impl_slice_index!(ops::RangeInclusive<usize>);
275impl_slice_index!(range::RangeInclusive<usize>);
276impl_slice_index!(ops::RangeToInclusive<usize>);
277impl_slice_index!((ops::Bound<usize>, ops::Bound<usize>));
core/bstr/traits.rs

core/bstr/
traits.rs
