Trait bytes::buf::Buf

source ·

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§

source

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.

source

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 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. Once the end of the buffer is reached, i.e., Buf::remaining returns 0, calls to chunk() should return an empty slice.

source

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§

source

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.

source

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());

source

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()

source

fn get_u8(&mut self) -> u8

Gets an unsigned 8 bit integer from self.

The current position is advanced by 1.

Examples

use bytes::Buf;

let mut buf = &b"\x08 hello"[..];
assert_eq!(8, buf.get_u8());

Panics

This function panics if there is no more remaining data in self.

source

fn get_i8(&mut self) -> i8

Gets a signed 8 bit integer from self.

The current position is advanced by 1.

Examples

use bytes::Buf;

let mut buf = &b"\x08 hello"[..];
assert_eq!(8, buf.get_i8());

Panics

This function panics if there is no more remaining data in self.

source

fn get_u16(&mut self) -> u16

Gets an unsigned 16 bit integer from self in big-endian byte order.

The current position is advanced by 2.

Examples

use bytes::Buf;

let mut buf = &b"\x08\x09 hello"[..];
assert_eq!(0x0809, buf.get_u16());

Panics

This function panics if there is not enough remaining data in self.

source

fn get_u16_le(&mut self) -> u16

Gets an unsigned 16 bit integer from self in little-endian byte order.

The current position is advanced by 2.

Examples

use bytes::Buf;

let mut buf = &b"\x09\x08 hello"[..];
assert_eq!(0x0809, buf.get_u16_le());

Panics

This function panics if there is not enough remaining data in self.

source

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.

source

fn get_i16(&mut self) -> i16

Gets a signed 16 bit integer from self in big-endian byte order.

The current position is advanced by 2.

Examples

use bytes::Buf;

let mut buf = &b"\x08\x09 hello"[..];
assert_eq!(0x0809, buf.get_i16());

Panics

This function panics if there is not enough remaining data in self.

source

fn get_i16_le(&mut self) -> i16

Gets a signed 16 bit integer from self in little-endian byte order.

The current position is advanced by 2.

Examples

use bytes::Buf;

let mut buf = &b"\x09\x08 hello"[..];
assert_eq!(0x0809, buf.get_i16_le());

Panics

This function panics if there is not enough remaining data in self.

source

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.

source

fn get_u32(&mut self) -> u32

Gets an unsigned 32 bit integer from self in the big-endian byte order.

The current position is advanced by 4.

Examples

use bytes::Buf;

let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
assert_eq!(0x0809A0A1, buf.get_u32());

Panics

This function panics if there is not enough remaining data in self.

source

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.

source

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.

source

fn get_i32(&mut self) -> i32

Gets a signed 32 bit integer from self in big-endian byte order.

The current position is advanced by 4.

Examples

use bytes::Buf;

let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
assert_eq!(0x0809A0A1, buf.get_i32());

Panics

This function panics if there is not enough remaining data in self.

source

fn get_i32_le(&mut self) -> i32

Gets a signed 32 bit integer from self in 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_i32_le());

Panics

This function panics if there is not enough remaining data in self.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

fn get_uint(&mut self, nbytes: usize) -> u64

Gets an unsigned 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_uint(3));

Panics

This function panics if there is not enough remaining data in self.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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"[..]);

source

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");

source

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");

source

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"[..]);

Implementations on Foreign Types§

source §

fn copy_to_bytes(&mut self, len: usize) -> Bytes

Implementors§

source §

impl Buf for Bytes

source §

impl Buf for BytesMut

source §

impl<T, U> Buf for Chain<T, U>where T: Buf, U: Buf,

source §