Trait BufWrite 

pub trait BufWrite: BufRead {
    // Required methods
    fn remaining_mut(&mut self) -> &mut [u8] ;
    fn resize(&mut self, nbytes: usize) -> usize;

    // Provided methods
    fn push<V: AsRef<[u8]>>(&mut self, value: V) -> JResult<usize> { ... }
    fn push_bytes(&mut self, value: &[u8]) -> JResult<usize> { ... }
    fn push_array<const N: usize>(&mut self, value: [u8; N]) -> JResult<usize> { ... }
    fn push_byteorder_array<const N: usize>(
        &mut self,
        value: [u8; N],
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_char(&mut self, value: char) -> JResult<usize> { ... }
    fn push_bool(&mut self, value: bool) -> JResult<usize> { ... }
    fn push_u8(&mut self, value: u8) -> JResult<usize> { ... }
    fn push_be_u8(&mut self, value: u8) -> JResult<usize> { ... }
    fn push_le_u8(&mut self, value: u8) -> JResult<usize> { ... }
    fn push_ne_u8(&mut self, value: u8) -> JResult<usize> { ... }
    fn push_byteorder_u8(
        &mut self,
        value: u8,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_i8(&mut self, value: i8) -> JResult<usize> { ... }
    fn push_be_i8(&mut self, value: i8) -> JResult<usize> { ... }
    fn push_le_i8(&mut self, value: i8) -> JResult<usize> { ... }
    fn push_ne_i8(&mut self, value: i8) -> JResult<usize> { ... }
    fn push_byteorder_i8(
        &mut self,
        value: i8,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_u16(&mut self, value: u16) -> JResult<usize> { ... }
    fn push_be_u16(&mut self, value: u16) -> JResult<usize> { ... }
    fn push_le_u16(&mut self, value: u16) -> JResult<usize> { ... }
    fn push_ne_u16(&mut self, value: u16) -> JResult<usize> { ... }
    fn push_byteorder_u16(
        &mut self,
        value: u16,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_i16(&mut self, value: i16) -> JResult<usize> { ... }
    fn push_be_i16(&mut self, value: i16) -> JResult<usize> { ... }
    fn push_le_i16(&mut self, value: i16) -> JResult<usize> { ... }
    fn push_ne_i16(&mut self, value: i16) -> JResult<usize> { ... }
    fn push_byteorder_i16(
        &mut self,
        value: i16,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_u24(&mut self, value: u32) -> JResult<usize> { ... }
    fn push_be_u24(&mut self, value: u32) -> JResult<usize> { ... }
    fn push_le_u24(&mut self, value: u32) -> JResult<usize> { ... }
    fn push_ne_u24(&mut self, value: u32) -> JResult<usize> { ... }
    fn push_byteorder_u24(
        &mut self,
        value: u32,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_u32(&mut self, value: u32) -> JResult<usize> { ... }
    fn push_be_u32(&mut self, value: u32) -> JResult<usize> { ... }
    fn push_le_u32(&mut self, value: u32) -> JResult<usize> { ... }
    fn push_ne_u32(&mut self, value: u32) -> JResult<usize> { ... }
    fn push_byteorder_u32(
        &mut self,
        value: u32,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_i32(&mut self, value: i32) -> JResult<usize> { ... }
    fn push_be_i32(&mut self, value: i32) -> JResult<usize> { ... }
    fn push_le_i32(&mut self, value: i32) -> JResult<usize> { ... }
    fn push_ne_i32(&mut self, value: i32) -> JResult<usize> { ... }
    fn push_byteorder_i32(
        &mut self,
        value: i32,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_u64(&mut self, value: u64) -> JResult<usize> { ... }
    fn push_be_u64(&mut self, value: u64) -> JResult<usize> { ... }
    fn push_le_u64(&mut self, value: u64) -> JResult<usize> { ... }
    fn push_ne_u64(&mut self, value: u64) -> JResult<usize> { ... }
    fn push_byteorder_u64(
        &mut self,
        value: u64,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_i64(&mut self, value: i64) -> JResult<usize> { ... }
    fn push_be_i64(&mut self, value: i64) -> JResult<usize> { ... }
    fn push_le_i64(&mut self, value: i64) -> JResult<usize> { ... }
    fn push_ne_i64(&mut self, value: i64) -> JResult<usize> { ... }
    fn push_byteorder_i64(
        &mut self,
        value: i64,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_u128(&mut self, value: u128) -> JResult<usize> { ... }
    fn push_be_u128(&mut self, value: u128) -> JResult<usize> { ... }
    fn push_le_u128(&mut self, value: u128) -> JResult<usize> { ... }
    fn push_ne_u128(&mut self, value: u128) -> JResult<usize> { ... }
    fn push_byteorder_u128(
        &mut self,
        value: u128,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_i128(&mut self, value: i128) -> JResult<usize> { ... }
    fn push_be_i128(&mut self, value: i128) -> JResult<usize> { ... }
    fn push_le_i128(&mut self, value: i128) -> JResult<usize> { ... }
    fn push_ne_i128(&mut self, value: i128) -> JResult<usize> { ... }
    fn push_byteorder_i128(
        &mut self,
        value: i128,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_usize(&mut self, value: usize) -> JResult<usize> { ... }
    fn push_be_usize(&mut self, value: usize) -> JResult<usize> { ... }
    fn push_le_usize(&mut self, value: usize) -> JResult<usize> { ... }
    fn push_ne_usize(&mut self, value: usize) -> JResult<usize> { ... }
    fn push_byteorder_usize(
        &mut self,
        value: usize,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_isize(&mut self, value: isize) -> JResult<usize> { ... }
    fn push_be_isize(&mut self, value: isize) -> JResult<usize> { ... }
    fn push_le_isize(&mut self, value: isize) -> JResult<usize> { ... }
    fn push_ne_isize(&mut self, value: isize) -> JResult<usize> { ... }
    fn push_byteorder_isize(
        &mut self,
        value: isize,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_uint(&mut self, value: u64, nbytes: usize) -> JResult<usize> { ... }
    fn push_be_uint(&mut self, value: u64, nbytes: usize) -> JResult<usize> { ... }
    fn push_le_uint(&mut self, value: u64, nbytes: usize) -> JResult<usize> { ... }
    fn push_ne_uint(&mut self, value: u64, nbytes: usize) -> JResult<usize> { ... }
    fn push_byteorder_uint(
        &mut self,
        value: u64,
        nbytes: usize,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_int(&mut self, value: i64, nbytes: usize) -> JResult<usize> { ... }
    fn push_be_int(&mut self, value: i64, nbytes: usize) -> JResult<usize> { ... }
    fn push_le_int(&mut self, value: i64, nbytes: usize) -> JResult<usize> { ... }
    fn push_ne_int(&mut self, value: i64, nbytes: usize) -> JResult<usize> { ... }
    fn push_byteorder_int(
        &mut self,
        value: i64,
        nbytes: usize,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_f32(&mut self, value: f32) -> JResult<usize> { ... }
    fn push_be_f32(&mut self, value: f32) -> JResult<usize> { ... }
    fn push_le_f32(&mut self, value: f32) -> JResult<usize> { ... }
    fn push_ne_f32(&mut self, value: f32) -> JResult<usize> { ... }
    fn push_byteorder_f32(
        &mut self,
        value: f32,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
    fn push_f64(&mut self, value: f64) -> JResult<usize> { ... }
    fn push_be_f64(&mut self, value: f64) -> JResult<usize> { ... }
    fn push_le_f64(&mut self, value: f64) -> JResult<usize> { ... }
    fn push_ne_f64(&mut self, value: f64) -> JResult<usize> { ... }
    fn push_byteorder_f64(
        &mut self,
        value: f64,
        byteorder: ByteOrder,
    ) -> JResult<usize> { ... }
}

Required Methods

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

Returns the n-bytes between the current position and the end of the buffer.

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

Update memory size.

Provided Methods

fn push<V: AsRef<[u8]>>(&mut self, value: V) -> JResult<usize>

Writes AsRef<[u8]> to self, eg: &u8/&str/String/array/vec, etc.

fn push_bytes(&mut self, value: &[u8]) -> JResult<usize>

Writes bytes(&u8) to self.

fn push_array<const N: usize>(&mut self, value: [u8; N]) -> JResult<usize>

Writes array data to self.

fn push_byteorder_array<const N: usize>( &mut self, value: [u8; N], byteorder: ByteOrder, ) -> JResult<usize>

Writes array data to self.

fn push_char(&mut self, value: char) -> JResult<usize>

Writes a char to self.

fn push_bool(&mut self, value: bool) -> JResult<usize>

Writes a bool to self.

fn push_u8(&mut self, value: u8) -> JResult<usize>

Writes an unsigned 8 bit integer to self.

fn push_be_u8(&mut self, value: u8) -> JResult<usize>

Writes an unsigned 8 bit integer to self, exactly like the [push_u8] function.

fn push_le_u8(&mut self, value: u8) -> JResult<usize>

Writes an unsigned 8 bit integer to self, exactly like the [push_u8] function.

fn push_ne_u8(&mut self, value: u8) -> JResult<usize>

Writes an unsigned 8 bit integer to self, exactly like the [push_u8] function.

fn push_byteorder_u8( &mut self, value: u8, byteorder: ByteOrder, ) -> JResult<usize>

Writes an unsigned 8 bit integer to self, exactly like the [push_u8] function.

fn push_i8(&mut self, value: i8) -> JResult<usize>

Writes a signed 8 bit integer to self.

fn push_be_i8(&mut self, value: i8) -> JResult<usize>

Writes a signed 8 bit integer to self, exactly like the [push_i8] function.

fn push_le_i8(&mut self, value: i8) -> JResult<usize>

Writes a signed 8 bit integer to self, exactly like the [push_i8] function.

fn push_ne_i8(&mut self, value: i8) -> JResult<usize>

Writes a signed 8 bit integer to self, exactly like the [push_i8] function.

fn push_byteorder_i8( &mut self, value: i8, byteorder: ByteOrder, ) -> JResult<usize>

Writes a signed 8 bit integer to self.

fn push_u16(&mut self, value: u16) -> JResult<usize>

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

fn push_be_u16(&mut self, value: u16) -> JResult<usize>

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

fn push_le_u16(&mut self, value: u16) -> JResult<usize>

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

fn push_ne_u16(&mut self, value: u16) -> JResult<usize>

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

fn push_byteorder_u16( &mut self, value: u16, byteorder: ByteOrder, ) -> JResult<usize>

Writes an unsigned 16 bit integer to self.

fn push_i16(&mut self, value: i16) -> JResult<usize>

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

fn push_be_i16(&mut self, value: i16) -> JResult<usize>

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

fn push_le_i16(&mut self, value: i16) -> JResult<usize>

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

fn push_ne_i16(&mut self, value: i16) -> JResult<usize>

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

fn push_byteorder_i16( &mut self, value: i16, byteorder: ByteOrder, ) -> JResult<usize>

Writes a signed 16 bit integer to self.

fn push_u24(&mut self, value: u32) -> JResult<usize>

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

fn push_be_u24(&mut self, value: u32) -> JResult<usize>

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

fn push_le_u24(&mut self, value: u32) -> JResult<usize>

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

fn push_ne_u24(&mut self, value: u32) -> JResult<usize>

Writes an unsigned 24 bit integer to self in native-endian byte order.

fn push_byteorder_u24( &mut self, value: u32, byteorder: ByteOrder, ) -> JResult<usize>

Writes an unsigned 24 bit integer to self.

fn push_u32(&mut self, value: u32) -> JResult<usize>

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

fn push_be_u32(&mut self, value: u32) -> JResult<usize>

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

fn push_le_u32(&mut self, value: u32) -> JResult<usize>

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

fn push_ne_u32(&mut self, value: u32) -> JResult<usize>

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

fn push_byteorder_u32( &mut self, value: u32, byteorder: ByteOrder, ) -> JResult<usize>

Writes an unsigned 32 bit integer to self.

fn push_i32(&mut self, value: i32) -> JResult<usize>

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

fn push_be_i32(&mut self, value: i32) -> JResult<usize>

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

fn push_le_i32(&mut self, value: i32) -> JResult<usize>

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

fn push_ne_i32(&mut self, value: i32) -> JResult<usize>

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

fn push_byteorder_i32( &mut self, value: i32, byteorder: ByteOrder, ) -> JResult<usize>

Writes a signed 32 bit integer to self.

fn push_u64(&mut self, value: u64) -> JResult<usize>

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

fn push_be_u64(&mut self, value: u64) -> JResult<usize>

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

fn push_le_u64(&mut self, value: u64) -> JResult<usize>

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

fn push_ne_u64(&mut self, value: u64) -> JResult<usize>

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

fn push_byteorder_u64( &mut self, value: u64, byteorder: ByteOrder, ) -> JResult<usize>

Writes an unsigned 64 bit integer to self.

fn push_i64(&mut self, value: i64) -> JResult<usize>

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

fn push_be_i64(&mut self, value: i64) -> JResult<usize>

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

fn push_le_i64(&mut self, value: i64) -> JResult<usize>

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

fn push_ne_i64(&mut self, value: i64) -> JResult<usize>

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

fn push_byteorder_i64( &mut self, value: i64, byteorder: ByteOrder, ) -> JResult<usize>

Writes a signed 64 bit integer to self.

fn push_u128(&mut self, value: u128) -> JResult<usize>

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

fn push_be_u128(&mut self, value: u128) -> JResult<usize>

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

fn push_le_u128(&mut self, value: u128) -> JResult<usize>

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

fn push_ne_u128(&mut self, value: u128) -> JResult<usize>

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

fn push_byteorder_u128( &mut self, value: u128, byteorder: ByteOrder, ) -> JResult<usize>

Writes an unsigned 128 bit integer to self.

fn push_i128(&mut self, value: i128) -> JResult<usize>

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

fn push_be_i128(&mut self, value: i128) -> JResult<usize>

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

fn push_le_i128(&mut self, value: i128) -> JResult<usize>

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

fn push_ne_i128(&mut self, value: i128) -> JResult<usize>

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

fn push_byteorder_i128( &mut self, value: i128, byteorder: ByteOrder, ) -> JResult<usize>

Writes a signed 128 bit integer to self.

fn push_usize(&mut self, value: usize) -> JResult<usize>

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

fn push_be_usize(&mut self, value: usize) -> JResult<usize>

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

fn push_le_usize(&mut self, value: usize) -> JResult<usize>

Writes an unsigned usize integer to self in little-endian byte order.

fn push_ne_usize(&mut self, value: usize) -> JResult<usize>

Writes an unsigned usize integer to self in native-endian byte order.

fn push_byteorder_usize( &mut self, value: usize, byteorder: ByteOrder, ) -> JResult<usize>

Writes an unsigned usize integer to self.

fn push_isize(&mut self, value: isize) -> JResult<usize>

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

fn push_be_isize(&mut self, value: isize) -> JResult<usize>

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

fn push_le_isize(&mut self, value: isize) -> JResult<usize>

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

fn push_ne_isize(&mut self, value: isize) -> JResult<usize>

Writes a signed usize integer to self in native-endian byte order.

fn push_byteorder_isize( &mut self, value: isize, byteorder: ByteOrder, ) -> JResult<usize>

Writes a signed usize integer to self.

fn push_uint(&mut self, value: u64, nbytes: usize) -> JResult<usize>

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

fn push_be_uint(&mut self, value: u64, nbytes: usize) -> JResult<usize>

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

fn push_le_uint(&mut self, value: u64, nbytes: usize) -> JResult<usize>

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

fn push_ne_uint(&mut self, value: u64, nbytes: usize) -> JResult<usize>

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

fn push_byteorder_uint( &mut self, value: u64, nbytes: usize, byteorder: ByteOrder, ) -> JResult<usize>

Writes an unsigned n-byte integer to self.

fn push_int(&mut self, value: i64, nbytes: usize) -> JResult<usize>

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

fn push_be_int(&mut self, value: i64, nbytes: usize) -> JResult<usize>

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

fn push_le_int(&mut self, value: i64, nbytes: usize) -> JResult<usize>

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

fn push_ne_int(&mut self, value: i64, nbytes: usize) -> JResult<usize>

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

fn push_byteorder_int( &mut self, value: i64, nbytes: usize, byteorder: ByteOrder, ) -> JResult<usize>

Writes a signed n-byte integer to self.

fn push_f32(&mut self, value: f32) -> JResult<usize>

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

fn push_be_f32(&mut self, value: f32) -> JResult<usize>

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

fn push_le_f32(&mut self, value: f32) -> JResult<usize>

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

fn push_ne_f32(&mut self, value: f32) -> JResult<usize>

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

fn push_byteorder_f32( &mut self, value: f32, byteorder: ByteOrder, ) -> JResult<usize>

Writes an IEEE754 double-precision (4 bytes) floating point number to self.

fn push_f64(&mut self, value: f64) -> JResult<usize>

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

fn push_be_f64(&mut self, value: f64) -> JResult<usize>

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

fn push_le_f64(&mut self, value: f64) -> JResult<usize>

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

fn push_ne_f64(&mut self, value: f64) -> JResult<usize>

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

fn push_byteorder_f64( &mut self, value: f64, byteorder: ByteOrder, ) -> JResult<usize>

Writes an IEEE754 double-precision (8 bytes) floating point number to self.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl BufWrite for Buffer