1 use crate::Buf;
2 
3 /// Iterator over the bytes contained by the buffer.
4 ///
5 /// # Examples
6 ///
7 /// Basic usage:
8 ///
9 /// ```
10 /// use bytes::Bytes;
11 ///
12 /// let buf = Bytes::from(&b"abc"[..]);
13 /// let mut iter = buf.into_iter();
14 ///
15 /// assert_eq!(iter.next(), Some(b'a'));
16 /// assert_eq!(iter.next(), Some(b'b'));
17 /// assert_eq!(iter.next(), Some(b'c'));
18 /// assert_eq!(iter.next(), None);
19 /// ```
20 #[derive(Debug)]
21 pub struct IntoIter<T> {
22     inner: T,
23 }
24 
25 impl<T> IntoIter<T> {
26     /// Creates an iterator over the bytes contained by the buffer.
27     ///
28     /// # Examples
29     ///
30     /// ```
31     /// use bytes::Bytes;
32     ///
33     /// let buf = Bytes::from_static(b"abc");
34     /// let mut iter = buf.into_iter();
35     ///
36     /// assert_eq!(iter.next(), Some(b'a'));
37     /// assert_eq!(iter.next(), Some(b'b'));
38     /// assert_eq!(iter.next(), Some(b'c'));
39     /// assert_eq!(iter.next(), None);
40     /// ```
new(inner: T) -> IntoIter<T>41     pub fn new(inner: T) -> IntoIter<T> {
42         IntoIter { inner }
43     }
44 
45     /// Consumes this `IntoIter`, returning the underlying value.
46     ///
47     /// # Examples
48     ///
49     /// ```rust
50     /// use bytes::{Buf, Bytes};
51     ///
52     /// let buf = Bytes::from(&b"abc"[..]);
53     /// let mut iter = buf.into_iter();
54     ///
55     /// assert_eq!(iter.next(), Some(b'a'));
56     ///
57     /// let buf = iter.into_inner();
58     /// assert_eq!(2, buf.remaining());
59     /// ```
into_inner(self) -> T60     pub fn into_inner(self) -> T {
61         self.inner
62     }
63 
64     /// Gets a reference to the underlying `Buf`.
65     ///
66     /// It is inadvisable to directly read from the underlying `Buf`.
67     ///
68     /// # Examples
69     ///
70     /// ```rust
71     /// use bytes::{Buf, Bytes};
72     ///
73     /// let buf = Bytes::from(&b"abc"[..]);
74     /// let mut iter = buf.into_iter();
75     ///
76     /// assert_eq!(iter.next(), Some(b'a'));
77     ///
78     /// assert_eq!(2, iter.get_ref().remaining());
79     /// ```
get_ref(&self) -> &T80     pub fn get_ref(&self) -> &T {
81         &self.inner
82     }
83 
84     /// Gets a mutable reference to the underlying `Buf`.
85     ///
86     /// It is inadvisable to directly read from the underlying `Buf`.
87     ///
88     /// # Examples
89     ///
90     /// ```rust
91     /// use bytes::{Buf, BytesMut};
92     ///
93     /// let buf = BytesMut::from(&b"abc"[..]);
94     /// let mut iter = buf.into_iter();
95     ///
96     /// assert_eq!(iter.next(), Some(b'a'));
97     ///
98     /// iter.get_mut().advance(1);
99     ///
100     /// assert_eq!(iter.next(), Some(b'c'));
101     /// ```
get_mut(&mut self) -> &mut T102     pub fn get_mut(&mut self) -> &mut T {
103         &mut self.inner
104     }
105 }
106 
107 impl<T: Buf> Iterator for IntoIter<T> {
108     type Item = u8;
109 
next(&mut self) -> Option<u8>110     fn next(&mut self) -> Option<u8> {
111         if !self.inner.has_remaining() {
112             return None;
113         }
114 
115         let b = self.inner.chunk()[0];
116         self.inner.advance(1);
117 
118         Some(b)
119     }
120 
size_hint(&self) -> (usize, Option<usize>)121     fn size_hint(&self) -> (usize, Option<usize>) {
122         let rem = self.inner.remaining();
123         (rem, Some(rem))
124     }
125 }
126 
127 impl<T: Buf> ExactSizeIterator for IntoIter<T> {}
128