# Trait bytes::BufMut [−] [src]

###

    pub unsafe trait BufMut {
        fn remaining_mut(&self) -> usize;
        unsafe fn advance_mut(&mut self, cnt: usize);
        fn chunk_mut(&mut self) -> &mut UninitSlice;

        fn has_remaining_mut(&self) -> bool { ... }
        fn put<T: Buf>(&mut self, src: T)
        where
            Self: Sized,
        { ... }
        fn put_slice(&mut self, src: &[u8]) { ... }
        fn put_u8(&mut self, n: u8) { ... }
        fn put_i8(&mut self, n: i8) { ... }
        fn put_u16(&mut self, n: u16) { ... }
        fn put_u16_le(&mut self, n: u16) { ... }
        fn put_i16(&mut self, n: i16) { ... }
        fn put_i16_le(&mut self, n: i16) { ... }
        fn put_u32(&mut self, n: u32) { ... }
        fn put_u32_le(&mut self, n: u32) { ... }
        fn put_i32(&mut self, n: i32) { ... }
        fn put_i32_le(&mut self, n: i32) { ... }
        fn put_u64(&mut self, n: u64) { ... }
        fn put_u64_le(&mut self, n: u64) { ... }
        fn put_i64(&mut self, n: i64) { ... }
        fn put_i64_le(&mut self, n: i64) { ... }
        fn put_u128(&mut self, n: u128) { ... }
        fn put_u128_le(&mut self, n: u128) { ... }
        fn put_i128(&mut self, n: i128) { ... }
        fn put_i128_le(&mut self, n: i128) { ... }
        fn put_uint(&mut self, n: u64, nbytes: usize) { ... }
        fn put_uint_le(&mut self, n: u64, nbytes: usize) { ... }
        fn put_int(&mut self, n: i64, nbytes: usize) { ... }
        fn put_int_le(&mut self, n: i64, nbytes: usize) { ... }
        fn put_f32(&mut self, n: f32) { ... }
        fn put_f32_le(&mut self, n: f32) { ... }
        fn put_f64(&mut self, n: f64) { ... }
        fn put_f64_le(&mut self, n: f64) { ... }
        fn limit(self, limit: usize) -> Limit<Self>
        where
            Self: Sized,
        { ... }
        fn writer(self) -> Writer<Self>ⓘNotable traits for Writer<B>impl<B: BufMut + Sized> Write for Writer<B>
        where
            Self: Sized,
        { ... }
        fn chain_mut<U: BufMut>(self, next: U) -> Chain<Self, U>
        where
            Self: Sized,
        { ... }
    }

A trait for values that provide sequential write access to bytes.

Write bytes to a buffer

A buffer stores bytes in memory such that write operations are infallible. The underlying storage may or may not be in contiguous memory. A `BufMut` value is a cursor into the buffer. Writing to `BufMut` advances the cursor position.

The simplest `BufMut` is a `Vec<u8>`.

    use bytes::BufMut;

    let mut buf = vec![];

    buf.put(&b"hello world"[..]);

    assert_eq!(buf, b"hello world");

## Required methods

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

Returns the number of bytes that can be written from the current position until the end of the buffer is reached.

This value is greater than or equal to the length of the slice returned by `chunk_mut()`.

# Examples

    use bytes::BufMut;

    let mut dst = [0; 10];
    let mut buf = &mut dst[..];

    let original_remaining = buf.remaining_mut();
    buf.put(&b"hello"[..]);

    assert_eq!(original_remaining - 5, buf.remaining_mut());

# Implementer notes

Implementations of `remaining_mut` should ensure that the return value does not change unless a call is made to `advance_mut` or any other function that is documented to change the `BufMut`’s current position.

### `unsafe fn advance_mut(&mut self, cnt: usize)` [src]

Advance the internal cursor of the BufMut

The next call to `chunk_mut` will return a slice starting `cnt` bytes further into the underlying buffer.

This function is unsafe because there is no guarantee that the bytes being advanced past have been initialized.

# Examples

    use bytes::BufMut;

    let mut buf = Vec::with_capacity(16);

    // Write some data
    buf.chunk_mut()[0..2].copy_from_slice(b"he");
    unsafe { buf.advance_mut(2) };

    // write more bytes
    buf.chunk_mut()[0..3].copy_from_slice(b"llo");

    unsafe { buf.advance_mut(3); }

    assert_eq!(5, buf.len());
    assert_eq!(buf, b"hello");

# Panics

This function may panic if `cnt > self.remaining_mut()`.

# Implementer notes

It is recommended for implementations of `advance_mut` to panic if `cnt > self.remaining_mut()`. If the implementation does not panic, the call must behave as if `cnt == self.remaining_mut()`.

A call with `cnt == 0` should never panic and be a no-op.

### `fn chunk_mut(&mut self) -> &mut UninitSlice` [src]

Returns a mutable slice starting at the current BufMut position and of length between 0 and `BufMut::remaining_mut()`. Note that this can be shorter than the whole remainder of the buffer (this allows non-continuous implementation).

This is a lower level function. Most operations are done with other functions.

The returned byte slice may represent uninitialized memory.

# Examples

    use bytes::BufMut;

    let mut buf = Vec::with_capacity(16);

    unsafe {
        // MaybeUninit::as_mut_ptr
        buf.chunk_mut()[0..].as_mut_ptr().write(b'h');
        buf.chunk_mut()[1..].as_mut_ptr().write(b'e');

        buf.advance_mut(2);

        buf.chunk_mut()[0..].as_mut_ptr().write(b'l');
        buf.chunk_mut()[1..].as_mut_ptr().write(b'l');
        buf.chunk_mut()[2..].as_mut_ptr().write(b'o');

        buf.advance_mut(3);
    }

    assert_eq!(5, buf.len());
    assert_eq!(buf, b"hello");

# Implementer notes

This function should never panic. `chunk_mut` should return an empty slice if and only if `remaining_mut()` returns 0. In other words, `chunk_mut()` returning an empty slice implies that `remaining_mut()` will return 0 and `remaining_mut()` returning 0 implies that `chunk_mut()` will return an empty slice.

Loading content...

## Provided methods

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

Returns true if there is space in `self` for more bytes.

This is equivalent to `self.remaining_mut() != 0`.

# Examples

    use bytes::BufMut;

    let mut dst = [0; 5];
    let mut buf = &mut dst[..];

    assert!(buf.has_remaining_mut());

    buf.put(&b"hello"[..]);

    assert!(!buf.has_remaining_mut());

### `fn put<T: Buf>(&mut self, src: T) where
Self: Sized,` [src]

Transfer bytes into `self` from `src` and advance the cursor by the number of bytes written.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];

    buf.put_u8(b'h');
    buf.put(&b"ello"[..]);
    buf.put(&b" world"[..]);

    assert_eq!(buf, b"hello world");

# Panics

Panics if `self` does not have enough capacity to contain `src`.

### `fn put_slice(&mut self, src: &[u8])` [src]

Transfer bytes into `self` from `src` and advance the cursor by the number of bytes written.

`self` must have enough remaining capacity to contain all of `src`.

    use bytes::BufMut;

    let mut dst = [0; 6];

    {
        let mut buf = &mut dst[..];
        buf.put_slice(b"hello");

        assert_eq!(1, buf.remaining_mut());
    }

    assert_eq!(b"hello\0", &dst);

### `fn put_u8(&mut self, n: u8)` [src]

Writes an unsigned 8 bit integer to `self`.

The current position is advanced by 1.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_u8(0x01);
    assert_eq!(buf, b"\x01");

# Panics

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

### `fn put_i8(&mut self, n: i8)` [src]

Writes a signed 8 bit integer to `self`.

The current position is advanced by 1.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_i8(0x01);
    assert_eq!(buf, b"\x01");

# Panics

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

### `fn put_u16(&mut self, n: u16)` [src]

Writes an unsigned 16 bit integer to `self` in big-endian byte order.

The current position is advanced by 2.

# Examples

    use bytes::BufMut;

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

# Panics

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

### `fn put_u16_le(&mut self, n: u16)` [src]

Writes an unsigned 16 bit integer to `self` in little-endian byte order.

The current position is advanced by 2.

# Examples

    use bytes::BufMut;

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

# Panics

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

### `fn put_i16(&mut self, n: i16)` [src]

Writes a signed 16 bit integer to `self` in big-endian byte order.

The current position is advanced by 2.

# Examples

    use bytes::BufMut;

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

# Panics

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

### `fn put_i16_le(&mut self, n: i16)` [src]

Writes a signed 16 bit integer to `self` in little-endian byte order.

The current position is advanced by 2.

# Examples

    use bytes::BufMut;

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

# Panics

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

### `fn put_u32(&mut self, n: u32)` [src]

Writes an unsigned 32 bit integer to `self` in big-endian byte order.

The current position is advanced by 4.

# Examples

    use bytes::BufMut;

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

# Panics

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

### `fn put_u32_le(&mut self, n: u32)` [src]

Writes an unsigned 32 bit integer to `self` in little-endian byte order.

The current position is advanced by 4.

# Examples

    use bytes::BufMut;

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

# Panics

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

### `fn put_i32(&mut self, n: i32)` [src]

Writes a signed 32 bit integer to `self` in big-endian byte order.

The current position is advanced by 4.

# Examples

    use bytes::BufMut;

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

# Panics

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

### `fn put_i32_le(&mut self, n: i32)` [src]

Writes a signed 32 bit integer to `self` in little-endian byte order.

The current position is advanced by 4.

# Examples

    use bytes::BufMut;

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

# Panics

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

### `fn put_u64(&mut self, n: u64)` [src]

Writes an unsigned 64 bit integer to `self` in the big-endian byte order.

The current position is advanced by 8.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_u64(0x0102030405060708);
    assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");

# Panics

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

### `fn put_u64_le(&mut self, n: u64)` [src]

Writes an unsigned 64 bit integer to `self` in little-endian byte order.

The current position is advanced by 8.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_u64_le(0x0102030405060708);
    assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");

# Panics

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

### `fn put_i64(&mut self, n: i64)` [src]

Writes a signed 64 bit integer to `self` in the big-endian byte order.

The current position is advanced by 8.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_i64(0x0102030405060708);
    assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");

# Panics

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

### `fn put_i64_le(&mut self, n: i64)` [src]

Writes a signed 64 bit integer to `self` in little-endian byte order.

The current position is advanced by 8.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_i64_le(0x0102030405060708);
    assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");

# Panics

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

### `fn put_u128(&mut self, n: u128)` [src]

Writes an unsigned 128 bit integer to `self` in the big-endian byte order.

The current position is advanced by 16.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_u128(0x01020304050607080910111213141516);
    assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");

# Panics

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

### `fn put_u128_le(&mut self, n: u128)` [src]

Writes an unsigned 128 bit integer to `self` in little-endian byte order.

The current position is advanced by 16.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_u128_le(0x01020304050607080910111213141516);
    assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");

# Panics

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

### `fn put_i128(&mut self, n: i128)` [src]

Writes a signed 128 bit integer to `self` in the big-endian byte order.

The current position is advanced by 16.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_i128(0x01020304050607080910111213141516);
    assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");

# Panics

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

### `fn put_i128_le(&mut self, n: i128)` [src]

Writes a signed 128 bit integer to `self` in little-endian byte order.

The current position is advanced by 16.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_i128_le(0x01020304050607080910111213141516);
    assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");

# Panics

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

### `fn put_uint(&mut self, n: u64, nbytes: usize)` [src]

Writes an unsigned n-byte integer to `self` in big-endian byte order.

The current position is advanced by `nbytes`.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_uint(0x010203, 3);
    assert_eq!(buf, b"\x01\x02\x03");

# Panics

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

### `fn put_uint_le(&mut self, n: u64, nbytes: usize)` [src]

Writes an unsigned n-byte integer to `self` in the little-endian byte order.

The current position is advanced by `nbytes`.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_uint_le(0x010203, 3);
    assert_eq!(buf, b"\x03\x02\x01");

# Panics

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

### `fn put_int(&mut self, n: i64, nbytes: usize)` [src]

Writes a signed n-byte integer to `self` in big-endian byte order.

The current position is advanced by `nbytes`.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_int(0x010203, 3);
    assert_eq!(buf, b"\x01\x02\x03");

# Panics

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

### `fn put_int_le(&mut self, n: i64, nbytes: usize)` [src]

Writes a signed n-byte integer to `self` in little-endian byte order.

The current position is advanced by `nbytes`.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_int_le(0x010203, 3);
    assert_eq!(buf, b"\x03\x02\x01");

# Panics

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

### `fn put_f32(&mut self, n: f32)` [src]

Writes an IEEE754 single-precision (4 bytes) floating point number to `self` in big-endian byte order.

The current position is advanced by 4.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_f32(1.2f32);
    assert_eq!(buf, b"\x3F\x99\x99\x9A");

# Panics

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

### `fn put_f32_le(&mut self, n: f32)` [src]

Writes an IEEE754 single-precision (4 bytes) floating point number to `self` in little-endian byte order.

The current position is advanced by 4.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_f32_le(1.2f32);
    assert_eq!(buf, b"\x9A\x99\x99\x3F");

# Panics

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

### `fn put_f64(&mut self, n: f64)` [src]

Writes an IEEE754 double-precision (8 bytes) floating point number to `self` in big-endian byte order.

The current position is advanced by 8.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_f64(1.2f64);
    assert_eq!(buf, b"\x3F\xF3\x33\x33\x33\x33\x33\x33");

# Panics

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

### `fn put_f64_le(&mut self, n: f64)` [src]

Writes an IEEE754 double-precision (8 bytes) floating point number to `self` in little-endian byte order.

The current position is advanced by 8.

# Examples

    use bytes::BufMut;

    let mut buf = vec![];
    buf.put_f64_le(1.2f64);
    assert_eq!(buf, b"\x33\x33\x33\x33\x33\x33\xF3\x3F");

# Panics

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

### `fn limit(self, limit: usize) -> Limit<Self> where
Self: Sized,` [src]

Creates an adaptor which can write at most `limit` bytes to `self`.

# Examples

    use bytes::BufMut;

    let arr = &mut [0u8; 128][..];
    assert_eq!(arr.remaining_mut(), 128);

    let dst = arr.limit(10);
    assert_eq!(dst.remaining_mut(), 10);

### `fn writer(self) -> Writer<Self>ⓘ

### Notable traits for Writer<B>

`impl<B: BufMut + Sized> Write for Writer<B>`
where
Self: Sized,` [src]

Creates an adaptor which implements the `Write` trait for `self`.

This function returns a new value which implements `Write` by adapting the `Write` trait functions to the `BufMut` trait functions. Given that `BufMut` operations are infallible, none of the `Write` functions will return with `Err`.

# Examples

    use bytes::BufMut;
    use std::io::Write;

    let mut buf = vec![].writer();

    let num = buf.write(&b"hello world"[..]).unwrap();
    assert_eq!(11, num);

    let buf = buf.into_inner();

    assert_eq!(*buf, b"hello world"[..]);

### `fn chain_mut<U: BufMut>(self, next: U) -> Chain<Self, U> where
Self: Sized,` [src]

Creates an adapter which will chain this buffer with another.

The returned `BufMut` instance will first write to all bytes from `self`. Afterwards, it will write to `next`.

# Examples

    use bytes::BufMut;

    let mut a = [0u8; 5];
    let mut b = [0u8; 6];

    let mut chain = (&mut a[..]).chain_mut(&mut b[..]);

    chain.put_slice(b"hello world");

    assert_eq!(&a[..], b"hello");
    assert_eq!(&b[..], b" world");

Loading content...

## Implementations on Foreign Types

### `impl<T: BufMut + ?Sized> BufMut for &mut T` [src]

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

#### `fn chunk_mut(&mut self) -> &mut UninitSlice` [src]

#### `unsafe fn advance_mut(&mut self, cnt: usize)` [src]

#### `fn put_slice(&mut self, src: &[u8])` [src]

#### `fn put_u8(&mut self, n: u8)` [src]

#### `fn put_i8(&mut self, n: i8)` [src]

#### `fn put_u16(&mut self, n: u16)` [src]

#### `fn put_u16_le(&mut self, n: u16)` [src]

#### `fn put_i16(&mut self, n: i16)` [src]

#### `fn put_i16_le(&mut self, n: i16)` [src]

#### `fn put_u32(&mut self, n: u32)` [src]

#### `fn put_u32_le(&mut self, n: u32)` [src]

#### `fn put_i32(&mut self, n: i32)` [src]

#### `fn put_i32_le(&mut self, n: i32)` [src]

#### `fn put_u64(&mut self, n: u64)` [src]

#### `fn put_u64_le(&mut self, n: u64)` [src]

#### `fn put_i64(&mut self, n: i64)` [src]

#### `fn put_i64_le(&mut self, n: i64)` [src]

### `impl<T: BufMut + ?Sized> BufMut for Box<T>` [src]

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

#### `fn chunk_mut(&mut self) -> &mut UninitSlice` [src]

#### `unsafe fn advance_mut(&mut self, cnt: usize)` [src]

#### `fn put_slice(&mut self, src: &[u8])` [src]

#### `fn put_u8(&mut self, n: u8)` [src]

#### `fn put_i8(&mut self, n: i8)` [src]

#### `fn put_u16(&mut self, n: u16)` [src]

#### `fn put_u16_le(&mut self, n: u16)` [src]

#### `fn put_i16(&mut self, n: i16)` [src]

#### `fn put_i16_le(&mut self, n: i16)` [src]

#### `fn put_u32(&mut self, n: u32)` [src]

#### `fn put_u32_le(&mut self, n: u32)` [src]

#### `fn put_i32(&mut self, n: i32)` [src]

#### `fn put_i32_le(&mut self, n: i32)` [src]

#### `fn put_u64(&mut self, n: u64)` [src]

#### `fn put_u64_le(&mut self, n: u64)` [src]

#### `fn put_i64(&mut self, n: i64)` [src]

#### `fn put_i64_le(&mut self, n: i64)` [src]

### `impl BufMut for &mut [u8]` [src]

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

#### `fn chunk_mut(&mut self) -> &mut UninitSlice` [src]

#### `unsafe fn advance_mut(&mut self, cnt: usize)` [src]

### `impl BufMut for Vec<u8>` [src]

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

#### `unsafe fn advance_mut(&mut self, cnt: usize)` [src]

#### `fn chunk_mut(&mut self) -> &mut UninitSlice` [src]

#### `fn put<T: Buf>(&mut self, src: T) where
Self: Sized,` [src]

#### `fn put_slice(&mut self, src: &[u8])` [src]

Loading content...

## Implementors

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

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

#### `unsafe fn advance_mut(&mut self, cnt: usize)` [src]

#### `fn chunk_mut(&mut self) -> &mut UninitSlice` [src]

#### `fn put<T: Buf>(&mut self, src: T) where
Self: Sized,` [src]

#### `fn put_slice(&mut self, src: &[u8])` [src]

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

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

#### `fn chunk_mut(&mut self) -> &mut UninitSlice` [src]

#### `unsafe fn advance_mut(&mut self, cnt: usize)` [src]

### `impl<T: BufMut> BufMut for Limit<T>` [src]

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

#### `fn chunk_mut(&mut self) -> &mut UninitSlice` [src]

#### `unsafe fn advance_mut(&mut self, cnt: usize)` [src]

Loading content...