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