Trait BytesWrite

pub trait BytesWrite {
    // Required methods
    fn as_mut(&mut self) -> &mut [u8] ;
    fn as_bytes(&self) -> Bytes<'_> ;
    fn remaining_mut(&mut self) -> &mut [u8] ;
    fn try_write(&mut self, slice: impl AsRef<[u8]>) -> Result<(), WriteError>;

    // Provided methods
    fn write(&mut self, slice: impl AsRef<[u8]>) { ... }
    fn try_write_u8(&mut self, num: u8) -> Result<(), WriteError> { ... }
    fn write_u8(&mut self, num: u8) { ... }
    fn try_write_u16(&mut self, num: u16) -> Result<(), WriteError> { ... }
    fn write_u16(&mut self, num: u16) { ... }
    fn try_write_u32(&mut self, num: u32) -> Result<(), WriteError> { ... }
    fn write_u32(&mut self, num: u32) { ... }
    fn try_write_u64(&mut self, num: u64) -> Result<(), WriteError> { ... }
    fn write_u64(&mut self, num: u64) { ... }
    fn try_write_u128(&mut self, num: u128) -> Result<(), WriteError> { ... }
    fn write_u128(&mut self, num: u128) { ... }
    fn try_write_i8(&mut self, num: i8) -> Result<(), WriteError> { ... }
    fn write_i8(&mut self, num: i8) { ... }
    fn try_write_i16(&mut self, num: i16) -> Result<(), WriteError> { ... }
    fn write_i16(&mut self, num: i16) { ... }
    fn try_write_i32(&mut self, num: i32) -> Result<(), WriteError> { ... }
    fn write_i32(&mut self, num: i32) { ... }
    fn try_write_i64(&mut self, num: i64) -> Result<(), WriteError> { ... }
    fn write_i64(&mut self, num: i64) { ... }
    fn try_write_i128(&mut self, num: i128) -> Result<(), WriteError> { ... }
    fn write_i128(&mut self, num: i128) { ... }
    fn try_write_f32(&mut self, num: f32) -> Result<(), WriteError> { ... }
    fn write_f32(&mut self, num: f32) { ... }
    fn try_write_f64(&mut self, num: f64) -> Result<(), WriteError> { ... }
    fn write_f64(&mut self, num: f64) { ... }
    fn try_write_le_u8(&mut self, num: u8) -> Result<(), WriteError> { ... }
    fn write_le_u8(&mut self, num: u8) { ... }
    fn try_write_le_u16(&mut self, num: u16) -> Result<(), WriteError> { ... }
    fn write_le_u16(&mut self, num: u16) { ... }
    fn try_write_le_u32(&mut self, num: u32) -> Result<(), WriteError> { ... }
    fn write_le_u32(&mut self, num: u32) { ... }
    fn try_write_le_u64(&mut self, num: u64) -> Result<(), WriteError> { ... }
    fn write_le_u64(&mut self, num: u64) { ... }
    fn try_write_le_u128(&mut self, num: u128) -> Result<(), WriteError> { ... }
    fn write_le_u128(&mut self, num: u128) { ... }
    fn try_write_le_i8(&mut self, num: i8) -> Result<(), WriteError> { ... }
    fn write_le_i8(&mut self, num: i8) { ... }
    fn try_write_le_i16(&mut self, num: i16) -> Result<(), WriteError> { ... }
    fn write_le_i16(&mut self, num: i16) { ... }
    fn try_write_le_i32(&mut self, num: i32) -> Result<(), WriteError> { ... }
    fn write_le_i32(&mut self, num: i32) { ... }
    fn try_write_le_i64(&mut self, num: i64) -> Result<(), WriteError> { ... }
    fn write_le_i64(&mut self, num: i64) { ... }
    fn try_write_le_i128(&mut self, num: i128) -> Result<(), WriteError> { ... }
    fn write_le_i128(&mut self, num: i128) { ... }
    fn try_write_le_f32(&mut self, num: f32) -> Result<(), WriteError> { ... }
    fn write_le_f32(&mut self, num: f32) { ... }
    fn try_write_le_f64(&mut self, num: f64) -> Result<(), WriteError> { ... }
    fn write_le_f64(&mut self, num: f64) { ... }
}

Write bytes or numbers.

Required Methods

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

Returns the entire slice mutably.

fn as_bytes(&self) -> Bytes<'_>

Returns the entire slice as a bytes struct setting the position of the new Bytes to 0.

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

Returns the remaining bytes mutably.

fn try_write(&mut self, slice: impl AsRef<[u8]>) -> Result<(), WriteError>

Writes a slice.

Provided Methods

fn write(&mut self, slice: impl AsRef<[u8]>)

Writes a slice.

Panics

If there aren’t enough remaining bytes left.

fn try_write_u8(&mut self, num: u8) -> Result<(), WriteError>

Try to write u8 in big-endian.`

fn write_u8(&mut self, num: u8)

Writes an u8 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_u16(&mut self, num: u16) -> Result<(), WriteError>

Try to write u16 in big-endian.`

fn write_u16(&mut self, num: u16)

Writes an u16 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_u32(&mut self, num: u32) -> Result<(), WriteError>

Try to write u32 in big-endian.`

fn write_u32(&mut self, num: u32)

Writes an u32 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_u64(&mut self, num: u64) -> Result<(), WriteError>

Try to write u64 in big-endian.`

fn write_u64(&mut self, num: u64)

Writes an u64 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_u128(&mut self, num: u128) -> Result<(), WriteError>

Try to write u128 in big-endian.`

fn write_u128(&mut self, num: u128)

Writes an u128 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_i8(&mut self, num: i8) -> Result<(), WriteError>

Try to write i8 in big-endian.`

fn write_i8(&mut self, num: i8)

Writes an i8 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_i16(&mut self, num: i16) -> Result<(), WriteError>

Try to write i16 in big-endian.`

fn write_i16(&mut self, num: i16)

Writes an i16 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_i32(&mut self, num: i32) -> Result<(), WriteError>

Try to write i32 in big-endian.`

fn write_i32(&mut self, num: i32)

Writes an i32 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_i64(&mut self, num: i64) -> Result<(), WriteError>

Try to write i64 in big-endian.`

fn write_i64(&mut self, num: i64)

Writes an i64 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_i128(&mut self, num: i128) -> Result<(), WriteError>

Try to write i128 in big-endian.`

fn write_i128(&mut self, num: i128)

Writes an i128 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_f32(&mut self, num: f32) -> Result<(), WriteError>

Try to write f32 in big-endian.`

fn write_f32(&mut self, num: f32)

Writes an f32 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_f64(&mut self, num: f64) -> Result<(), WriteError>

Try to write f64 in big-endian.`

fn write_f64(&mut self, num: f64)

Writes an f64 in big-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_u8(&mut self, num: u8) -> Result<(), WriteError>

Try to write u8 in little-endian.`

fn write_le_u8(&mut self, num: u8)

Writes an u8 in little-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_u16(&mut self, num: u16) -> Result<(), WriteError>

Try to write u16 in little-endian.`

fn write_le_u16(&mut self, num: u16)

Writes an u16 in little-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_u32(&mut self, num: u32) -> Result<(), WriteError>

Try to write u32 in little-endian.`

fn write_le_u32(&mut self, num: u32)

Writes an u32 in little-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_u64(&mut self, num: u64) -> Result<(), WriteError>

Try to write u64 in little-endian.`

fn write_le_u64(&mut self, num: u64)

Writes an u64 in little-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_u128(&mut self, num: u128) -> Result<(), WriteError>

Try to write u128 in little-endian.`

fn write_le_u128(&mut self, num: u128)

Writes an u128 in little-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_i8(&mut self, num: i8) -> Result<(), WriteError>

Try to write i8 in little-endian.`

fn write_le_i8(&mut self, num: i8)

Writes an i8 in little-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_i16(&mut self, num: i16) -> Result<(), WriteError>

Try to write i16 in little-endian.`

fn write_le_i16(&mut self, num: i16)

Writes an i16 in little-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_i32(&mut self, num: i32) -> Result<(), WriteError>

Try to write i32 in little-endian.`

fn write_le_i32(&mut self, num: i32)

Writes an i32 in little-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_i64(&mut self, num: i64) -> Result<(), WriteError>

Try to write i64 in little-endian.`

fn write_le_i64(&mut self, num: i64)

Writes an i64 in little-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_i128(&mut self, num: i128) -> Result<(), WriteError>

Try to write i128 in little-endian.`

fn write_le_i128(&mut self, num: i128)

Writes an i128 in little-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_f32(&mut self, num: f32) -> Result<(), WriteError>

Try to write f32 in little-endian.`

fn write_le_f32(&mut self, num: f32)

Writes an f32 in little-endian.

Panics

If there aren’t enough remaining bytes left.

fn try_write_le_f64(&mut self, num: f64) -> Result<(), WriteError>

Try to write f64 in little-endian.`

fn write_le_f64(&mut self, num: f64)

Writes an f64 in little-endian.

Panics

If there aren’t enough remaining bytes left.

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.

Implementations on Foreign Types

impl<W: BytesWrite> BytesWrite for &mut W

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

fn as_bytes(&self) -> Bytes<'_>

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

fn try_write(&mut self, slice: impl AsRef<[u8]>) -> Result<(), WriteError>

Implementors

impl BytesWrite for BytesMut<'_>

impl BytesWrite for BytesOwned

impl BytesWrite for Cursor<&mut Vec<u8>>

impl BytesWrite for Cursor<Vec<u8>>

impl<'a> BytesWrite for Cursor<&'a mut [u8]>

impl<T> BytesWrite for Offset<T>

where T: BytesWrite,

impl<const L: usize> BytesWrite for Cursor<[u8; L]>

impl<const N: usize> BytesWrite for BytesArray<N>