Trait InlinableWrite

pub trait InlinableWrite: Write {
    // Provided methods
    fn write_len_with_width<const N: usize>(
        &mut self,
        len: usize,
    ) -> Result<usize> { ... }
    fn write_u8_le(&mut self, value: u8) -> Result<usize> { ... }
    fn write_u16_le(&mut self, value: u16) -> Result<usize> { ... }
    fn write_u32_le(&mut self, value: u32) -> Result<usize> { ... }
    fn write_i64_le(&mut self, value: i64) -> Result<usize> { ... }
    fn write_u64_le(&mut self, value: u64) -> Result<usize> { ... }
    fn write_u128_le(&mut self, value: u128) -> Result<usize> { ... }
    fn write_inlined_bytes<const N: usize>(
        &mut self,
        bytes: &[u8],
    ) -> Result<usize> { ... }
    fn write_inlined_str<const N: usize>(&mut self, s: &str) -> Result<usize> { ... }
    fn write_inlinable<T: Inlinable>(&mut self, value: &T) -> Result<usize>
       where Self: Sized { ... }
}

Provided Methods

fn write_len_with_width<const N: usize>(&mut self, len: usize) -> Result<usize>

Write usize length as little endian N bytes.

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

Write a u8 value to writer.

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

Write a u16 value to writer.

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

Write a u32 value to writer.

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

Write a i64 value to writer.

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

Write a u64 value to writer.

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

Write a u128 value to writer.

fn write_inlined_bytes<const N: usize>(&mut self, bytes: &[u8]) -> Result<usize>

Write inlined bytes to writer with specific length width N.

The inlined bytes are constructed as:

+--------------+-----------------+
| len: N bytes | data: len bytes |
+--------------+-----------------+

Safety

Write inlined bytes may not be safe if the input bytes length overflows to the width. For example, write 256 bytes with length width 1 is not safe.

fn write_inlined_str<const N: usize>(&mut self, s: &str) -> Result<usize>

Write inlined string with specific length width N.

fn write_inlinable<T: Inlinable>(&mut self, value: &T) -> Result<usize>

where Self: Sized,

Write an inlinable object.

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<T> InlinableWrite for T

where T: Write,