Struct WriteBuf

pub struct WriteBuf<B: ?Sized>(/* private fields */);

A wrapper around any type that implements BufMut for improved ergonomics in generic code.

WriteBuf provides a unified interface over different buffer types, making it easier to write generic functions that accept various writable buffer types without requiring complex type signatures or awkward reference patterns.

Problem Solved

When writing generic functions that accept BufMut implementors, you often run into ergonomic issues with reference types. For example, with &mut [u8], callers would need to pass &mut &mut [u8] which is awkward and unintuitive.

Solution

By using impl Into<WriteBuf<B>> in your function signatures, callers can pass buffer types naturally without extra reference wrapping:

use bufkit::{BufMut, WriteBuf};

// Instead of this awkward signature:
fn encode_bad<B: BufMut>(buf: &mut B) { /* ... */ }

// Use this ergonomic signature:
fn encode_good<B: BufMut>(buf: impl Into<WriteBuf<B>>) { /* ... */ }

// Now callers can write:
let mut buffer = [0u8; 64];
encode_good(&mut buffer[..]);        // Natural - no double reference needed
encode_bad(&mut &mut buffer[..]);    // Awkward - requires &mut &mut

Common Usage Pattern

This type is particularly useful for encoding/serialization APIs where you want to accept various buffer types:

use bufkit::{BufMut, WriteBuf};

pub trait Encode {
    fn encode<B: BufMut>(&self, buf: impl Into<WriteBuf<B>>) -> Result<usize, Error>;
}

impl Encode for MyStruct {
    fn encode<B: BufMut>(&self, buf: impl Into<WriteBuf<B>>) -> Result<usize, Error> {
        let mut buf = buf.into();
        // Write to buf...
        Ok(bytes_written)
    }
}

// Usage is clean and intuitive:
let my_struct = MyStruct::new();
let mut array_buf = [0u8; 100];

my_struct.encode(&mut array_buf[..])?;  // No &mut &mut needed

Type Flexibility

WriteBuf can wrap any type that implements BufMut, including:

• &mut [u8] - Fixed-size byte arrays
• Custom buffer implementations
• Other BufMut implementors

Implementations

impl<B: ?Sized> WriteBuf<B>

pub const fn as_mut(&mut self) -> WriteBuf<&mut B>

Similar to Option::as_mut, converts &mut WriteBuf<B> to WriteBuf<&mut B>.

Example

use bufkit::{BufMut, WriteBuf};

let mut buf = [0u8; 24];
let mut write_buf = WriteBuf::from(&mut buf[..]);
let _ = write_buf.as_mut();

pub const fn as_ref(&self) -> WriteBuf<&B>

Similar to Option::as_ref, converts &WriteBuf<B> to WriteBuf<&B>.

Example

use bufkit::{BufMut, WriteBuf};

let mut buf = [0u8; 24];
let write_buf = WriteBuf::from(&mut buf[..]);
let _ = write_buf.as_ref();

impl<B> WriteBuf<B>

pub fn into_inner(self) -> B

Consumes the WriteBuf and returns the underlying BufMut.

Examples

use bufkit::{BufMut, WriteBuf};

let mut buf = [0u8; 24];
let mut write_buf = WriteBuf::from(&mut buf[..]);
let _ = write_buf.into_inner();

Trait Implementations

impl<B: ?Sized + BufMut> BufMut for WriteBuf<B>

fn has_remaining_mut(&self) -> bool

Returns true if the buffer has available space for writing.

fn remaining_mut(&self) -> usize

Returns the number of bytes available for writing in the buffer.

fn advance_mut(&mut self, cnt: usize)

Advances the internal cursor by the specified number of bytes.

fn try_advance_mut(&mut self, cnt: usize) -> Result<(), TryAdvanceError>

Attempts to advance the internal cursor by the specified number of bytes.

fn truncate_mut(&mut self, new_len: usize)

Shortens the buffer to the specified length, keeping the first len bytes.

fn buffer_mut(&mut self) -> &mut [u8]

Returns the entire initialized buffer as a remaining_mut slice.

fn fill(&mut self, value: u8)

Fills the entire buffer with the specified byte value.

fn prefix_mut(&mut self, len: usize) -> &mut [u8]

Returns a remaining_mut slice containing the first len bytes of the buffer.

fn prefix_mut_checked(&mut self, len: usize) -> Option<&mut [u8]>

Returns a remaining_mut slice containing the first len bytes of the buffer.

fn suffix_mut(&mut self, len: usize) -> &mut [u8]

Returns a remaining_mut slice containing the last len bytes of the buffer.

fn suffix_mut_checked(&mut self, len: usize) -> Option<&mut [u8]>

Returns a remaining_mut slice containing the last len bytes of the buffer.

fn split_at_mut(&mut self, mid: usize) -> (&mut [u8], &mut [u8])

Divides the buffer into two remaining_mut slices at the given index.

fn split_at_mut_checked(&mut self, mid: usize) -> Option<(&mut [u8], &mut [u8])>

Divides the buffer into two remaining_mut slices at the given index.

fn put_slice(&mut self, slice: &[u8]) -> usize

Puts slice of bytes to the beginning of the buffer without advancing the internal cursor.

fn put_slice_checked(&mut self, slice: &[u8]) -> Option<usize>

Tries to put slice of bytes to the beginning of the buffer without advancing the internal cursor.

fn try_put_slice(&mut self, slice: &[u8]) -> Result<usize, TryPutError>

Tries to put slice of bytes to the beginning of the buffer without advancing the internal cursor.

fn put_slice_at(&mut self, slice: &[u8], offset: usize) -> usize

Puts slice of bytes to the buffer at the specified offset without advancing the internal cursor.

fn put_slice_at_checked(&mut self, slice: &[u8], offset: usize) -> Option<usize>

Tries to put slice of bytes to the buffer at the specified offset without advancing the internal cursor.

fn try_put_slice_at( &mut self, slice: &[u8], offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put slice of bytes to the buffer at the specified offset without advancing the internal cursor.

fn put_u8(&mut self, value: u8) -> usize

Puts u8 value to the beginning of the buffer without advancing the internal cursor.

fn put_u8_checked(&mut self, value: u8) -> Option<usize>

Tries to put u8 value to the beginning of the buffer without advancing the internal cursor.

fn try_put_u8(&mut self, value: u8) -> Result<usize, TryPutError>

Tries to put u8 value to the beginning of the buffer without advancing the internal cursor.

fn put_i8(&mut self, value: i8) -> usize

Puts i8 value to the beginning of the buffer without advancing the internal cursor.

fn put_i8_checked(&mut self, value: i8) -> Option<usize>

Tries to put i8 value to the beginning of the buffer without advancing the internal cursor.

fn try_put_i8(&mut self, value: i8) -> Result<usize, TryPutError>

Tries to put i8 value to the beginning of the buffer without advancing the internal cursor.

fn put_u8_at(&mut self, value: u8, offset: usize) -> usize

Puts u8 value to the buffer at the specified offset without advancing the internal cursor.

fn put_u8_at_checked(&mut self, value: u8, offset: usize) -> Option<usize>

Tries to put u8 value to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u8_at( &mut self, value: u8, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u8 value to the buffer at the specified offset without advancing the internal cursor.

fn put_i8_at(&mut self, value: i8, offset: usize) -> usize

Puts i8 value to the buffer at the specified offset without advancing the internal cursor.

fn put_i8_at_checked(&mut self, value: i8, offset: usize) -> Option<usize>

Tries to put i8 value to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i8_at( &mut self, value: i8, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i8 value to the buffer at the specified offset without advancing the internal cursor.

fn put_u16_le_at(&mut self, value: u16, offset: usize) -> usize

Puts a u16 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u16_le_at_checked(&mut self, value: u16, offset: usize) -> Option<usize>

Tries to put u16 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u16_le_at( &mut self, value: u16, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u16 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u16_be_at(&mut self, value: u16, offset: usize) -> usize

Puts u16 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u16_be_at_checked(&mut self, value: u16, offset: usize) -> Option<usize>

Tries to put u16 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u16_be_at( &mut self, value: u16, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u16 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u16_ne_at(&mut self, value: u16, offset: usize) -> usize

Puts u16 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u16_ne_at_checked(&mut self, value: u16, offset: usize) -> Option<usize>

Tries to put u16 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u16_ne_at( &mut self, value: u16, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u16 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u16_le(&mut self, value: u16) -> usize

Puts u16 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u16_le_checked(&mut self, value: u16) -> Option<usize>

Tries to put u16 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u16_le(&mut self, value: u16) -> Result<usize, TryPutError>

Tries to put u16 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u16_be(&mut self, value: u16) -> usize

Puts a u16 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u16_be_checked(&mut self, value: u16) -> Option<usize>

Tries to put u16 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u16_be(&mut self, value: u16) -> Result<usize, TryPutError>

Tries to put u16 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u16_ne(&mut self, value: u16) -> usize

Puts u16 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u16_ne_checked(&mut self, value: u16) -> Option<usize>

Tries to put u16 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u16_ne(&mut self, value: u16) -> Result<usize, TryPutError>

Tries to put u16 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u32_le_at(&mut self, value: u32, offset: usize) -> usize

Puts a u32 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u32_le_at_checked(&mut self, value: u32, offset: usize) -> Option<usize>

Tries to put u32 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u32_le_at( &mut self, value: u32, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u32 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u32_be_at(&mut self, value: u32, offset: usize) -> usize

Puts u32 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u32_be_at_checked(&mut self, value: u32, offset: usize) -> Option<usize>

Tries to put u32 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u32_be_at( &mut self, value: u32, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u32 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u32_ne_at(&mut self, value: u32, offset: usize) -> usize

Puts u32 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u32_ne_at_checked(&mut self, value: u32, offset: usize) -> Option<usize>

Tries to put u32 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u32_ne_at( &mut self, value: u32, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u32 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u32_le(&mut self, value: u32) -> usize

Puts u32 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u32_le_checked(&mut self, value: u32) -> Option<usize>

Tries to put u32 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u32_le(&mut self, value: u32) -> Result<usize, TryPutError>

Tries to put u32 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u32_be(&mut self, value: u32) -> usize

Puts a u32 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u32_be_checked(&mut self, value: u32) -> Option<usize>

Tries to put u32 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u32_be(&mut self, value: u32) -> Result<usize, TryPutError>

Tries to put u32 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u32_ne(&mut self, value: u32) -> usize

Puts u32 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u32_ne_checked(&mut self, value: u32) -> Option<usize>

Tries to put u32 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u32_ne(&mut self, value: u32) -> Result<usize, TryPutError>

Tries to put u32 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u64_le_at(&mut self, value: u64, offset: usize) -> usize

Puts a u64 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u64_le_at_checked(&mut self, value: u64, offset: usize) -> Option<usize>

Tries to put u64 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u64_le_at( &mut self, value: u64, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u64 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u64_be_at(&mut self, value: u64, offset: usize) -> usize

Puts u64 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u64_be_at_checked(&mut self, value: u64, offset: usize) -> Option<usize>

Tries to put u64 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u64_be_at( &mut self, value: u64, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u64 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u64_ne_at(&mut self, value: u64, offset: usize) -> usize

Puts u64 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u64_ne_at_checked(&mut self, value: u64, offset: usize) -> Option<usize>

Tries to put u64 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u64_ne_at( &mut self, value: u64, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u64 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u64_le(&mut self, value: u64) -> usize

Puts u64 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u64_le_checked(&mut self, value: u64) -> Option<usize>

Tries to put u64 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u64_le(&mut self, value: u64) -> Result<usize, TryPutError>

Tries to put u64 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u64_be(&mut self, value: u64) -> usize

Puts a u64 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u64_be_checked(&mut self, value: u64) -> Option<usize>

Tries to put u64 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u64_be(&mut self, value: u64) -> Result<usize, TryPutError>

Tries to put u64 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u64_ne(&mut self, value: u64) -> usize

Puts u64 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u64_ne_checked(&mut self, value: u64) -> Option<usize>

Tries to put u64 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u64_ne(&mut self, value: u64) -> Result<usize, TryPutError>

Tries to put u64 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u128_le_at(&mut self, value: u128, offset: usize) -> usize

Puts a u128 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u128_le_at_checked( &mut self, value: u128, offset: usize, ) -> Option<usize>

Tries to put u128 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u128_le_at( &mut self, value: u128, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u128 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u128_be_at(&mut self, value: u128, offset: usize) -> usize

Puts u128 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u128_be_at_checked( &mut self, value: u128, offset: usize, ) -> Option<usize>

Tries to put u128 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u128_be_at( &mut self, value: u128, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u128 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u128_ne_at(&mut self, value: u128, offset: usize) -> usize

Puts u128 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u128_ne_at_checked( &mut self, value: u128, offset: usize, ) -> Option<usize>

Tries to put u128 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_u128_ne_at( &mut self, value: u128, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put u128 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_u128_le(&mut self, value: u128) -> usize

Puts u128 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u128_le_checked(&mut self, value: u128) -> Option<usize>

Tries to put u128 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u128_le(&mut self, value: u128) -> Result<usize, TryPutError>

Tries to put u128 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u128_be(&mut self, value: u128) -> usize

Puts a u128 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u128_be_checked(&mut self, value: u128) -> Option<usize>

Tries to put u128 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u128_be(&mut self, value: u128) -> Result<usize, TryPutError>

Tries to put u128 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u128_ne(&mut self, value: u128) -> usize

Puts u128 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_u128_ne_checked(&mut self, value: u128) -> Option<usize>

Tries to put u128 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_u128_ne(&mut self, value: u128) -> Result<usize, TryPutError>

Tries to put u128 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i16_le_at(&mut self, value: i16, offset: usize) -> usize

Puts a i16 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i16_le_at_checked(&mut self, value: i16, offset: usize) -> Option<usize>

Tries to put i16 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i16_le_at( &mut self, value: i16, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i16 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i16_be_at(&mut self, value: i16, offset: usize) -> usize

Puts i16 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i16_be_at_checked(&mut self, value: i16, offset: usize) -> Option<usize>

Tries to put i16 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i16_be_at( &mut self, value: i16, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i16 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i16_ne_at(&mut self, value: i16, offset: usize) -> usize

Puts i16 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i16_ne_at_checked(&mut self, value: i16, offset: usize) -> Option<usize>

Tries to put i16 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i16_ne_at( &mut self, value: i16, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i16 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i16_le(&mut self, value: i16) -> usize

Puts i16 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i16_le_checked(&mut self, value: i16) -> Option<usize>

Tries to put i16 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i16_le(&mut self, value: i16) -> Result<usize, TryPutError>

Tries to put i16 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i16_be(&mut self, value: i16) -> usize

Puts a i16 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i16_be_checked(&mut self, value: i16) -> Option<usize>

Tries to put i16 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i16_be(&mut self, value: i16) -> Result<usize, TryPutError>

Tries to put i16 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i16_ne(&mut self, value: i16) -> usize

Puts i16 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i16_ne_checked(&mut self, value: i16) -> Option<usize>

Tries to put i16 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i16_ne(&mut self, value: i16) -> Result<usize, TryPutError>

Tries to put i16 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i32_le_at(&mut self, value: i32, offset: usize) -> usize

Puts a i32 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i32_le_at_checked(&mut self, value: i32, offset: usize) -> Option<usize>

Tries to put i32 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i32_le_at( &mut self, value: i32, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i32 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i32_be_at(&mut self, value: i32, offset: usize) -> usize

Puts i32 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i32_be_at_checked(&mut self, value: i32, offset: usize) -> Option<usize>

Tries to put i32 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i32_be_at( &mut self, value: i32, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i32 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i32_ne_at(&mut self, value: i32, offset: usize) -> usize

Puts i32 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i32_ne_at_checked(&mut self, value: i32, offset: usize) -> Option<usize>

Tries to put i32 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i32_ne_at( &mut self, value: i32, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i32 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i32_le(&mut self, value: i32) -> usize

Puts i32 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i32_le_checked(&mut self, value: i32) -> Option<usize>

Tries to put i32 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i32_le(&mut self, value: i32) -> Result<usize, TryPutError>

Tries to put i32 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i32_be(&mut self, value: i32) -> usize

Puts a i32 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i32_be_checked(&mut self, value: i32) -> Option<usize>

Tries to put i32 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i32_be(&mut self, value: i32) -> Result<usize, TryPutError>

Tries to put i32 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i32_ne(&mut self, value: i32) -> usize

Puts i32 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i32_ne_checked(&mut self, value: i32) -> Option<usize>

Tries to put i32 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i32_ne(&mut self, value: i32) -> Result<usize, TryPutError>

Tries to put i32 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i64_le_at(&mut self, value: i64, offset: usize) -> usize

Puts a i64 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i64_le_at_checked(&mut self, value: i64, offset: usize) -> Option<usize>

Tries to put i64 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i64_le_at( &mut self, value: i64, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i64 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i64_be_at(&mut self, value: i64, offset: usize) -> usize

Puts i64 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i64_be_at_checked(&mut self, value: i64, offset: usize) -> Option<usize>

Tries to put i64 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i64_be_at( &mut self, value: i64, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i64 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i64_ne_at(&mut self, value: i64, offset: usize) -> usize

Puts i64 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i64_ne_at_checked(&mut self, value: i64, offset: usize) -> Option<usize>

Tries to put i64 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i64_ne_at( &mut self, value: i64, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i64 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i64_le(&mut self, value: i64) -> usize

Puts i64 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i64_le_checked(&mut self, value: i64) -> Option<usize>

Tries to put i64 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i64_le(&mut self, value: i64) -> Result<usize, TryPutError>

Tries to put i64 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i64_be(&mut self, value: i64) -> usize

Puts a i64 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i64_be_checked(&mut self, value: i64) -> Option<usize>

Tries to put i64 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i64_be(&mut self, value: i64) -> Result<usize, TryPutError>

Tries to put i64 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i64_ne(&mut self, value: i64) -> usize

Puts i64 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i64_ne_checked(&mut self, value: i64) -> Option<usize>

Tries to put i64 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i64_ne(&mut self, value: i64) -> Result<usize, TryPutError>

Tries to put i64 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i128_le_at(&mut self, value: i128, offset: usize) -> usize

Puts a i128 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i128_le_at_checked( &mut self, value: i128, offset: usize, ) -> Option<usize>

Tries to put i128 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i128_le_at( &mut self, value: i128, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i128 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i128_be_at(&mut self, value: i128, offset: usize) -> usize

Puts i128 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i128_be_at_checked( &mut self, value: i128, offset: usize, ) -> Option<usize>

Tries to put i128 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i128_be_at( &mut self, value: i128, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i128 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i128_ne_at(&mut self, value: i128, offset: usize) -> usize

Puts i128 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i128_ne_at_checked( &mut self, value: i128, offset: usize, ) -> Option<usize>

Tries to put i128 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_i128_ne_at( &mut self, value: i128, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put i128 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_i128_le(&mut self, value: i128) -> usize

Puts i128 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i128_le_checked(&mut self, value: i128) -> Option<usize>

Tries to put i128 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i128_le(&mut self, value: i128) -> Result<usize, TryPutError>

Tries to put i128 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i128_be(&mut self, value: i128) -> usize

Puts a i128 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i128_be_checked(&mut self, value: i128) -> Option<usize>

Tries to put i128 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i128_be(&mut self, value: i128) -> Result<usize, TryPutError>

Tries to put i128 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i128_ne(&mut self, value: i128) -> usize

Puts i128 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_i128_ne_checked(&mut self, value: i128) -> Option<usize>

Tries to put i128 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_i128_ne(&mut self, value: i128) -> Result<usize, TryPutError>

Tries to put i128 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f32_le_at(&mut self, value: f32, offset: usize) -> usize

Puts a f32 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f32_le_at_checked(&mut self, value: f32, offset: usize) -> Option<usize>

Tries to put f32 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_f32_le_at( &mut self, value: f32, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put f32 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f32_be_at(&mut self, value: f32, offset: usize) -> usize

Puts f32 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f32_be_at_checked(&mut self, value: f32, offset: usize) -> Option<usize>

Tries to put f32 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_f32_be_at( &mut self, value: f32, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put f32 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f32_ne_at(&mut self, value: f32, offset: usize) -> usize

Puts f32 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f32_ne_at_checked(&mut self, value: f32, offset: usize) -> Option<usize>

Tries to put f32 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_f32_ne_at( &mut self, value: f32, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put f32 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f32_le(&mut self, value: f32) -> usize

Puts f32 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f32_le_checked(&mut self, value: f32) -> Option<usize>

Tries to put f32 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_f32_le(&mut self, value: f32) -> Result<usize, TryPutError>

Tries to put f32 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f32_be(&mut self, value: f32) -> usize

Puts a f32 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f32_be_checked(&mut self, value: f32) -> Option<usize>

Tries to put f32 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_f32_be(&mut self, value: f32) -> Result<usize, TryPutError>

Tries to put f32 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f32_ne(&mut self, value: f32) -> usize

Puts f32 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f32_ne_checked(&mut self, value: f32) -> Option<usize>

Tries to put f32 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_f32_ne(&mut self, value: f32) -> Result<usize, TryPutError>

Tries to put f32 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f64_le_at(&mut self, value: f64, offset: usize) -> usize

Puts a f64 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f64_le_at_checked(&mut self, value: f64, offset: usize) -> Option<usize>

Tries to put f64 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_f64_le_at( &mut self, value: f64, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put f64 value in little-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f64_be_at(&mut self, value: f64, offset: usize) -> usize

Puts f64 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f64_be_at_checked(&mut self, value: f64, offset: usize) -> Option<usize>

Tries to put f64 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_f64_be_at( &mut self, value: f64, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put f64 value in big-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f64_ne_at(&mut self, value: f64, offset: usize) -> usize

Puts f64 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f64_ne_at_checked(&mut self, value: f64, offset: usize) -> Option<usize>

Tries to put f64 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn try_put_f64_ne_at( &mut self, value: f64, offset: usize, ) -> Result<usize, TryPutAtError>

Tries to put f64 value in native-endian byte order to the buffer at the specified offset without advancing the internal cursor.

fn put_f64_le(&mut self, value: f64) -> usize

Puts f64 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f64_le_checked(&mut self, value: f64) -> Option<usize>

Tries to put f64 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_f64_le(&mut self, value: f64) -> Result<usize, TryPutError>

Tries to put f64 value in little-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f64_be(&mut self, value: f64) -> usize

Puts a f64 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f64_be_checked(&mut self, value: f64) -> Option<usize>

Tries to put f64 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_f64_be(&mut self, value: f64) -> Result<usize, TryPutError>

Tries to put f64 value in big-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f64_ne(&mut self, value: f64) -> usize

Puts f64 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn put_f64_ne_checked(&mut self, value: f64) -> Option<usize>

Tries to put f64 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn try_put_f64_ne(&mut self, value: f64) -> Result<usize, TryPutError>

Tries to put f64 value in native-endian byte order to the beginning of the buffer without advancing the internal cursor.

fn write_slice(&mut self, slice: &[u8]) -> usize

Writes slice of bytes to the beginning of the buffer and advances the internal cursor.

fn write_slice_checked(&mut self, slice: &[u8]) -> Option<usize>

Tries to write slice of bytes to the beginning of the buffer and advance the internal cursor.

fn try_write_slice(&mut self, slice: &[u8]) -> Result<usize, TryWriteError>

Tries to write slice of bytes to the beginning of the buffer and advance the internal cursor.

fn write_u8(&mut self, value: u8) -> usize

Writes u8 value to the beginning of the buffer without advancing the internal cursor.

fn write_u8_checked(&mut self, value: u8) -> Option<usize>

Tries to write u8 value to the beginning of the buffer without advancing the internal cursor.

fn try_write_u8(&mut self, value: u8) -> Result<usize, TryWriteError>

Tries to write u8 value to the beginning of the buffer without advancing the internal cursor.

fn write_i8(&mut self, value: i8) -> usize

Writes i8 value to the beginning of the buffer without advancing the internal cursor.

fn write_i8_checked(&mut self, value: i8) -> Option<usize>

Tries to write i8 value to the beginning of the buffer without advancing the internal cursor.

fn try_write_i8(&mut self, value: i8) -> Result<usize, TryWriteError>

Tries to write i8 value to the beginning of the buffer without advancing the internal cursor.

fn write_u16_le(&mut self, value: u16) -> usize

Writes u16 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u16_le_checked(&mut self, value: u16) -> Option<usize>

Tries to write u16 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u16_le(&mut self, value: u16) -> Result<usize, TryWriteError>

Tries to write u16 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u16_be(&mut self, value: u16) -> usize

Writes u16 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u16_be_checked(&mut self, value: u16) -> Option<usize>

Tries to write u16 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u16_be(&mut self, value: u16) -> Result<usize, TryWriteError>

Tries to write u16 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u16_ne(&mut self, value: u16) -> usize

Writes u16 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u16_ne_checked(&mut self, value: u16) -> Option<usize>

Tries to write u16 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u16_ne(&mut self, value: u16) -> Result<usize, TryWriteError>

Tries to write u16 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u32_le(&mut self, value: u32) -> usize

Writes u32 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u32_le_checked(&mut self, value: u32) -> Option<usize>

Tries to write u32 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u32_le(&mut self, value: u32) -> Result<usize, TryWriteError>

Tries to write u32 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u32_be(&mut self, value: u32) -> usize

Writes u32 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u32_be_checked(&mut self, value: u32) -> Option<usize>

Tries to write u32 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u32_be(&mut self, value: u32) -> Result<usize, TryWriteError>

Tries to write u32 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u32_ne(&mut self, value: u32) -> usize

Writes u32 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u32_ne_checked(&mut self, value: u32) -> Option<usize>

Tries to write u32 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u32_ne(&mut self, value: u32) -> Result<usize, TryWriteError>

Tries to write u32 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u64_le(&mut self, value: u64) -> usize

Writes u64 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u64_le_checked(&mut self, value: u64) -> Option<usize>

Tries to write u64 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u64_le(&mut self, value: u64) -> Result<usize, TryWriteError>

Tries to write u64 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u64_be(&mut self, value: u64) -> usize

Writes u64 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u64_be_checked(&mut self, value: u64) -> Option<usize>

Tries to write u64 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u64_be(&mut self, value: u64) -> Result<usize, TryWriteError>

Tries to write u64 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u64_ne(&mut self, value: u64) -> usize

Writes u64 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u64_ne_checked(&mut self, value: u64) -> Option<usize>

Tries to write u64 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u64_ne(&mut self, value: u64) -> Result<usize, TryWriteError>

Tries to write u64 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u128_le(&mut self, value: u128) -> usize

Writes u128 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u128_le_checked(&mut self, value: u128) -> Option<usize>

Tries to write u128 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u128_le(&mut self, value: u128) -> Result<usize, TryWriteError>

Tries to write u128 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u128_be(&mut self, value: u128) -> usize

Writes u128 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u128_be_checked(&mut self, value: u128) -> Option<usize>

Tries to write u128 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u128_be(&mut self, value: u128) -> Result<usize, TryWriteError>

Tries to write u128 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u128_ne(&mut self, value: u128) -> usize

Writes u128 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_u128_ne_checked(&mut self, value: u128) -> Option<usize>

Tries to write u128 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_u128_ne(&mut self, value: u128) -> Result<usize, TryWriteError>

Tries to write u128 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i16_le(&mut self, value: i16) -> usize

Writes i16 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i16_le_checked(&mut self, value: i16) -> Option<usize>

Tries to write i16 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i16_le(&mut self, value: i16) -> Result<usize, TryWriteError>

Tries to write i16 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i16_be(&mut self, value: i16) -> usize

Writes i16 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i16_be_checked(&mut self, value: i16) -> Option<usize>

Tries to write i16 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i16_be(&mut self, value: i16) -> Result<usize, TryWriteError>

Tries to write i16 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i16_ne(&mut self, value: i16) -> usize

Writes i16 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i16_ne_checked(&mut self, value: i16) -> Option<usize>

Tries to write i16 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i16_ne(&mut self, value: i16) -> Result<usize, TryWriteError>

Tries to write i16 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i32_le(&mut self, value: i32) -> usize

Writes i32 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i32_le_checked(&mut self, value: i32) -> Option<usize>

Tries to write i32 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i32_le(&mut self, value: i32) -> Result<usize, TryWriteError>

Tries to write i32 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i32_be(&mut self, value: i32) -> usize

Writes i32 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i32_be_checked(&mut self, value: i32) -> Option<usize>

Tries to write i32 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i32_be(&mut self, value: i32) -> Result<usize, TryWriteError>

Tries to write i32 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i32_ne(&mut self, value: i32) -> usize

Writes i32 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i32_ne_checked(&mut self, value: i32) -> Option<usize>

Tries to write i32 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i32_ne(&mut self, value: i32) -> Result<usize, TryWriteError>

Tries to write i32 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i64_le(&mut self, value: i64) -> usize

Writes i64 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i64_le_checked(&mut self, value: i64) -> Option<usize>

Tries to write i64 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i64_le(&mut self, value: i64) -> Result<usize, TryWriteError>

Tries to write i64 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i64_be(&mut self, value: i64) -> usize

Writes i64 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i64_be_checked(&mut self, value: i64) -> Option<usize>

Tries to write i64 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i64_be(&mut self, value: i64) -> Result<usize, TryWriteError>

Tries to write i64 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i64_ne(&mut self, value: i64) -> usize

Writes i64 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i64_ne_checked(&mut self, value: i64) -> Option<usize>

Tries to write i64 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i64_ne(&mut self, value: i64) -> Result<usize, TryWriteError>

Tries to write i64 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i128_le(&mut self, value: i128) -> usize

Writes i128 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i128_le_checked(&mut self, value: i128) -> Option<usize>

Tries to write i128 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i128_le(&mut self, value: i128) -> Result<usize, TryWriteError>

Tries to write i128 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i128_be(&mut self, value: i128) -> usize

Writes i128 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i128_be_checked(&mut self, value: i128) -> Option<usize>

Tries to write i128 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i128_be(&mut self, value: i128) -> Result<usize, TryWriteError>

Tries to write i128 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i128_ne(&mut self, value: i128) -> usize

Writes i128 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_i128_ne_checked(&mut self, value: i128) -> Option<usize>

Tries to write i128 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_i128_ne(&mut self, value: i128) -> Result<usize, TryWriteError>

Tries to write i128 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f32_le(&mut self, value: f32) -> usize

Writes f32 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f32_le_checked(&mut self, value: f32) -> Option<usize>

Tries to write f32 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_f32_le(&mut self, value: f32) -> Result<usize, TryWriteError>

Tries to write f32 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f32_be(&mut self, value: f32) -> usize

Writes f32 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f32_be_checked(&mut self, value: f32) -> Option<usize>

Tries to write f32 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_f32_be(&mut self, value: f32) -> Result<usize, TryWriteError>

Tries to write f32 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f32_ne(&mut self, value: f32) -> usize

Writes f32 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f32_ne_checked(&mut self, value: f32) -> Option<usize>

Tries to write f32 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_f32_ne(&mut self, value: f32) -> Result<usize, TryWriteError>

Tries to write f32 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f64_le(&mut self, value: f64) -> usize

Writes f64 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f64_le_checked(&mut self, value: f64) -> Option<usize>

Tries to write f64 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_f64_le(&mut self, value: f64) -> Result<usize, TryWriteError>

Tries to write f64 value in little-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f64_be(&mut self, value: f64) -> usize

Writes f64 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f64_be_checked(&mut self, value: f64) -> Option<usize>

Tries to write f64 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_f64_be(&mut self, value: f64) -> Result<usize, TryWriteError>

Tries to write f64 value in big-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f64_ne(&mut self, value: f64) -> usize

Writes f64 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn write_f64_ne_checked(&mut self, value: f64) -> Option<usize>

Tries to write f64 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn try_write_f64_ne(&mut self, value: f64) -> Result<usize, TryWriteError>

Tries to write f64 value in native-endian byte order to the beginning of the buffer, advancing the internal cursor.

fn buffer_mut_from(&mut self, offset: usize) -> &mut [u8]

Returns a remaining_mut slice of the buffer starting from the specified offset.

fn buffer_mut_from_checked(&mut self, offset: usize) -> Option<&mut [u8]>

Returns a remaining_mut slice of the buffer starting from the specified offset.

impl<B: Clone + ?Sized> Clone for WriteBuf<B>

fn clone(&self) -> WriteBuf<B>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Debug + ?Sized> Debug for WriteBuf<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: ?Sized> Deref for WriteBuf<B>

type Target = B

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<B: ?Sized> DerefMut for WriteBuf<B>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<B> From<B> for WriteBuf<B>

fn from(value: B) -> Self

Converts to this type from the input type.

impl<B: Hash + ?Sized> Hash for WriteBuf<B>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<B: PartialEq + ?Sized> PartialEq for WriteBuf<B>

fn eq(&self, other: &WriteBuf<B>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<B: Copy + ?Sized> Copy for WriteBuf<B>

impl<B: Eq + ?Sized> Eq for WriteBuf<B>

impl<B: ?Sized> StructuralPartialEq for WriteBuf<B>