pub trait Buf {
Show 48 methods
// Required methods
fn remaining(&self) -> usize;
fn chunk(&self) -> &[u8] ⓘ;
fn advance(&mut self, cnt: usize);
// Provided methods
fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize { ... }
fn has_remaining(&self) -> bool { ... }
fn copy_to_slice(&mut self, dst: &mut [u8]) { ... }
fn get_u8(&mut self) -> u8 { ... }
fn get_i8(&mut self) -> i8 { ... }
fn get_u16(&mut self) -> u16 { ... }
fn get_u16_le(&mut self) -> u16 { ... }
fn get_u16_ne(&mut self) -> u16 { ... }
fn get_i16(&mut self) -> i16 { ... }
fn get_i16_le(&mut self) -> i16 { ... }
fn get_i16_ne(&mut self) -> i16 { ... }
fn get_u32(&mut self) -> u32 { ... }
fn get_u32_le(&mut self) -> u32 { ... }
fn get_u32_ne(&mut self) -> u32 { ... }
fn get_i32(&mut self) -> i32 { ... }
fn get_i32_le(&mut self) -> i32 { ... }
fn get_i32_ne(&mut self) -> i32 { ... }
fn get_u64(&mut self) -> u64 { ... }
fn get_u64_le(&mut self) -> u64 { ... }
fn get_u64_ne(&mut self) -> u64 { ... }
fn get_i64(&mut self) -> i64 { ... }
fn get_i64_le(&mut self) -> i64 { ... }
fn get_i64_ne(&mut self) -> i64 { ... }
fn get_u128(&mut self) -> u128 { ... }
fn get_u128_le(&mut self) -> u128 { ... }
fn get_u128_ne(&mut self) -> u128 { ... }
fn get_i128(&mut self) -> i128 { ... }
fn get_i128_le(&mut self) -> i128 { ... }
fn get_i128_ne(&mut self) -> i128 { ... }
fn get_uint(&mut self, nbytes: usize) -> u64 { ... }
fn get_uint_le(&mut self, nbytes: usize) -> u64 { ... }
fn get_uint_ne(&mut self, nbytes: usize) -> u64 { ... }
fn get_int(&mut self, nbytes: usize) -> i64 { ... }
fn get_int_le(&mut self, nbytes: usize) -> i64 { ... }
fn get_int_ne(&mut self, nbytes: usize) -> i64 { ... }
fn get_f32(&mut self) -> f32 { ... }
fn get_f32_le(&mut self) -> f32 { ... }
fn get_f32_ne(&mut self) -> f32 { ... }
fn get_f64(&mut self) -> f64 { ... }
fn get_f64_le(&mut self) -> f64 { ... }
fn get_f64_ne(&mut self) -> f64 { ... }
fn copy_to_bytes(&mut self, len: usize) -> Bytes { ... }
fn take(self, limit: usize) -> Take<Self>
where Self: Sized { ... }
fn chain<U: Buf>(self, next: U) -> Chain<Self, U>
where Self: Sized { ... }
fn reader(self) -> Reader<Self> ⓘ
where Self: Sized { ... }
}
Expand description
Read bytes from a buffer.
A buffer stores bytes in memory such that read operations are infallible.
The underlying storage may or may not be in contiguous memory. A Buf
value
is a cursor into the buffer. Reading from Buf
advances the cursor
position. It can be thought of as an efficient Iterator
for collections of
bytes.
The simplest Buf
is a &[u8]
.
use bytes::Buf;
let mut buf = &b"hello world"[..];
assert_eq!(b'h', buf.get_u8());
assert_eq!(b'e', buf.get_u8());
assert_eq!(b'l', buf.get_u8());
let mut rest = [0; 8];
buf.copy_to_slice(&mut rest);
assert_eq!(&rest[..], &b"lo world"[..]);
Required Methods§
Sourcefn remaining(&self) -> usize
fn remaining(&self) -> usize
Returns the number of bytes between the current position and the end of the buffer.
This value is greater than or equal to the length of the slice returned
by chunk()
.
§Examples
use bytes::Buf;
let mut buf = &b"hello world"[..];
assert_eq!(buf.remaining(), 11);
buf.get_u8();
assert_eq!(buf.remaining(), 10);
§Implementer notes
Implementations of remaining
should ensure that the return value does
not change unless a call is made to advance
or any other function that
is documented to change the Buf
’s current position.
Sourcefn chunk(&self) -> &[u8] ⓘ
fn chunk(&self) -> &[u8] ⓘ
Returns a slice starting at the current position and of length between 0
and Buf::remaining()
. Note that this can return a shorter slice (this
allows non-continuous internal representation).
This is a lower level function. Most operations are done with other functions.
§Examples
use bytes::Buf;
let mut buf = &b"hello world"[..];
assert_eq!(buf.chunk(), &b"hello world"[..]);
buf.advance(6);
assert_eq!(buf.chunk(), &b"world"[..]);
§Implementer notes
This function should never panic. chunk()
should return an empty
slice if and only if remaining()
returns 0. In other words,
chunk()
returning an empty slice implies that remaining()
will
return 0 and remaining()
returning 0 implies that chunk()
will
return an empty slice.
Sourcefn advance(&mut self, cnt: usize)
fn advance(&mut self, cnt: usize)
Advance the internal cursor of the Buf
The next call to chunk()
will return a slice starting cnt
bytes
further into the underlying buffer.
§Examples
use bytes::Buf;
let mut buf = &b"hello world"[..];
assert_eq!(buf.chunk(), &b"hello world"[..]);
buf.advance(6);
assert_eq!(buf.chunk(), &b"world"[..]);
§Panics
This function may panic if cnt > self.remaining()
.
§Implementer notes
It is recommended for implementations of advance
to panic if cnt > self.remaining()
. If the implementation does not panic, the call must
behave as if cnt == self.remaining()
.
A call with cnt == 0
should never panic and be a no-op.
Provided Methods§
Sourcefn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize
fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize
Fills dst
with potentially multiple slices starting at self
’s
current position.
If the Buf
is backed by disjoint slices of bytes, chunk_vectored
enables
fetching more than one slice at once. dst
is a slice of IoSlice
references, enabling the slice to be directly used with writev
without any further conversion. The sum of the lengths of all the
buffers in dst
will be less than or equal to Buf::remaining()
.
The entries in dst
will be overwritten, but the data contained by
the slices will not be modified. If chunk_vectored
does not fill every
entry in dst
, then dst
is guaranteed to contain all remaining slices
in `self.
This is a lower level function. Most operations are done with other functions.
§Implementer notes
This function should never panic. Once the end of the buffer is reached,
i.e., Buf::remaining
returns 0, calls to chunk_vectored
must return 0
without mutating dst
.
Implementations should also take care to properly handle being called
with dst
being a zero length slice.
Sourcefn has_remaining(&self) -> bool
fn has_remaining(&self) -> bool
Returns true if there are any more bytes to consume
This is equivalent to self.remaining() != 0
.
§Examples
use bytes::Buf;
let mut buf = &b"a"[..];
assert!(buf.has_remaining());
buf.get_u8();
assert!(!buf.has_remaining());
Sourcefn copy_to_slice(&mut self, dst: &mut [u8])
fn copy_to_slice(&mut self, dst: &mut [u8])
Copies bytes from self
into dst
.
The cursor is advanced by the number of bytes copied. self
must have
enough remaining bytes to fill dst
.
§Examples
use bytes::Buf;
let mut buf = &b"hello world"[..];
let mut dst = [0; 5];
buf.copy_to_slice(&mut dst);
assert_eq!(&b"hello"[..], &dst);
assert_eq!(6, buf.remaining());
§Panics
This function panics if self.remaining() < dst.len()
.
Sourcefn get_u16_le(&mut self) -> u16
fn get_u16_le(&mut self) -> u16
Sourcefn get_u16_ne(&mut self) -> u16
fn get_u16_ne(&mut self) -> u16
Gets an unsigned 16 bit integer from self
in native-endian byte order.
The current position is advanced by 2.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x08\x09 hello",
false => b"\x09\x08 hello",
};
assert_eq!(0x0809, buf.get_u16_ne());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_i16_le(&mut self) -> i16
fn get_i16_le(&mut self) -> i16
Sourcefn get_i16_ne(&mut self) -> i16
fn get_i16_ne(&mut self) -> i16
Gets a signed 16 bit integer from self
in native-endian byte order.
The current position is advanced by 2.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x08\x09 hello",
false => b"\x09\x08 hello",
};
assert_eq!(0x0809, buf.get_i16_ne());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_u32_le(&mut self) -> u32
fn get_u32_le(&mut self) -> u32
Gets an unsigned 32 bit integer from self
in the little-endian byte order.
The current position is advanced by 4.
§Examples
use bytes::Buf;
let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
assert_eq!(0x0809A0A1, buf.get_u32_le());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_u32_ne(&mut self) -> u32
fn get_u32_ne(&mut self) -> u32
Gets an unsigned 32 bit integer from self
in native-endian byte order.
The current position is advanced by 4.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x08\x09\xA0\xA1 hello",
false => b"\xA1\xA0\x09\x08 hello",
};
assert_eq!(0x0809A0A1, buf.get_u32_ne());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_i32_le(&mut self) -> i32
fn get_i32_le(&mut self) -> i32
Sourcefn get_i32_ne(&mut self) -> i32
fn get_i32_ne(&mut self) -> i32
Gets a signed 32 bit integer from self
in native-endian byte order.
The current position is advanced by 4.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x08\x09\xA0\xA1 hello",
false => b"\xA1\xA0\x09\x08 hello",
};
assert_eq!(0x0809A0A1, buf.get_i32_ne());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_u64(&mut self) -> u64
fn get_u64(&mut self) -> u64
Gets an unsigned 64 bit integer from self
in big-endian byte order.
The current position is advanced by 8.
§Examples
use bytes::Buf;
let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
assert_eq!(0x0102030405060708, buf.get_u64());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_u64_le(&mut self) -> u64
fn get_u64_le(&mut self) -> u64
Gets an unsigned 64 bit integer from self
in little-endian byte order.
The current position is advanced by 8.
§Examples
use bytes::Buf;
let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(0x0102030405060708, buf.get_u64_le());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_u64_ne(&mut self) -> u64
fn get_u64_ne(&mut self) -> u64
Gets an unsigned 64 bit integer from self
in native-endian byte order.
The current position is advanced by 8.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(0x0102030405060708, buf.get_u64_ne());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_i64(&mut self) -> i64
fn get_i64(&mut self) -> i64
Gets a signed 64 bit integer from self
in big-endian byte order.
The current position is advanced by 8.
§Examples
use bytes::Buf;
let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
assert_eq!(0x0102030405060708, buf.get_i64());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_i64_le(&mut self) -> i64
fn get_i64_le(&mut self) -> i64
Gets a signed 64 bit integer from self
in little-endian byte order.
The current position is advanced by 8.
§Examples
use bytes::Buf;
let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(0x0102030405060708, buf.get_i64_le());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_i64_ne(&mut self) -> i64
fn get_i64_ne(&mut self) -> i64
Gets a signed 64 bit integer from self
in native-endian byte order.
The current position is advanced by 8.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(0x0102030405060708, buf.get_i64_ne());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_u128(&mut self) -> u128
fn get_u128(&mut self) -> u128
Gets an unsigned 128 bit integer from self
in big-endian byte order.
The current position is advanced by 16.
§Examples
use bytes::Buf;
let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
assert_eq!(0x01020304050607080910111213141516, buf.get_u128());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_u128_le(&mut self) -> u128
fn get_u128_le(&mut self) -> u128
Gets an unsigned 128 bit integer from self
in little-endian byte order.
The current position is advanced by 16.
§Examples
use bytes::Buf;
let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(0x01020304050607080910111213141516, buf.get_u128_le());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_u128_ne(&mut self) -> u128
fn get_u128_ne(&mut self) -> u128
Gets an unsigned 128 bit integer from self
in native-endian byte order.
The current position is advanced by 16.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(0x01020304050607080910111213141516, buf.get_u128_ne());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_i128(&mut self) -> i128
fn get_i128(&mut self) -> i128
Gets a signed 128 bit integer from self
in big-endian byte order.
The current position is advanced by 16.
§Examples
use bytes::Buf;
let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
assert_eq!(0x01020304050607080910111213141516, buf.get_i128());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_i128_le(&mut self) -> i128
fn get_i128_le(&mut self) -> i128
Gets a signed 128 bit integer from self
in little-endian byte order.
The current position is advanced by 16.
§Examples
use bytes::Buf;
let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
assert_eq!(0x01020304050607080910111213141516, buf.get_i128_le());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_i128_ne(&mut self) -> i128
fn get_i128_ne(&mut self) -> i128
Gets a signed 128 bit integer from self
in native-endian byte order.
The current position is advanced by 16.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
};
assert_eq!(0x01020304050607080910111213141516, buf.get_i128_ne());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_uint_le(&mut self, nbytes: usize) -> u64
fn get_uint_le(&mut self, nbytes: usize) -> u64
Gets an unsigned n-byte integer from self
in little-endian byte order.
The current position is advanced by nbytes
.
§Examples
use bytes::Buf;
let mut buf = &b"\x03\x02\x01 hello"[..];
assert_eq!(0x010203, buf.get_uint_le(3));
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_uint_ne(&mut self, nbytes: usize) -> u64
fn get_uint_ne(&mut self, nbytes: usize) -> u64
Gets an unsigned n-byte integer from self
in native-endian byte order.
The current position is advanced by nbytes
.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x01\x02\x03 hello",
false => b"\x03\x02\x01 hello",
};
assert_eq!(0x010203, buf.get_uint_ne(3));
§Panics
This function panics if there is not enough remaining data in self
, or
if nbytes
is greater than 8.
Sourcefn get_int(&mut self, nbytes: usize) -> i64
fn get_int(&mut self, nbytes: usize) -> i64
Gets a signed n-byte integer from self
in big-endian byte order.
The current position is advanced by nbytes
.
§Examples
use bytes::Buf;
let mut buf = &b"\x01\x02\x03 hello"[..];
assert_eq!(0x010203, buf.get_int(3));
§Panics
This function panics if there is not enough remaining data in self
, or
if nbytes
is greater than 8.
Sourcefn get_int_le(&mut self, nbytes: usize) -> i64
fn get_int_le(&mut self, nbytes: usize) -> i64
Gets a signed n-byte integer from self
in little-endian byte order.
The current position is advanced by nbytes
.
§Examples
use bytes::Buf;
let mut buf = &b"\x03\x02\x01 hello"[..];
assert_eq!(0x010203, buf.get_int_le(3));
§Panics
This function panics if there is not enough remaining data in self
, or
if nbytes
is greater than 8.
Sourcefn get_int_ne(&mut self, nbytes: usize) -> i64
fn get_int_ne(&mut self, nbytes: usize) -> i64
Gets a signed n-byte integer from self
in native-endian byte order.
The current position is advanced by nbytes
.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x01\x02\x03 hello",
false => b"\x03\x02\x01 hello",
};
assert_eq!(0x010203, buf.get_int_ne(3));
§Panics
This function panics if there is not enough remaining data in self
, or
if nbytes
is greater than 8.
Sourcefn get_f32(&mut self) -> f32
fn get_f32(&mut self) -> f32
Gets an IEEE754 single-precision (4 bytes) floating point number from
self
in big-endian byte order.
The current position is advanced by 4.
§Examples
use bytes::Buf;
let mut buf = &b"\x3F\x99\x99\x9A hello"[..];
assert_eq!(1.2f32, buf.get_f32());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_f32_le(&mut self) -> f32
fn get_f32_le(&mut self) -> f32
Gets an IEEE754 single-precision (4 bytes) floating point number from
self
in little-endian byte order.
The current position is advanced by 4.
§Examples
use bytes::Buf;
let mut buf = &b"\x9A\x99\x99\x3F hello"[..];
assert_eq!(1.2f32, buf.get_f32_le());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_f32_ne(&mut self) -> f32
fn get_f32_ne(&mut self) -> f32
Gets an IEEE754 single-precision (4 bytes) floating point number from
self
in native-endian byte order.
The current position is advanced by 4.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x3F\x99\x99\x9A hello",
false => b"\x9A\x99\x99\x3F hello",
};
assert_eq!(1.2f32, buf.get_f32_ne());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_f64(&mut self) -> f64
fn get_f64(&mut self) -> f64
Gets an IEEE754 double-precision (8 bytes) floating point number from
self
in big-endian byte order.
The current position is advanced by 8.
§Examples
use bytes::Buf;
let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..];
assert_eq!(1.2f64, buf.get_f64());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_f64_le(&mut self) -> f64
fn get_f64_le(&mut self) -> f64
Gets an IEEE754 double-precision (8 bytes) floating point number from
self
in little-endian byte order.
The current position is advanced by 8.
§Examples
use bytes::Buf;
let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..];
assert_eq!(1.2f64, buf.get_f64_le());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn get_f64_ne(&mut self) -> f64
fn get_f64_ne(&mut self) -> f64
Gets an IEEE754 double-precision (8 bytes) floating point number from
self
in native-endian byte order.
The current position is advanced by 8.
§Examples
use bytes::Buf;
let mut buf: &[u8] = match cfg!(target_endian = "big") {
true => b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello",
false => b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello",
};
assert_eq!(1.2f64, buf.get_f64_ne());
§Panics
This function panics if there is not enough remaining data in self
.
Sourcefn copy_to_bytes(&mut self, len: usize) -> Bytes
fn copy_to_bytes(&mut self, len: usize) -> Bytes
Consumes len
bytes inside self and returns new instance of Bytes
with this data.
This function may be optimized by the underlying type to avoid actual
copies. For example, Bytes
implementation will do a shallow copy
(ref-count increment).
§Examples
use bytes::Buf;
let bytes = (&b"hello world"[..]).copy_to_bytes(5);
assert_eq!(&bytes[..], &b"hello"[..]);
§Panics
This function panics if len > self.remaining()
.
Sourcefn take(self, limit: usize) -> Take<Self>where
Self: Sized,
fn take(self, limit: usize) -> Take<Self>where
Self: Sized,
Creates an adaptor which will read at most limit
bytes from self
.
This function returns a new instance of Buf
which will read at most
limit
bytes.
§Examples
use bytes::{Buf, BufMut};
let mut buf = b"hello world"[..].take(5);
let mut dst = vec![];
dst.put(&mut buf);
assert_eq!(dst, b"hello");
let mut buf = buf.into_inner();
dst.clear();
dst.put(&mut buf);
assert_eq!(dst, b" world");
Sourcefn chain<U: Buf>(self, next: U) -> Chain<Self, U>where
Self: Sized,
fn chain<U: Buf>(self, next: U) -> Chain<Self, U>where
Self: Sized,
Creates an adaptor which will chain this buffer with another.
The returned Buf
instance will first consume all bytes from self
.
Afterwards the output is equivalent to the output of next.
§Examples
use bytes::Buf;
let mut chain = b"hello "[..].chain(&b"world"[..]);
let full = chain.copy_to_bytes(11);
assert_eq!(full.chunk(), b"hello world");
Sourcefn reader(self) -> Reader<Self> ⓘwhere
Self: Sized,
fn reader(self) -> Reader<Self> ⓘwhere
Self: Sized,
Creates an adaptor which implements the Read
trait for self
.
This function returns a new value which implements Read
by adapting
the Read
trait functions to the Buf
trait functions. Given that
Buf
operations are infallible, none of the Read
functions will
return with Err
.
§Examples
use bytes::{Bytes, Buf};
use std::io::Read;
let buf = Bytes::from("hello world");
let mut reader = buf.reader();
let mut dst = [0; 1024];
let num = reader.read(&mut dst).unwrap();
assert_eq!(11, num);
assert_eq!(&dst[..11], &b"hello world"[..]);