# Trait hyper::body::Buf [−] [src]

###

    pub trait Buf {
        pub fn remaining(&self) -> usize;
        pub fn chunk(&self) -> &[u8]ⓘNotable traits for &'_ [u8]impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8];
        pub fn advance(&mut self, cnt: usize);

        pub fn chunks_vectored(&'a self, dst: &mut [IoSlice<'a>]) -> usize { ... }
        pub fn has_remaining(&self) -> bool { ... }
        pub fn copy_to_slice(&mut self, dst: &mut [u8]) { ... }
        pub fn get_u8(&mut self) -> u8 { ... }
        pub fn get_i8(&mut self) -> i8 { ... }
        pub fn get_u16(&mut self) -> u16 { ... }
        pub fn get_u16_le(&mut self) -> u16 { ... }
        pub fn get_i16(&mut self) -> i16 { ... }
        pub fn get_i16_le(&mut self) -> i16 { ... }
        pub fn get_u32(&mut self) -> u32 { ... }
        pub fn get_u32_le(&mut self) -> u32 { ... }
        pub fn get_i32(&mut self) -> i32 { ... }
        pub fn get_i32_le(&mut self) -> i32 { ... }
        pub fn get_u64(&mut self) -> u64 { ... }
        pub fn get_u64_le(&mut self) -> u64 { ... }
        pub fn get_i64(&mut self) -> i64 { ... }
        pub fn get_i64_le(&mut self) -> i64 { ... }
        pub fn get_u128(&mut self) -> u128 { ... }
        pub fn get_u128_le(&mut self) -> u128 { ... }
        pub fn get_i128(&mut self) -> i128 { ... }
        pub fn get_i128_le(&mut self) -> i128 { ... }
        pub fn get_uint(&mut self, nbytes: usize) -> u64 { ... }
        pub fn get_uint_le(&mut self, nbytes: usize) -> u64 { ... }
        pub fn get_int(&mut self, nbytes: usize) -> i64 { ... }
        pub fn get_int_le(&mut self, nbytes: usize) -> i64 { ... }
        pub fn get_f32(&mut self) -> f32 { ... }
        pub fn get_f32_le(&mut self) -> f32 { ... }
        pub fn get_f64(&mut self) -> f64 { ... }
        pub fn get_f64_le(&mut self) -> f64 { ... }
        pub fn copy_to_bytes(&mut self, len: usize) -> Bytes { ... }
        pub fn take(self, limit: usize) -> Take<Self> { ... }
        pub fn chain<U>(self, next: U) -> Chain<Self, U>
        where
            U: Buf,
        { ... }
        pub fn reader(self) -> Reader<Self> { ... }
    }

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

### `pub fn remaining(&self) -> usize` [src]

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.

### `pub fn chunk(&self) -> &[u8]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
` [src]

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.

### `pub fn advance(&mut self, cnt: usize)` [src]

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.

Loading content...

## Provided methods

### `pub fn chunks_vectored(&'a self, dst: &mut [IoSlice<'a>]) -> usize` [src]

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.

### `pub fn has_remaining(&self) -> bool` [src]

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

### `pub fn copy_to_slice(&mut self, dst: &mut [u8])` [src]

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

### `pub fn get_u8(&mut self) -> u8` [src]

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`.

### `pub fn get_i8(&mut self) -> i8` [src]

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`.

### `pub fn get_u16(&mut self) -> u16` [src]

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`.

### `pub fn get_u16_le(&mut self) -> u16` [src]

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`.

### `pub fn get_i16(&mut self) -> i16` [src]

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`.

### `pub fn get_i16_le(&mut self) -> i16` [src]

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`.

### `pub fn get_u32(&mut self) -> u32` [src]

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`.

### `pub fn get_u32_le(&mut self) -> u32` [src]

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`.

### `pub fn get_i32(&mut self) -> i32` [src]

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`.

### `pub fn get_i32_le(&mut self) -> i32` [src]

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`.

### `pub fn get_u64(&mut self) -> u64` [src]

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`.

### `pub fn get_u64_le(&mut self) -> u64` [src]

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`.

### `pub fn get_i64(&mut self) -> i64` [src]

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`.

### `pub fn get_i64_le(&mut self) -> i64` [src]

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`.

### `pub fn get_u128(&mut self) -> u128` [src]

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`.

### `pub fn get_u128_le(&mut self) -> u128` [src]

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`.

### `pub fn get_i128(&mut self) -> i128` [src]

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`.

### `pub fn get_i128_le(&mut self) -> i128` [src]

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`.

### `pub fn get_uint(&mut self, nbytes: usize) -> u64` [src]

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`.

### `pub fn get_uint_le(&mut self, nbytes: usize) -> u64` [src]

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`.

### `pub fn get_int(&mut self, nbytes: usize) -> i64` [src]

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`.

### `pub fn get_int_le(&mut self, nbytes: usize) -> i64` [src]

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`.

### `pub fn get_f32(&mut self) -> f32` [src]

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`.

### `pub fn get_f32_le(&mut self) -> f32` [src]

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`.

### `pub fn get_f64(&mut self) -> f64` [src]

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`.

### `pub fn get_f64_le(&mut self) -> f64` [src]

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`.

### `pub fn copy_to_bytes(&mut self, len: usize) -> Bytes` [src]

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

### `pub fn take(self, limit: usize) -> Take<Self>` [src]

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

### `pub fn chain<U>(self, next: U) -> Chain<Self, U> where
U: Buf,` [src]

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

### `pub fn reader(self) -> Reader<Self>` [src]

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

Loading content...

## Implementations on Foreign Types

### `impl<T> Buf for Cursor<T> where
T: AsRef<[u8]>,` [src]

#### `pub fn remaining(&self) -> usize` [src]

#### `pub fn chunk(&self) -> &[u8]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
` [src]

#### `pub fn advance(&mut self, cnt: usize)` [src]

### `impl Buf for BytesMut` [src]

#### `pub fn remaining(&self) -> usize` [src]

#### `pub fn chunk(&self) -> &[u8]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
` [src]

#### `pub fn advance(&mut self, cnt: usize)` [src]

#### `pub fn copy_to_bytes(&mut self, len: usize) -> Bytes` [src]

### `impl<T> Buf for Box<T, Global> where
T: Buf + ?Sized,` [src]

#### `pub fn remaining(&self) -> usize` [src]

#### `pub fn chunk(&self) -> &[u8]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
` [src]

#### `pub fn chunks_vectored(&'b self, dst: &mut [IoSlice<'b>]) -> usize` [src]

#### `pub fn advance(&mut self, cnt: usize)` [src]

#### `pub fn has_remaining(&self) -> bool` [src]

#### `pub fn copy_to_slice(&mut self, dst: &mut [u8])` [src]

#### `pub fn get_u8(&mut self) -> u8` [src]

#### `pub fn get_i8(&mut self) -> i8` [src]

#### `pub fn get_u16(&mut self) -> u16` [src]

#### `pub fn get_u16_le(&mut self) -> u16` [src]

#### `pub fn get_i16(&mut self) -> i16` [src]

#### `pub fn get_i16_le(&mut self) -> i16` [src]

#### `pub fn get_u32(&mut self) -> u32` [src]

#### `pub fn get_u32_le(&mut self) -> u32` [src]

#### `pub fn get_i32(&mut self) -> i32` [src]

#### `pub fn get_i32_le(&mut self) -> i32` [src]

#### `pub fn get_u64(&mut self) -> u64` [src]

#### `pub fn get_u64_le(&mut self) -> u64` [src]

#### `pub fn get_i64(&mut self) -> i64` [src]

#### `pub fn get_i64_le(&mut self) -> i64` [src]

#### `pub fn get_uint(&mut self, nbytes: usize) -> u64` [src]

#### `pub fn get_uint_le(&mut self, nbytes: usize) -> u64` [src]

#### `pub fn get_int(&mut self, nbytes: usize) -> i64` [src]

#### `pub fn get_int_le(&mut self, nbytes: usize) -> i64` [src]

#### `pub fn copy_to_bytes(&mut self, len: usize) -> Bytes` [src]

### `impl<T, U> Buf for Chain<T, U> where
T: Buf,
U: Buf,` [src]

#### `pub fn remaining(&self) -> usize` [src]

#### `pub fn chunk(&self) -> &[u8]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
` [src]

#### `pub fn advance(&mut self, cnt: usize)` [src]

#### `pub fn chunks_vectored(&'a self, dst: &mut [IoSlice<'a>]) -> usize` [src]

### `impl Buf for VecDeque<u8>` [src]

#### `pub fn remaining(&self) -> usize` [src]

#### `pub fn chunk(&self) -> &[u8]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
` [src]

#### `pub fn advance(&mut self, cnt: usize)` [src]

### `impl<T> Buf for Take<T> where
T: Buf,` [src]

#### `pub fn remaining(&self) -> usize` [src]

#### `pub fn chunk(&self) -> &[u8]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
` [src]

#### `pub fn advance(&mut self, cnt: usize)` [src]

### `impl<'_, T> Buf for &'_ mut T where
T: Buf + ?Sized,` [src]

#### `pub fn remaining(&self) -> usize` [src]

#### `pub fn chunk(&self) -> &[u8]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
` [src]

#### `pub fn chunks_vectored(&'b self, dst: &mut [IoSlice<'b>]) -> usize` [src]

#### `pub fn advance(&mut self, cnt: usize)` [src]

#### `pub fn has_remaining(&self) -> bool` [src]

#### `pub fn copy_to_slice(&mut self, dst: &mut [u8])` [src]

#### `pub fn get_u8(&mut self) -> u8` [src]

#### `pub fn get_i8(&mut self) -> i8` [src]

#### `pub fn get_u16(&mut self) -> u16` [src]

#### `pub fn get_u16_le(&mut self) -> u16` [src]

#### `pub fn get_i16(&mut self) -> i16` [src]

#### `pub fn get_i16_le(&mut self) -> i16` [src]

#### `pub fn get_u32(&mut self) -> u32` [src]

#### `pub fn get_u32_le(&mut self) -> u32` [src]

#### `pub fn get_i32(&mut self) -> i32` [src]

#### `pub fn get_i32_le(&mut self) -> i32` [src]

#### `pub fn get_u64(&mut self) -> u64` [src]

#### `pub fn get_u64_le(&mut self) -> u64` [src]

#### `pub fn get_i64(&mut self) -> i64` [src]

#### `pub fn get_i64_le(&mut self) -> i64` [src]

#### `pub fn get_uint(&mut self, nbytes: usize) -> u64` [src]

#### `pub fn get_uint_le(&mut self, nbytes: usize) -> u64` [src]

#### `pub fn get_int(&mut self, nbytes: usize) -> i64` [src]

#### `pub fn get_int_le(&mut self, nbytes: usize) -> i64` [src]

#### `pub fn copy_to_bytes(&mut self, len: usize) -> Bytes` [src]

### `impl<'_> Buf for &'_ [u8]` [src]

#### `pub fn remaining(&self) -> usize` [src]

#### `pub fn chunk(&self) -> &[u8]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
` [src]

#### `pub fn advance(&mut self, cnt: usize)` [src]

Loading content...

## Implementors

### `impl Buf for Bytes` [src]

#### `pub fn remaining(&self) -> usize` [src]

#### `pub fn chunk(&self) -> &[u8]ⓘ

### Notable traits for &'_ [u8]

`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`
` [src]

#### `pub fn advance(&mut self, cnt: usize)` [src]

#### `pub fn copy_to_bytes(&mut self, len: usize) -> Bytes` [src]

Loading content...