Trait NumWrite 

pub trait NumWrite: Sealed {
    // Required methods
    fn write_bool(&mut self, value: bool) -> Result<()>;
    fn write_u8(&mut self, value: u8) -> Result<()>;
    fn write_u16_le(&mut self, value: u16) -> Result<()>;
    fn write_u16_be(&mut self, value: u16) -> Result<()>;
    fn write_u16_ne(&mut self, value: u16) -> Result<()>;
    fn write_u32_le(&mut self, value: u32) -> Result<()>;
    fn write_u32_be(&mut self, value: u32) -> Result<()>;
    fn write_u32_ne(&mut self, value: u32) -> Result<()>;
    fn write_u64_le(&mut self, value: u64) -> Result<()>;
    fn write_u64_be(&mut self, value: u64) -> Result<()>;
    fn write_u64_ne(&mut self, value: u64) -> Result<()>;
    fn write_u128_le(&mut self, value: u128) -> Result<()>;
    fn write_u128_be(&mut self, value: u128) -> Result<()>;
    fn write_u128_ne(&mut self, value: u128) -> Result<()>;
    fn write_i8(&mut self, value: i8) -> Result<()>;
    fn write_i16_le(&mut self, value: i16) -> Result<()>;
    fn write_i16_be(&mut self, value: i16) -> Result<()>;
    fn write_i16_ne(&mut self, value: i16) -> Result<()>;
    fn write_i32_le(&mut self, value: i32) -> Result<()>;
    fn write_i32_be(&mut self, value: i32) -> Result<()>;
    fn write_i32_ne(&mut self, value: i32) -> Result<()>;
    fn write_i64_le(&mut self, value: i64) -> Result<()>;
    fn write_i64_be(&mut self, value: i64) -> Result<()>;
    fn write_i64_ne(&mut self, value: i64) -> Result<()>;
    fn write_i128_le(&mut self, value: i128) -> Result<()>;
    fn write_i128_be(&mut self, value: i128) -> Result<()>;
    fn write_i128_ne(&mut self, value: i128) -> Result<()>;
    fn write_f32_le(&mut self, value: f32) -> Result<()>;
    fn write_f32_be(&mut self, value: f32) -> Result<()>;
    fn write_f32_ne(&mut self, value: f32) -> Result<()>;
    fn write_f64_le(&mut self, value: f64) -> Result<()>;
    fn write_f64_be(&mut self, value: f64) -> Result<()>;
    fn write_f64_ne(&mut self, value: f64) -> Result<()>;
    fn write_u8_slice(&mut self, slice: &[u8]) -> Result<()>;
    fn write_i8_slice(&mut self, slice: &[i8]) -> Result<()>;
    fn write_u16_slice_le(&mut self, slice: &[u16]) -> Result<()>;
    fn write_u16_slice_be(&mut self, slice: &[u16]) -> Result<()>;
    fn write_u16_slice_ne(&mut self, slice: &[u16]) -> Result<()>;
    fn write_u32_slice_le(&mut self, slice: &[u32]) -> Result<()>;
    fn write_u32_slice_be(&mut self, slice: &[u32]) -> Result<()>;
    fn write_u32_slice_ne(&mut self, slice: &[u32]) -> Result<()>;
    fn write_u64_slice_le(&mut self, slice: &[u64]) -> Result<()>;
    fn write_u64_slice_be(&mut self, slice: &[u64]) -> Result<()>;
    fn write_u64_slice_ne(&mut self, slice: &[u64]) -> Result<()>;
    fn write_u128_slice_le(&mut self, slice: &[u128]) -> Result<()>;
    fn write_u128_slice_be(&mut self, slice: &[u128]) -> Result<()>;
    fn write_u128_slice_ne(&mut self, slice: &[u128]) -> Result<()>;
    fn write_i16_slice_le(&mut self, slice: &[i16]) -> Result<()>;
    fn write_i16_slice_be(&mut self, slice: &[i16]) -> Result<()>;
    fn write_i16_slice_ne(&mut self, slice: &[i16]) -> Result<()>;
    fn write_i32_slice_le(&mut self, slice: &[i32]) -> Result<()>;
    fn write_i32_slice_be(&mut self, slice: &[i32]) -> Result<()>;
    fn write_i32_slice_ne(&mut self, slice: &[i32]) -> Result<()>;
    fn write_i64_slice_le(&mut self, slice: &[i64]) -> Result<()>;
    fn write_i64_slice_be(&mut self, slice: &[i64]) -> Result<()>;
    fn write_i64_slice_ne(&mut self, slice: &[i64]) -> Result<()>;
    fn write_i128_slice_le(&mut self, slice: &[i128]) -> Result<()>;
    fn write_i128_slice_be(&mut self, slice: &[i128]) -> Result<()>;
    fn write_i128_slice_ne(&mut self, slice: &[i128]) -> Result<()>;
    fn write_f64_slice_le(&mut self, slice: &[f64]) -> Result<()>;
    fn write_f64_slice_be(&mut self, slice: &[f64]) -> Result<()>;
    fn write_f64_slice_ne(&mut self, slice: &[f64]) -> Result<()>;
    fn write_f32_slice_le(&mut self, slice: &[f32]) -> Result<()>;
    fn write_f32_slice_be(&mut self, slice: &[f32]) -> Result<()>;
    fn write_f32_slice_ne(&mut self, slice: &[f32]) -> Result<()>;
    fn write_u8_vec(&mut self, slice: &Vec<u8>) -> Result<()>;
    fn write_i8_vec(&mut self, slice: &Vec<i8>) -> Result<()>;
    fn write_u16_vec_le(&mut self, slice: &Vec<u16>) -> Result<()>;
    fn write_u16_vec_be(&mut self, slice: &Vec<u16>) -> Result<()>;
    fn write_u16_vec_ne(&mut self, slice: &Vec<u16>) -> Result<()>;
    fn write_u32_vec_le(&mut self, slice: &Vec<u32>) -> Result<()>;
    fn write_u32_vec_be(&mut self, slice: &Vec<u32>) -> Result<()>;
    fn write_u32_vec_ne(&mut self, slice: &Vec<u32>) -> Result<()>;
    fn write_u64_vec_le(&mut self, slice: &Vec<u64>) -> Result<()>;
    fn write_u64_vec_be(&mut self, slice: &Vec<u64>) -> Result<()>;
    fn write_u64_vec_ne(&mut self, slice: &Vec<u64>) -> Result<()>;
    fn write_u128_vec_le(&mut self, slice: &Vec<u128>) -> Result<()>;
    fn write_u128_vec_be(&mut self, slice: &Vec<u128>) -> Result<()>;
    fn write_u128_vec_ne(&mut self, slice: &Vec<u128>) -> Result<()>;
    fn write_i16_vec_le(&mut self, slice: &Vec<i16>) -> Result<()>;
    fn write_i16_vec_be(&mut self, slice: &Vec<i16>) -> Result<()>;
    fn write_i16_vec_ne(&mut self, slice: &Vec<i16>) -> Result<()>;
    fn write_i32_vec_le(&mut self, slice: &Vec<i32>) -> Result<()>;
    fn write_i32_vec_be(&mut self, slice: &Vec<i32>) -> Result<()>;
    fn write_i32_vec_ne(&mut self, slice: &Vec<i32>) -> Result<()>;
    fn write_i64_vec_le(&mut self, slice: &Vec<i64>) -> Result<()>;
    fn write_i64_vec_be(&mut self, slice: &Vec<i64>) -> Result<()>;
    fn write_i64_vec_ne(&mut self, slice: &Vec<i64>) -> Result<()>;
    fn write_i128_vec_le(&mut self, slice: &Vec<i128>) -> Result<()>;
    fn write_i128_vec_be(&mut self, slice: &Vec<i128>) -> Result<()>;
    fn write_i128_vec_ne(&mut self, slice: &Vec<i128>) -> Result<()>;
    fn write_f64_vec_le(&mut self, slice: &Vec<f64>) -> Result<()>;
    fn write_f64_vec_be(&mut self, slice: &Vec<f64>) -> Result<()>;
    fn write_f64_vec_ne(&mut self, slice: &Vec<f64>) -> Result<()>;
    fn write_f32_vec_le(&mut self, slice: &Vec<f32>) -> Result<()>;
    fn write_f32_vec_be(&mut self, slice: &Vec<f32>) -> Result<()>;
    fn write_f32_vec_ne(&mut self, slice: &Vec<f32>) -> Result<()>;
}

Trait that provides various methods to write numbers. Automatically implemented for all implementations of io::Write.

Required Methods

fn write_bool(&mut self, value: bool) -> Result<()>

Writes one byte and treats 0 as false and any other value as true.

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

Writes 1 byte and treats it as an u8

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

Writes 2 bytes and treats them as an u16 in little endian byte order

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

Writes 2 bytes and treats them as an u16 in big endian byte order

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

Writes 2 bytes and treats them as an u16 in native byte order

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

Writes 4 bytes and treats them as an u32 in little endian byte order

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

Writes 4 bytes and treats them as an u32 in big endian byte order

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

Writes 4 bytes and treats them as an u32 in native byte order

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

Writes 8 bytes and treats them as an u64 in little endian byte order

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

Writes 8 bytes and treats them as an u64 in big endian byte order

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

Writes 8 bytes and treats them as an u64 in native byte order

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

Writes 16 bytes and treats them as an u128 in little endian byte order

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

Writes 16 bytes and treats them as an u128 in big endian byte order

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

Writes 16 bytes and treats them as an u128 in native byte order

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

Writes 1 byte and treats it as an i8

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

Writes 2 bytes and treats them as an i16 in little endian byte order

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

Writes 2 bytes and treats them as an i16 in big endian byte order

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

Writes 2 bytes and treats them as an u16 in native byte order

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

Writes 4 bytes and treats them as an i32 in little endian byte order

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

Writes 4 bytes and treats them as an i32 in big endian byte order

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

Writes 4 bytes and treats them as an i32 in native byte order

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

Writes 8 bytes and treats them as an i64 in little endian byte order

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

Writes 8 bytes and treats them as an i64 in big endian byte order

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

Writes 8 bytes and treats them as an u64 in native byte order

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

Writes 16 bytes and treats them as an u128 in little endian byte order

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

Writes 16 bytes and treats them as an u128 in big endian byte order

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

Writes 16 bytes and treats them as an u128 in native byte order

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

Writes 4 bytes and treats them as an f32 in little endian byte order

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

Writes 4 bytes and treats them as an f32 in big endian byte order

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

Writes 4 bytes and treats them as an f32 in native byte order

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

Writes 8 bytes and treats them as an f64 in little endian byte order

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

Writes 8 bytes and treats them as an f64 in big endian byte order

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

Writes 8 bytes and treats them as an f64 in native byte order

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

Writes the entire slice.

fn write_i8_slice(&mut self, slice: &[i8]) -> Result<()>

Writes the entire slice.

fn write_u16_slice_le(&mut self, slice: &[u16]) -> Result<()>

Writes the entire slice. Each element is encoded in little endian.

fn write_u16_slice_be(&mut self, slice: &[u16]) -> Result<()>

Writes the entire slice. Each element is encoded in big endian.

fn write_u16_slice_ne(&mut self, slice: &[u16]) -> Result<()>

Writes the entire slice. Each element is encoded in native endian.

fn write_u32_slice_le(&mut self, slice: &[u32]) -> Result<()>

Writes the entire slice. Each element is encoded in little endian.

fn write_u32_slice_be(&mut self, slice: &[u32]) -> Result<()>

Writes the entire slice. Each element is encoded in big endian.

fn write_u32_slice_ne(&mut self, slice: &[u32]) -> Result<()>

Writes the entire slice. Each element is encoded in native endian.

fn write_u64_slice_le(&mut self, slice: &[u64]) -> Result<()>

Writes the entire slice. Each element is encoded in little endian.

fn write_u64_slice_be(&mut self, slice: &[u64]) -> Result<()>

Writes the entire slice. Each element is encoded in big endian.

fn write_u64_slice_ne(&mut self, slice: &[u64]) -> Result<()>

Writes the entire slice. Each element is encoded in native endian.

fn write_u128_slice_le(&mut self, slice: &[u128]) -> Result<()>

Writes the entire slice. Each element is encoded in little endian.

fn write_u128_slice_be(&mut self, slice: &[u128]) -> Result<()>

Writes the entire slice. Each element is encoded in big endian.

fn write_u128_slice_ne(&mut self, slice: &[u128]) -> Result<()>

Writes the entire slice. Each element is encoded in native endian.

fn write_i16_slice_le(&mut self, slice: &[i16]) -> Result<()>

Writes the entire slice. Each element is encoded in little endian.

fn write_i16_slice_be(&mut self, slice: &[i16]) -> Result<()>

Writes the entire slice. Each element is encoded in big endian.

fn write_i16_slice_ne(&mut self, slice: &[i16]) -> Result<()>

Writes the entire slice. Each element is encoded in native endian.

fn write_i32_slice_le(&mut self, slice: &[i32]) -> Result<()>

Writes the entire slice. Each element is encoded in little endian.

fn write_i32_slice_be(&mut self, slice: &[i32]) -> Result<()>

Writes the entire slice. Each element is encoded in big endian.

fn write_i32_slice_ne(&mut self, slice: &[i32]) -> Result<()>

Writes the entire slice. Each element is encoded in native endian.

fn write_i64_slice_le(&mut self, slice: &[i64]) -> Result<()>

Writes the entire slice. Each element is encoded in little endian.

fn write_i64_slice_be(&mut self, slice: &[i64]) -> Result<()>

Writes the entire slice. Each element is encoded in big endian.

fn write_i64_slice_ne(&mut self, slice: &[i64]) -> Result<()>

Writes the entire slice. Each element is encoded in native endian.

fn write_i128_slice_le(&mut self, slice: &[i128]) -> Result<()>

Writes the entire slice. Each element is encoded in little endian.

fn write_i128_slice_be(&mut self, slice: &[i128]) -> Result<()>

Writes the entire slice. Each element is encoded in big endian.

fn write_i128_slice_ne(&mut self, slice: &[i128]) -> Result<()>

Writes the entire slice. Each element is encoded in native endian.

fn write_f64_slice_le(&mut self, slice: &[f64]) -> Result<()>

Writes the entire slice. Each element is encoded in little endian.

fn write_f64_slice_be(&mut self, slice: &[f64]) -> Result<()>

Writes the entire slice. Each element is encoded in big endian.

fn write_f64_slice_ne(&mut self, slice: &[f64]) -> Result<()>

Writes the entire slice. Each element is encoded in native endian.

fn write_f32_slice_le(&mut self, slice: &[f32]) -> Result<()>

Writes the entire slice. Each element is encoded in little endian.

fn write_f32_slice_be(&mut self, slice: &[f32]) -> Result<()>

Writes the entire slice. Each element is encoded in big endian.

fn write_f32_slice_ne(&mut self, slice: &[f32]) -> Result<()>

Writes the entire slice. Each element is encoded in native endian.

fn write_u8_vec(&mut self, slice: &Vec<u8>) -> Result<()>

Writes the entire vec.

fn write_i8_vec(&mut self, slice: &Vec<i8>) -> Result<()>

Writes the entire vec.

fn write_u16_vec_le(&mut self, slice: &Vec<u16>) -> Result<()>

Writes the entire vec. Each element is encoded in little endian.

fn write_u16_vec_be(&mut self, slice: &Vec<u16>) -> Result<()>

Writes the entire vec. Each element is encoded in big endian.

fn write_u16_vec_ne(&mut self, slice: &Vec<u16>) -> Result<()>

Writes the entire vec. Each element is encoded in native endian.

fn write_u32_vec_le(&mut self, slice: &Vec<u32>) -> Result<()>

Writes the entire vec. Each element is encoded in little endian.

fn write_u32_vec_be(&mut self, slice: &Vec<u32>) -> Result<()>

Writes the entire vec. Each element is encoded in big endian.

fn write_u32_vec_ne(&mut self, slice: &Vec<u32>) -> Result<()>

Writes the entire vec. Each element is encoded in native endian.

fn write_u64_vec_le(&mut self, slice: &Vec<u64>) -> Result<()>

Writes the entire vec. Each element is encoded in little endian.

fn write_u64_vec_be(&mut self, slice: &Vec<u64>) -> Result<()>

Writes the entire vec. Each element is encoded in big endian.

fn write_u64_vec_ne(&mut self, slice: &Vec<u64>) -> Result<()>

Writes the entire vec. Each element is encoded in native endian.

fn write_u128_vec_le(&mut self, slice: &Vec<u128>) -> Result<()>

Writes the entire vec. Each element is encoded in little endian.

fn write_u128_vec_be(&mut self, slice: &Vec<u128>) -> Result<()>

Writes the entire vec. Each element is encoded in big endian.

fn write_u128_vec_ne(&mut self, slice: &Vec<u128>) -> Result<()>

Writes the entire vec. Each element is encoded in native endian.

fn write_i16_vec_le(&mut self, slice: &Vec<i16>) -> Result<()>

Writes the entire vec. Each element is encoded in little endian.

fn write_i16_vec_be(&mut self, slice: &Vec<i16>) -> Result<()>

Writes the entire vec. Each element is encoded in big endian.

fn write_i16_vec_ne(&mut self, slice: &Vec<i16>) -> Result<()>

Writes the entire vec. Each element is encoded in native endian.

fn write_i32_vec_le(&mut self, slice: &Vec<i32>) -> Result<()>

Writes the entire vec. Each element is encoded in little endian.

fn write_i32_vec_be(&mut self, slice: &Vec<i32>) -> Result<()>

Writes the entire vec. Each element is encoded in big endian.

fn write_i32_vec_ne(&mut self, slice: &Vec<i32>) -> Result<()>

Writes the entire vec. Each element is encoded in native endian.

fn write_i64_vec_le(&mut self, slice: &Vec<i64>) -> Result<()>

Writes the entire vec. Each element is encoded in little endian.

fn write_i64_vec_be(&mut self, slice: &Vec<i64>) -> Result<()>

Writes the entire vec. Each element is encoded in big endian.

fn write_i64_vec_ne(&mut self, slice: &Vec<i64>) -> Result<()>

Writes the entire vec. Each element is encoded in native endian.

fn write_i128_vec_le(&mut self, slice: &Vec<i128>) -> Result<()>

Writes the entire vec. Each element is encoded in little endian.

fn write_i128_vec_be(&mut self, slice: &Vec<i128>) -> Result<()>

Writes the entire vec. Each element is encoded in big endian.

fn write_i128_vec_ne(&mut self, slice: &Vec<i128>) -> Result<()>

Writes the entire vec. Each element is encoded in native endian.

fn write_f64_vec_le(&mut self, slice: &Vec<f64>) -> Result<()>

Writes the entire vec. Each element is encoded in little endian.

fn write_f64_vec_be(&mut self, slice: &Vec<f64>) -> Result<()>

Writes the entire vec. Each element is encoded in big endian.

fn write_f64_vec_ne(&mut self, slice: &Vec<f64>) -> Result<()>

Writes the entire vec. Each element is encoded in native endian.

fn write_f32_vec_le(&mut self, slice: &Vec<f32>) -> Result<()>

Writes the entire vec. Each element is encoded in little endian.

fn write_f32_vec_be(&mut self, slice: &Vec<f32>) -> Result<()>

Writes the entire vec. Each element is encoded in big endian.

fn write_f32_vec_ne(&mut self, slice: &Vec<f32>) -> Result<()>

Writes the entire vec. Each element is encoded in native endian.

Implementors

impl<T> NumWrite for T

where T: Write,