ntex_bytes/
bytes.rs

1use std::{borrow, cmp, fmt, hash, mem, ops};
2
3use crate::{Buf, BytesMut, buf::IntoIter, debug, storage::INLINE_CAP, storage::Storage};
4
5/// A reference counted contiguous slice of memory.
6///
7/// `Bytes` is an efficient container for storing and operating on contiguous
8/// slices of memory. It is intended primarily for use in networking code, but
9/// could have applications elsewhere as well.
10///
11/// `Bytes` values facilitate zero-copy network programming by allowing multiple
12/// `Bytes` objects to point to the same underlying memory. This is managed by
13/// using a reference count to track when the memory is no longer needed and can
14/// be freed.
15///
16/// ```
17/// use ntex_bytes::Bytes;
18///
19/// let mut mem = Bytes::from(&b"Hello world"[..]);
20/// let a = mem.slice(0..5);
21///
22/// assert_eq!(a, b"Hello");
23///
24/// let b = mem.split_to(6);
25///
26/// assert_eq!(mem, b"world");
27/// assert_eq!(b, b"Hello ");
28/// ```
29///
30/// # Memory layout
31///
32/// The `Bytes` struct itself is fairly small, limited to a pointer to the
33/// memory and two `usize` fields used to track information about which segment of
34/// the underlying memory the `Bytes` handle has access to.
35///
36/// The memory layout looks like this:
37///
38/// ```text
39/// +-------+
40/// | Bytes |
41/// +-------+
42///  /      \_____
43/// |              \
44/// v               v
45/// +-----+------------------------------------+
46/// | MD  |         |      Data     |          |
47/// +-----+------------------------------------+
48/// ```
49///
50/// `Bytes` keeps a pointer to the start of the region visible to the handle and
51/// an `offset` that can be used to calculate the beginning of the heap-allocated
52/// buffer. `Bytes` also tracks the length of its view into the memory.
53///
54/// # Sharing
55///
56/// The memory itself is reference counted, and multiple `Bytes` objects may
57/// point to the same region. Each `Bytes` handle point to different sections within
58/// the memory region, and `Bytes` handle may or may not have overlapping views
59/// into the memory.
60///
61///
62/// ```text
63///
64///    Arc ptrs                   +---------+
65///    ________________________ / | Bytes 2 |
66///   /                           +---------+
67///  /          +-----------+     |         |
68/// |_________/ |  Bytes 1  |     |         |
69/// |           +-----------+     |         |
70/// |           |           | ___/ data     | tail
71/// |      data |      tail |/              |
72/// v           v           v               v
73/// +-----+---------------------------------+-----+
74/// | MD  |     |           |               |     |
75/// +-----+---------------------------------+-----+
76/// ```
77///
78/// # Mutating
79///
80/// While `Bytes` handles may represent overlapping views of the underlying
81/// memory slice and therefore cannot be mutated, `BytesMut` handles are
82/// guaranteed to be the only handle able to view that slice of memory. As such,
83/// `BytesMut` handles may mutate the underlying memory. Note that holding a
84/// unique view of a region of memory does not mean there are no other `Bytes`
85/// handles with disjoint views of the same underlying allocation.
86///
87/// # Inline bytes
88///
89/// As an optimization, when the slice referenced by a `Bytes` handle is small
90/// enough [^1], the data may be stored inline. In this case, a clone is no longer
91/// “shallow”, and the data will be copied. `BytesMut` does not support data
92/// inlining and always allocates, but during conversion to `Bytes`, data from
93/// `BytesMut` may be inlined.
94///
95/// [^1]: Small enough: 23 bytes on 64 bit systems, 11 on 32 bit systems.
96///
97pub struct Bytes {
98    pub(crate) storage: Storage,
99}
100
101/*
102 *
103 * ===== Bytes =====
104 *
105 */
106
107impl Bytes {
108    /// Creates a new empty `Bytes`.
109    ///
110    /// This will not allocate and the returned `Bytes` handle will be empty.
111    ///
112    /// # Examples
113    ///
114    /// ```
115    /// use ntex_bytes::Bytes;
116    ///
117    /// let b = Bytes::new();
118    /// assert_eq!(&b[..], b"");
119    /// ```
120    #[inline]
121    pub const fn new() -> Bytes {
122        Bytes {
123            storage: Storage::empty(),
124        }
125    }
126
127    /// Creates a new `Bytes` from a static slice.
128    ///
129    /// The returned `Bytes` will point directly to the static slice. There is
130    /// no allocating or copying.
131    ///
132    /// # Examples
133    ///
134    /// ```
135    /// use ntex_bytes::Bytes;
136    ///
137    /// let b = Bytes::from_static(b"hello");
138    /// assert_eq!(&b[..], b"hello");
139    /// ```
140    #[inline]
141    #[must_use]
142    pub const fn from_static(bytes: &'static [u8]) -> Bytes {
143        Bytes {
144            storage: Storage::from_static(bytes),
145        }
146    }
147
148    /// Returns the number of bytes contained in this `Bytes`.
149    ///
150    /// # Examples
151    ///
152    /// ```
153    /// use ntex_bytes::Bytes;
154    ///
155    /// let b = Bytes::from(&b"hello"[..]);
156    /// assert_eq!(b.len(), 5);
157    /// ```
158    #[inline]
159    pub fn len(&self) -> usize {
160        self.storage.len()
161    }
162
163    /// Returns true if the `Bytes` has a length of 0.
164    ///
165    /// # Examples
166    ///
167    /// ```
168    /// use ntex_bytes::Bytes;
169    ///
170    /// let b = Bytes::new();
171    /// assert!(b.is_empty());
172    /// ```
173    #[inline]
174    pub fn is_empty(&self) -> bool {
175        self.storage.is_empty()
176    }
177
178    /// Return true if the `Bytes` uses inline allocation
179    ///
180    /// # Examples
181    /// ```
182    /// use ntex_bytes::{Bytes, BytesMut};
183    ///
184    /// assert!(Bytes::from(BytesMut::from(&[0, 0, 0, 0][..])).is_inline());
185    /// assert!(Bytes::from(Vec::with_capacity(4)).is_inline());
186    /// assert!(!Bytes::from(&[0; 1024][..]).is_inline());
187    /// ```
188    pub fn is_inline(&self) -> bool {
189        self.storage.is_inline()
190    }
191
192    /// Creates `Bytes` instance from slice, by copying it.
193    ///
194    /// Data from the slice could be inlined.
195    #[must_use]
196    pub fn copy_from_slice(data: &[u8]) -> Self {
197        Bytes {
198            storage: Storage::from_slice(data),
199        }
200    }
201
202    /// Returns a slice of self for the provided range.
203    ///
204    /// This will increment the reference count for the underlying memory and
205    /// return a new `Bytes` handle set to the slice.
206    ///
207    /// This operation is `O(1)`.
208    ///
209    /// # Examples
210    ///
211    /// ```
212    /// use ntex_bytes::Bytes;
213    ///
214    /// let a = Bytes::from(b"hello world");
215    /// let b = a.slice(2..5);
216    ///
217    /// assert_eq!(&b[..], b"llo");
218    /// assert_eq!(&b[..=1], b"ll");
219    /// assert_eq!(&b[1..=1], b"l");
220    /// ```
221    ///
222    /// # Panics
223    ///
224    /// Requires that `begin <= end` and `end <= self.len()`, otherwise slicing
225    /// will panic.
226    #[must_use]
227    pub fn slice(&self, range: impl ops::RangeBounds<usize>) -> Bytes {
228        self.slice_checked(range)
229            .expect("Requires that `begin <= end` and `end <= self.len()`")
230    }
231
232    /// Returns a slice of self for the provided range.
233    ///
234    /// Does nothing if `begin <= end` or `end <= self.len()`
235    #[must_use]
236    pub fn slice_checked(&self, range: impl ops::RangeBounds<usize>) -> Option<Bytes> {
237        use std::ops::Bound;
238
239        let len = self.len();
240
241        let begin = match range.start_bound() {
242            Bound::Included(&n) => n,
243            Bound::Excluded(&n) => n + 1,
244            Bound::Unbounded => 0,
245        };
246
247        let end = match range.end_bound() {
248            Bound::Included(&n) => n + 1,
249            Bound::Excluded(&n) => n,
250            Bound::Unbounded => len,
251        };
252
253        if begin <= end && end <= len {
254            if end - begin <= INLINE_CAP {
255                Some(Bytes {
256                    storage: Storage::from_slice(&self[begin..end]),
257                })
258            } else {
259                let mut ret = self.clone();
260                unsafe {
261                    ret.storage.set_end(end);
262                    ret.storage.set_start(begin);
263                }
264                Some(ret)
265            }
266        } else {
267            None
268        }
269    }
270
271    /// Returns a slice of self that is equivalent to the given `subset`.
272    ///
273    /// When processing a `Bytes` buffer with other tools, one often gets a
274    /// `&[u8]` which is in fact a slice of the `Bytes`, i.e. a subset of it.
275    /// This function turns that `&[u8]` into another `Bytes`, as if one had
276    /// called `self.slice()` with the offsets that correspond to `subset`.
277    ///
278    /// This operation is `O(1)`.
279    ///
280    /// # Examples
281    ///
282    /// ```
283    /// use ntex_bytes::Bytes;
284    ///
285    /// let bytes = Bytes::from(&b"012345678"[..]);
286    /// let as_slice = bytes.as_ref();
287    /// let subset = &as_slice[2..6];
288    /// let subslice = bytes.slice_ref(&subset);
289    /// assert_eq!(subslice, b"2345");
290    /// ```
291    ///
292    /// # Panics
293    ///
294    /// Requires that the given `sub` slice is in fact contained within the
295    /// `Bytes` buffer; otherwise this function will panic.
296    #[must_use]
297    pub fn slice_ref(&self, subset: &[u8]) -> Bytes {
298        self.slice_ref_checked(subset)
299            .expect("Given `sub` slice is not contained within the `Bytes` buffer")
300    }
301
302    /// Returns a slice of self that is equivalent to the given `subset`.
303    #[must_use]
304    pub fn slice_ref_checked(&self, subset: &[u8]) -> Option<Bytes> {
305        let bytes_p = self.as_ptr() as usize;
306        let bytes_len = self.len();
307
308        let sub_p = subset.as_ptr() as usize;
309        let sub_len = subset.len();
310
311        if sub_p >= bytes_p && sub_p + sub_len <= bytes_p + bytes_len {
312            let sub_offset = sub_p - bytes_p;
313            Some(self.slice(sub_offset..(sub_offset + sub_len)))
314        } else {
315            None
316        }
317    }
318
319    /// Splits the bytes into two at the given index.
320    ///
321    /// Afterwards `self` contains elements `[0, at)`, and the returned `Bytes`
322    /// contains elements `[at, len)`.
323    ///
324    /// This is an `O(1)` operation that just increases the reference count and
325    /// sets a few indices.
326    ///
327    /// # Examples
328    ///
329    /// ```
330    /// use ntex_bytes::Bytes;
331    ///
332    /// let mut a = Bytes::from(&b"hello world"[..]);
333    /// let b = a.split_off(5);
334    ///
335    /// assert_eq!(a, b"hello");
336    /// assert_eq!(b, b" world");
337    /// ```
338    ///
339    /// # Panics
340    ///
341    /// Panics if `at > self.len()`.
342    #[must_use]
343    pub fn split_off(&mut self, at: usize) -> Bytes {
344        self.split_off_checked(at)
345            .expect("at value must be <= self.len()`")
346    }
347
348    /// Splits the bytes into two at the given index.
349    ///
350    /// Does nothing if `at > self.len()`
351    #[must_use]
352    pub fn split_off_checked(&mut self, at: usize) -> Option<Bytes> {
353        if at <= self.len() {
354            if at == self.len() {
355                Some(Bytes::new())
356            } else if at == 0 {
357                Some(mem::take(self))
358            } else {
359                Some(Bytes {
360                    storage: self.storage.split_off(at, true),
361                })
362            }
363        } else {
364            None
365        }
366    }
367
368    /// Splits the bytes into two at the given index.
369    ///
370    /// Afterwards `self` contains elements `[at, len)`, and the returned
371    /// `Bytes` contains elements `[0, at)`.
372    ///
373    /// This is an `O(1)` operation that just increases the reference count and
374    /// sets a few indices.
375    ///
376    /// # Examples
377    ///
378    /// ```
379    /// use ntex_bytes::Bytes;
380    ///
381    /// let mut a = Bytes::from(&b"hello world"[..]);
382    /// let b = a.split_to(5);
383    ///
384    /// assert_eq!(a, b" world");
385    /// assert_eq!(b, b"hello");
386    /// ```
387    ///
388    /// # Panics
389    ///
390    /// Panics if `at > len`.
391    #[must_use]
392    pub fn split_to(&mut self, at: usize) -> Bytes {
393        self.split_to_checked(at)
394            .expect("at value must be <= self.len()`")
395    }
396
397    /// Splits the bytes into two at the given index.
398    ///
399    /// Does nothing if `at > len`.
400    #[must_use]
401    pub fn split_to_checked(&mut self, at: usize) -> Option<Bytes> {
402        if at <= self.len() {
403            if at == self.len() {
404                Some(mem::take(self))
405            } else if at == 0 {
406                Some(Bytes::new())
407            } else {
408                Some(Bytes {
409                    storage: self.storage.split_to(at),
410                })
411            }
412        } else {
413            None
414        }
415    }
416
417    /// Advance the internal cursor.
418    ///
419    /// Afterwards `self` contains elements `[cnt, len)`.
420    /// This is an `O(1)` operation.
421    ///
422    /// # Examples
423    ///
424    /// ```
425    /// use ntex_bytes::Bytes;
426    ///
427    /// let mut a = Bytes::copy_from_slice(&b"hello world"[..]);
428    /// a.advance_to(5);
429    ///
430    /// assert_eq!(&a[..], b" world");
431    /// ```
432    ///
433    /// # Panics
434    ///
435    /// Panics if `cnt > len`.
436    #[inline]
437    pub fn advance_to(&mut self, cnt: usize) {
438        unsafe {
439            self.storage.set_start(cnt);
440        }
441    }
442
443    /// Shortens the buffer, keeping the first `len` bytes and dropping the
444    /// rest.
445    ///
446    /// If `len` is greater than the buffer's current length, this has no
447    /// effect. `Data` may be inlined if the slice fits.
448    ///
449    /// The [`split_off`] method can emulate `truncate`, but this causes the
450    /// excess bytes to be returned instead of dropped.
451    ///
452    /// # Examples
453    ///
454    /// ```
455    /// use ntex_bytes::Bytes;
456    ///
457    /// let mut buf = Bytes::from(&b"hello world"[..]);
458    /// buf.truncate(5);
459    /// assert_eq!(buf, b"hello"[..]);
460    /// ```
461    ///
462    /// [`split_off`]: #method.split_off
463    #[inline]
464    pub fn truncate(&mut self, len: usize) {
465        self.storage.truncate(len, true);
466    }
467
468    /// Shortens the buffer to `len` bytes and dropping the rest.
469    ///
470    /// This is useful if underlying buffer is larger than cuurrent bytes object.
471    ///
472    /// # Examples
473    ///
474    /// ```
475    /// use ntex_bytes::Bytes;
476    ///
477    /// let mut buf = Bytes::from(&b"hello world"[..]);
478    /// buf.trimdown();
479    /// assert_eq!(buf, b"hello world"[..]);
480    /// ```
481    #[inline]
482    pub fn trimdown(&mut self) {
483        self.storage.trimdown();
484    }
485
486    /// Clears the buffer, removing all data.
487    ///
488    /// # Examples
489    ///
490    /// ```
491    /// use ntex_bytes::Bytes;
492    ///
493    /// let mut buf = Bytes::from(&b"hello world"[..]);
494    /// buf.clear();
495    /// assert!(buf.is_empty());
496    /// ```
497    #[inline]
498    pub fn clear(&mut self) {
499        self.storage = Storage::empty();
500    }
501
502    /// Returns an iterator over the bytes contained by the buffer.
503    ///
504    /// # Examples
505    ///
506    /// ```
507    /// use ntex_bytes::{Buf, Bytes};
508    ///
509    /// let buf = Bytes::from(&b"abc"[..]);
510    /// let mut iter = buf.iter();
511    ///
512    /// assert_eq!(iter.next().map(|b| *b), Some(b'a'));
513    /// assert_eq!(iter.next().map(|b| *b), Some(b'b'));
514    /// assert_eq!(iter.next().map(|b| *b), Some(b'c'));
515    /// assert_eq!(iter.next(), None);
516    /// ```
517    pub fn iter(&'_ self) -> std::slice::Iter<'_, u8> {
518        self.chunk().iter()
519    }
520
521    #[inline]
522    #[doc(hidden)]
523    pub fn info(&self) -> crate::info::Info {
524        self.storage.info()
525    }
526}
527
528impl Buf for Bytes {
529    #[inline]
530    fn remaining(&self) -> usize {
531        self.len()
532    }
533
534    #[inline]
535    fn chunk(&self) -> &[u8] {
536        self.storage.as_ref()
537    }
538
539    #[inline]
540    fn advance(&mut self, cnt: usize) {
541        self.advance_to(cnt);
542    }
543
544    #[inline]
545    fn get_u8(&mut self) -> u8 {
546        self.storage.get_u8()
547    }
548}
549
550impl bytes::buf::Buf for Bytes {
551    #[inline]
552    fn remaining(&self) -> usize {
553        self.len()
554    }
555
556    #[inline]
557    fn chunk(&self) -> &[u8] {
558        self.storage.as_ref()
559    }
560
561    #[inline]
562    fn advance(&mut self, cnt: usize) {
563        self.advance_to(cnt);
564    }
565
566    #[inline]
567    fn get_u8(&mut self) -> u8 {
568        self.storage.get_u8()
569    }
570}
571
572impl Clone for Bytes {
573    fn clone(&self) -> Bytes {
574        Bytes {
575            storage: self.storage.clone(),
576        }
577    }
578}
579
580impl AsRef<[u8]> for Bytes {
581    #[inline]
582    fn as_ref(&self) -> &[u8] {
583        self.storage.as_ref()
584    }
585}
586
587impl ops::Deref for Bytes {
588    type Target = [u8];
589
590    #[inline]
591    fn deref(&self) -> &[u8] {
592        self.storage.as_ref()
593    }
594}
595
596impl From<&Bytes> for Bytes {
597    fn from(src: &Bytes) -> Bytes {
598        src.clone()
599    }
600}
601
602impl From<Vec<u8>> for Bytes {
603    /// Convert a `Vec` into a `Bytes`
604    fn from(src: Vec<u8>) -> Bytes {
605        Bytes {
606            storage: Storage::from_slice(&src),
607        }
608    }
609}
610
611impl From<String> for Bytes {
612    fn from(src: String) -> Bytes {
613        Bytes {
614            storage: Storage::from_slice(src.as_bytes()),
615        }
616    }
617}
618
619impl From<&'static [u8]> for Bytes {
620    fn from(src: &'static [u8]) -> Bytes {
621        Bytes::from_static(src)
622    }
623}
624
625impl From<&'static str> for Bytes {
626    fn from(src: &'static str) -> Bytes {
627        Bytes::from_static(src.as_bytes())
628    }
629}
630
631impl<'a, const N: usize> From<&'a [u8; N]> for Bytes {
632    fn from(src: &'a [u8; N]) -> Bytes {
633        Bytes::copy_from_slice(src)
634    }
635}
636
637impl FromIterator<u8> for Bytes {
638    fn from_iter<T: IntoIterator<Item = u8>>(into_iter: T) -> Self {
639        BytesMut::from_iter(into_iter).freeze()
640    }
641}
642
643impl<'a> FromIterator<&'a u8> for Bytes {
644    fn from_iter<T: IntoIterator<Item = &'a u8>>(into_iter: T) -> Self {
645        BytesMut::from_iter(into_iter).freeze()
646    }
647}
648
649impl Eq for Bytes {}
650
651impl PartialEq for Bytes {
652    fn eq(&self, other: &Bytes) -> bool {
653        self.storage.as_ref() == other.storage.as_ref()
654    }
655}
656
657impl PartialOrd for Bytes {
658    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
659        Some(self.cmp(other))
660    }
661}
662
663impl Ord for Bytes {
664    fn cmp(&self, other: &Bytes) -> cmp::Ordering {
665        self.storage.as_ref().cmp(other.storage.as_ref())
666    }
667}
668
669impl Default for Bytes {
670    #[inline]
671    fn default() -> Bytes {
672        Bytes::new()
673    }
674}
675
676impl fmt::Debug for Bytes {
677    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
678        fmt::Debug::fmt(&debug::BsDebug(self.storage.as_ref()), fmt)
679    }
680}
681
682impl hash::Hash for Bytes {
683    fn hash<H>(&self, state: &mut H)
684    where
685        H: hash::Hasher,
686    {
687        let s: &[u8] = self.as_ref();
688        s.hash(state);
689    }
690}
691
692impl borrow::Borrow<[u8]> for Bytes {
693    fn borrow(&self) -> &[u8] {
694        self.as_ref()
695    }
696}
697
698impl IntoIterator for Bytes {
699    type Item = u8;
700    type IntoIter = IntoIter<Bytes>;
701
702    fn into_iter(self) -> Self::IntoIter {
703        IntoIter::new(self)
704    }
705}
706
707impl<'a> IntoIterator for &'a Bytes {
708    type Item = &'a u8;
709    type IntoIter = std::slice::Iter<'a, u8>;
710
711    fn into_iter(self) -> Self::IntoIter {
712        self.as_ref().iter()
713    }
714}
715
716/*
717 *
718 * ===== PartialEq / PartialOrd =====
719 *
720 */
721
722impl PartialEq<[u8]> for Bytes {
723    fn eq(&self, other: &[u8]) -> bool {
724        self.storage.as_ref() == other
725    }
726}
727
728impl<const N: usize> PartialEq<[u8; N]> for Bytes {
729    fn eq(&self, other: &[u8; N]) -> bool {
730        self.storage.as_ref() == other.as_ref()
731    }
732}
733
734impl PartialOrd<[u8]> for Bytes {
735    fn partial_cmp(&self, other: &[u8]) -> Option<cmp::Ordering> {
736        self.storage.as_ref().partial_cmp(other)
737    }
738}
739
740impl<const N: usize> PartialOrd<[u8; N]> for Bytes {
741    fn partial_cmp(&self, other: &[u8; N]) -> Option<cmp::Ordering> {
742        self.storage.as_ref().partial_cmp(other.as_ref())
743    }
744}
745
746impl PartialEq<Bytes> for [u8] {
747    fn eq(&self, other: &Bytes) -> bool {
748        *other == *self
749    }
750}
751
752impl<const N: usize> PartialEq<Bytes> for [u8; N] {
753    fn eq(&self, other: &Bytes) -> bool {
754        *other == *self
755    }
756}
757
758impl<const N: usize> PartialEq<Bytes> for &[u8; N] {
759    fn eq(&self, other: &Bytes) -> bool {
760        *other == *self
761    }
762}
763
764impl PartialOrd<Bytes> for [u8] {
765    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
766        other.partial_cmp(self)
767    }
768}
769
770impl<const N: usize> PartialOrd<Bytes> for [u8; N] {
771    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
772        other.partial_cmp(self)
773    }
774}
775
776impl PartialEq<str> for Bytes {
777    fn eq(&self, other: &str) -> bool {
778        self.storage.as_ref() == other.as_bytes()
779    }
780}
781
782impl PartialOrd<str> for Bytes {
783    fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
784        self.storage.as_ref().partial_cmp(other.as_bytes())
785    }
786}
787
788impl PartialEq<Bytes> for str {
789    fn eq(&self, other: &Bytes) -> bool {
790        *other == *self
791    }
792}
793
794impl PartialOrd<Bytes> for str {
795    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
796        other.partial_cmp(self)
797    }
798}
799
800impl PartialEq<Vec<u8>> for Bytes {
801    fn eq(&self, other: &Vec<u8>) -> bool {
802        *self == other[..]
803    }
804}
805
806impl PartialOrd<Vec<u8>> for Bytes {
807    fn partial_cmp(&self, other: &Vec<u8>) -> Option<cmp::Ordering> {
808        self.storage.as_ref().partial_cmp(&other[..])
809    }
810}
811
812impl PartialEq<Bytes> for Vec<u8> {
813    fn eq(&self, other: &Bytes) -> bool {
814        *other == *self
815    }
816}
817
818impl PartialOrd<Bytes> for Vec<u8> {
819    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
820        other.partial_cmp(self)
821    }
822}
823
824impl PartialEq<String> for Bytes {
825    fn eq(&self, other: &String) -> bool {
826        *self == other[..]
827    }
828}
829
830impl PartialOrd<String> for Bytes {
831    fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> {
832        self.storage.as_ref().partial_cmp(other.as_bytes())
833    }
834}
835
836impl PartialEq<Bytes> for String {
837    fn eq(&self, other: &Bytes) -> bool {
838        *other == *self
839    }
840}
841
842impl PartialOrd<Bytes> for String {
843    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
844        other.partial_cmp(self)
845    }
846}
847
848impl PartialEq<Bytes> for &[u8] {
849    fn eq(&self, other: &Bytes) -> bool {
850        *other == *self
851    }
852}
853
854impl PartialOrd<Bytes> for &[u8] {
855    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
856        other.partial_cmp(self)
857    }
858}
859
860impl PartialEq<Bytes> for &str {
861    fn eq(&self, other: &Bytes) -> bool {
862        *other == *self
863    }
864}
865
866impl PartialOrd<Bytes> for &str {
867    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
868        other.partial_cmp(self)
869    }
870}
871
872impl<'a, T: ?Sized> PartialEq<&'a T> for Bytes
873where
874    Bytes: PartialEq<T>,
875{
876    fn eq(&self, other: &&'a T) -> bool {
877        *self == **other
878    }
879}
880
881impl<'a, T: ?Sized> PartialOrd<&'a T> for Bytes
882where
883    Bytes: PartialOrd<T>,
884{
885    fn partial_cmp(&self, other: &&'a T) -> Option<cmp::Ordering> {
886        self.partial_cmp(&**other)
887    }
888}
889
890#[cfg(test)]
891#[allow(unused_must_use)]
892mod tests {
893    use std::collections::HashMap;
894
895    use super::*;
896    use crate::BufMut;
897
898    const LONG: &[u8] = b"mary had a1 little la2mb, little lamb, little lamb, little lamb, little lamb, little lamb \
899        mary had a little lamb, little lamb, little lamb, little lamb, little lamb, little lamb \
900        mary had a little lamb, little lamb, little lamb, little lamb, little lamb, little lamb \0";
901
902    #[test]
903    #[allow(
904        clippy::op_ref,
905        clippy::len_zero,
906        clippy::nonminimal_bool,
907        clippy::unnecessary_fallible_conversions
908    )]
909    fn bytes() {
910        let mut b = Bytes::from(LONG.to_vec());
911        b.advance_to(10);
912        assert_eq!(&b, &LONG[10..]);
913        b.advance_to(10);
914        assert_eq!(&b[..], &LONG[20..]);
915        assert_eq!(&b, &LONG[20..]);
916        b.clear();
917        assert!(b.is_inline());
918        assert!(b.is_empty());
919        assert!(b.len() == 0);
920
921        let mut b = Bytes::from(LONG);
922        b.advance_to(10);
923        assert_eq!(&b, &LONG[10..]);
924        b.advance_to(10);
925        assert_eq!(&b[..], &LONG[20..]);
926        assert_eq!(&b, &LONG[20..]);
927        b.clear();
928        assert!(b.is_empty());
929        assert!(b.len() == 0);
930
931        let mut b = Bytes::from(LONG);
932        b.split_off(10);
933        assert_eq!(&b, &LONG[..10]);
934        b.advance_to(5);
935        assert_eq!(&b, &LONG[5..10]);
936
937        let mut b = Bytes::copy_from_slice(&LONG[..15]);
938        assert!(b.is_inline());
939        b.split_off(10);
940        assert_eq!(&b, &LONG[..10]);
941        b.advance_to(1);
942        assert_eq!(&b, &LONG[1..10]);
943
944        let b = Bytes::from(b"123");
945        assert!(&b"12"[..] > &b);
946        assert!("123" == &b);
947        assert!("12" > &b);
948
949        let b = Bytes::from(&Bytes::from(LONG));
950        assert_eq!(b, LONG);
951
952        let b = Bytes::from(BytesMut::from(LONG));
953        assert_eq!(b, LONG);
954
955        let mut b: Bytes = BytesMut::try_from(b).unwrap().freeze();
956        assert_eq!(b, LONG);
957        assert!(!(b > b));
958        assert_eq!(<Bytes as Buf>::remaining(&b), LONG.len());
959        assert_eq!(<Bytes as Buf>::chunk(&b), LONG);
960        <Bytes as Buf>::advance(&mut b, 10);
961        assert_eq!(Buf::chunk(&b), &LONG[10..]);
962        <Bytes as Buf>::advance(&mut b, 10);
963        assert_eq!(Buf::chunk(&b), &LONG[20..]);
964
965        let mut h: HashMap<Bytes, usize> = HashMap::default();
966        h.insert(b.clone(), 1);
967        assert_eq!(h.get(&b), Some(&1));
968
969        let mut b = BytesMut::try_from(LONG).unwrap();
970        assert_eq!(b, LONG);
971        assert_eq!(<BytesMut as Buf>::remaining(&b), LONG.len());
972        assert_eq!(<BytesMut as BufMut>::remaining_mut(&b), 0);
973        assert_eq!(<BytesMut as Buf>::chunk(&b), LONG);
974        <BytesMut as Buf>::advance(&mut b, 10);
975        assert_eq!(<BytesMut as Buf>::chunk(&b), &LONG[10..]);
976
977        let mut b = BytesMut::with_capacity(12);
978        <BytesMut as BufMut>::put_i8(&mut b, 1);
979        assert_eq!(b, b"\x01".as_ref());
980        <BytesMut as BufMut>::put_u8(&mut b, 2);
981        assert_eq!(b, b"\x01\x02".as_ref());
982        <BytesMut as BufMut>::put_slice(&mut b, b"12345");
983        assert_eq!(b, b"\x01\x0212345".as_ref());
984        <BytesMut as BufMut>::chunk_mut(&mut b).write_byte(0, b'1');
985        unsafe { <BytesMut as BufMut>::advance_mut(&mut b, 1) };
986        assert_eq!(b, b"\x01\x02123451".as_ref());
987
988        let mut iter = Bytes::from(LONG.to_vec()).into_iter();
989        assert_eq!(iter.next(), Some(LONG[0]));
990        assert_eq!(iter.next(), Some(LONG[1]));
991        assert_eq!(iter.next(), Some(LONG[2]));
992        assert_eq!(iter.next(), Some(LONG[3]));
993        assert_eq!(iter.get_ref(), &LONG[4..]);
994        assert_eq!(iter.get_mut(), &LONG[4..]);
995        let b = iter.into_inner();
996        assert_eq!(b, &LONG[4..]);
997    }
998}
ntex_bytes/bytes.rs

ntex_bytes/
bytes.rs
