mirror of
https://github.com/tokio-rs/bytes.git
synced 2026-08-07 00:00:13 +02:00
133 lines
3.0 KiB
Rust
133 lines
3.0 KiB
Rust
use crate::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, Bytes};
|
|
///
|
|
/// let buf = Bytes::from(&b"abc"[..]);
|
|
/// let mut iter = buf.into_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 IntoIter<T> {
|
|
inner: T,
|
|
}
|
|
|
|
impl<T> IntoIter<T> {
|
|
/// Creates an iterator over the bytes contained by the buffer.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// use bytes::{Buf, Bytes};
|
|
/// use bytes::buf::IntoIter;
|
|
///
|
|
/// let buf = Bytes::from_static(b"abc");
|
|
/// let mut iter = IntoIter::new(buf);
|
|
///
|
|
/// 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);
|
|
/// ```
|
|
pub fn new(inner: T) -> IntoIter<T> {
|
|
IntoIter { inner }
|
|
}
|
|
/// Consumes this `IntoIter`, returning the underlying value.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```rust
|
|
/// use bytes::{Buf, Bytes};
|
|
///
|
|
/// let buf = Bytes::from(&b"abc"[..]);
|
|
/// let mut iter = buf.into_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, Bytes};
|
|
///
|
|
/// let buf = Bytes::from(&b"abc"[..]);
|
|
/// let mut iter = buf.into_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, BytesMut};
|
|
///
|
|
/// let buf = BytesMut::from(&b"abc"[..]);
|
|
/// let mut iter = buf.into_iter();
|
|
///
|
|
/// assert_eq!(iter.next(), Some(b'a'));
|
|
///
|
|
/// iter.get_mut().advance(1);
|
|
///
|
|
/// assert_eq!(iter.next(), Some(b'c'));
|
|
/// ```
|
|
pub fn get_mut(&mut self) -> &mut T {
|
|
&mut self.inner
|
|
}
|
|
}
|
|
|
|
impl<T: Buf> Iterator for IntoIter<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 IntoIter<T> {}
|