Trait NumRead 

pub trait NumRead: Sealed {
    // Required methods
    fn read_bool(&mut self) -> Result<bool>;
    fn read_u8(&mut self) -> Result<u8>;
    fn read_u16_le(&mut self) -> Result<u16>;
    fn read_u16_be(&mut self) -> Result<u16>;
    fn read_u16_ne(&mut self) -> Result<u16>;
    fn read_u32_le(&mut self) -> Result<u32>;
    fn read_u32_be(&mut self) -> Result<u32>;
    fn read_u32_ne(&mut self) -> Result<u32>;
    fn read_u64_le(&mut self) -> Result<u64>;
    fn read_u64_be(&mut self) -> Result<u64>;
    fn read_u64_ne(&mut self) -> Result<u64>;
    fn read_u128_le(&mut self) -> Result<u128>;
    fn read_u128_be(&mut self) -> Result<u128>;
    fn read_u128_ne(&mut self) -> Result<u128>;
    fn read_i8(&mut self) -> Result<i8>;
    fn read_i16_le(&mut self) -> Result<i16>;
    fn read_i16_be(&mut self) -> Result<i16>;
    fn read_i16_ne(&mut self) -> Result<i16>;
    fn read_i32_le(&mut self) -> Result<i32>;
    fn read_i32_be(&mut self) -> Result<i32>;
    fn read_i32_ne(&mut self) -> Result<i32>;
    fn read_i64_le(&mut self) -> Result<i64>;
    fn read_i64_be(&mut self) -> Result<i64>;
    fn read_i64_ne(&mut self) -> Result<i64>;
    fn read_i128_le(&mut self) -> Result<i128>;
    fn read_i128_be(&mut self) -> Result<i128>;
    fn read_i128_ne(&mut self) -> Result<i128>;
    fn read_f32_le(&mut self) -> Result<f32>;
    fn read_f32_be(&mut self) -> Result<f32>;
    fn read_f32_ne(&mut self) -> Result<f32>;
    fn read_f64_le(&mut self) -> Result<f64>;
    fn read_f64_be(&mut self) -> Result<f64>;
    fn read_f64_ne(&mut self) -> Result<f64>;
    fn read_u8_slice(&mut self, slice: &mut [u8]) -> Result<()>;
    fn read_i8_slice(&mut self, slice: &mut [i8]) -> Result<()>;
    fn read_u16_slice_le(&mut self, slice: &mut [u16]) -> Result<()>;
    fn read_u16_slice_be(&mut self, slice: &mut [u16]) -> Result<()>;
    fn read_u16_slice_ne(&mut self, slice: &mut [u16]) -> Result<()>;
    fn read_u32_slice_le(&mut self, slice: &mut [u32]) -> Result<()>;
    fn read_u32_slice_be(&mut self, slice: &mut [u32]) -> Result<()>;
    fn read_u32_slice_ne(&mut self, slice: &mut [u32]) -> Result<()>;
    fn read_u64_slice_le(&mut self, slice: &mut [u64]) -> Result<()>;
    fn read_u64_slice_be(&mut self, slice: &mut [u64]) -> Result<()>;
    fn read_u64_slice_ne(&mut self, slice: &mut [u64]) -> Result<()>;
    fn read_u128_slice_le(&mut self, slice: &mut [u128]) -> Result<()>;
    fn read_u128_slice_be(&mut self, slice: &mut [u128]) -> Result<()>;
    fn read_u128_slice_ne(&mut self, slice: &mut [u128]) -> Result<()>;
    fn read_i16_slice_le(&mut self, slice: &mut [i16]) -> Result<()>;
    fn read_i16_slice_be(&mut self, slice: &mut [i16]) -> Result<()>;
    fn read_i16_slice_ne(&mut self, slice: &mut [i16]) -> Result<()>;
    fn read_i32_slice_le(&mut self, slice: &mut [i32]) -> Result<()>;
    fn read_i32_slice_be(&mut self, slice: &mut [i32]) -> Result<()>;
    fn read_i32_slice_ne(&mut self, slice: &mut [i32]) -> Result<()>;
    fn read_i64_slice_le(&mut self, slice: &mut [i64]) -> Result<()>;
    fn read_i64_slice_be(&mut self, slice: &mut [i64]) -> Result<()>;
    fn read_i64_slice_ne(&mut self, slice: &mut [i64]) -> Result<()>;
    fn read_i128_slice_le(&mut self, slice: &mut [i128]) -> Result<()>;
    fn read_i128_slice_be(&mut self, slice: &mut [i128]) -> Result<()>;
    fn read_i128_slice_ne(&mut self, slice: &mut [i128]) -> Result<()>;
    fn read_f64_slice_le(&mut self, slice: &mut [f64]) -> Result<()>;
    fn read_f64_slice_be(&mut self, slice: &mut [f64]) -> Result<()>;
    fn read_f64_slice_ne(&mut self, slice: &mut [f64]) -> Result<()>;
    fn read_f32_slice_le(&mut self, slice: &mut [f32]) -> Result<()>;
    fn read_f32_slice_be(&mut self, slice: &mut [f32]) -> Result<()>;
    fn read_f32_slice_ne(&mut self, slice: &mut [f32]) -> Result<()>;
    fn read_u8_vec(&mut self, size: usize) -> Result<Vec<u8>>;
    fn read_i8_vec(&mut self, size: usize) -> Result<Vec<i8>>;
    fn read_u16_vec_le(&mut self, size: usize) -> Result<Vec<u16>>;
    fn read_u16_vec_be(&mut self, size: usize) -> Result<Vec<u16>>;
    fn read_u16_vec_ne(&mut self, size: usize) -> Result<Vec<u16>>;
    fn read_u32_vec_le(&mut self, size: usize) -> Result<Vec<u32>>;
    fn read_u32_vec_be(&mut self, size: usize) -> Result<Vec<u32>>;
    fn read_u32_vec_ne(&mut self, size: usize) -> Result<Vec<u32>>;
    fn read_u64_vec_le(&mut self, size: usize) -> Result<Vec<u64>>;
    fn read_u64_vec_be(&mut self, size: usize) -> Result<Vec<u64>>;
    fn read_u64_vec_ne(&mut self, size: usize) -> Result<Vec<u64>>;
    fn read_u128_vec_le(&mut self, size: usize) -> Result<Vec<u128>>;
    fn read_u128_vec_be(&mut self, size: usize) -> Result<Vec<u128>>;
    fn read_u128_vec_ne(&mut self, size: usize) -> Result<Vec<u128>>;
    fn read_i16_vec_le(&mut self, size: usize) -> Result<Vec<i16>>;
    fn read_i16_vec_be(&mut self, size: usize) -> Result<Vec<i16>>;
    fn read_i16_vec_ne(&mut self, size: usize) -> Result<Vec<i16>>;
    fn read_i32_vec_le(&mut self, size: usize) -> Result<Vec<i32>>;
    fn read_i32_vec_be(&mut self, size: usize) -> Result<Vec<i32>>;
    fn read_i32_vec_ne(&mut self, size: usize) -> Result<Vec<i32>>;
    fn read_i64_vec_le(&mut self, size: usize) -> Result<Vec<i64>>;
    fn read_i64_vec_be(&mut self, size: usize) -> Result<Vec<i64>>;
    fn read_i64_vec_ne(&mut self, size: usize) -> Result<Vec<i64>>;
    fn read_i128_vec_le(&mut self, size: usize) -> Result<Vec<i128>>;
    fn read_i128_vec_be(&mut self, size: usize) -> Result<Vec<i128>>;
    fn read_i128_vec_ne(&mut self, size: usize) -> Result<Vec<i128>>;
    fn read_f64_vec_le(&mut self, size: usize) -> Result<Vec<f64>>;
    fn read_f64_vec_be(&mut self, size: usize) -> Result<Vec<f64>>;
    fn read_f64_vec_ne(&mut self, size: usize) -> Result<Vec<f64>>;
    fn read_f32_vec_le(&mut self, size: usize) -> Result<Vec<f32>>;
    fn read_f32_vec_be(&mut self, size: usize) -> Result<Vec<f32>>;
    fn read_f32_vec_ne(&mut self, size: usize) -> Result<Vec<f32>>;
}

Trait that provides various methods to read numbers. Automatically implemented for all implementations of io::Read. This trait is sealed and cannot be implemented manually.

Required Methods

fn read_bool(&mut self) -> Result<bool>

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

fn read_u8(&mut self) -> Result<u8>

Reads 1 byte and treats it as an u8

fn read_u16_le(&mut self) -> Result<u16>

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

fn read_u16_be(&mut self) -> Result<u16>

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

fn read_u16_ne(&mut self) -> Result<u16>

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

fn read_u32_le(&mut self) -> Result<u32>

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

fn read_u32_be(&mut self) -> Result<u32>

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

fn read_u32_ne(&mut self) -> Result<u32>

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

fn read_u64_le(&mut self) -> Result<u64>

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

fn read_u64_be(&mut self) -> Result<u64>

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

fn read_u64_ne(&mut self) -> Result<u64>

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

fn read_u128_le(&mut self) -> Result<u128>

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

fn read_u128_be(&mut self) -> Result<u128>

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

fn read_u128_ne(&mut self) -> Result<u128>

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

fn read_i8(&mut self) -> Result<i8>

Reads 1 byte and treats it as an i8

fn read_i16_le(&mut self) -> Result<i16>

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

fn read_i16_be(&mut self) -> Result<i16>

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

fn read_i16_ne(&mut self) -> Result<i16>

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

fn read_i32_le(&mut self) -> Result<i32>

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

fn read_i32_be(&mut self) -> Result<i32>

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

fn read_i32_ne(&mut self) -> Result<i32>

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

fn read_i64_le(&mut self) -> Result<i64>

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

fn read_i64_be(&mut self) -> Result<i64>

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

fn read_i64_ne(&mut self) -> Result<i64>

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

fn read_i128_le(&mut self) -> Result<i128>

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

fn read_i128_be(&mut self) -> Result<i128>

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

fn read_i128_ne(&mut self) -> Result<i128>

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

fn read_f32_le(&mut self) -> Result<f32>

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

fn read_f32_be(&mut self) -> Result<f32>

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

fn read_f32_ne(&mut self) -> Result<f32>

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

fn read_f64_le(&mut self) -> Result<f64>

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

fn read_f64_be(&mut self) -> Result<f64>

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

fn read_f64_ne(&mut self) -> Result<f64>

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

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

Reads bytes to fill the slice. Each byte is treated as a u8.

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

Reads bytes to fill the slice. Each byte is treated as a i8.

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

Reads bytes to fill the slice. Each group of 2 bytes is treated as an u16 in little endian

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

Reads bytes to fill the slice. Each group of 2 bytes is treated as an u16 in big endian

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

Reads bytes to fill the slice. Each group of 2 bytes is treated as an u16 in native endian

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

Reads bytes to fill the slice. Each group of 4 bytes is treated as an u32 in little endian

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

Reads bytes to fill the slice. Each group of 4 bytes is treated as an u32 in big endian

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

Reads bytes to fill the slice. Each group of 4 bytes is treated as an u32 in native endian

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

Reads bytes to fill the slice. Each group of 8 bytes is treated as an u64 in little endian

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

Reads bytes to fill the slice. Each group of 8 bytes is treated as an u64 in big endian

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

Reads bytes to fill the slice. Each group of 8 bytes is treated as an u64 in native endian

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

Reads bytes to fill the slice. Each group of 16 bytes is treated as an u128 in little endian

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

Reads bytes to fill the slice. Each group of 16 bytes is treated as an u128 in big endian

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

Reads bytes to fill the slice. Each group of 16 bytes is treated as an u128 in native endian

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

Reads bytes to fill the slice. Each group of 2 bytes is treated as an i16 in little endian

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

Reads bytes to fill the slice. Each group of 2 bytes is treated as an i16 in big endian

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

Reads bytes to fill the slice. Each group of 2 bytes is treated as an i16 in native endian

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

Reads bytes to fill the slice. Each group of 4 bytes is treated as an i32 in little endian

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

Reads bytes to fill the slice. Each group of 4 bytes is treated as an i32 in big endian

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

Reads bytes to fill the slice. Each group of 4 bytes is treated as an i32 in native endian

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

Reads bytes to fill the slice. Each group of 8 bytes is treated as an i64 in little endian

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

Reads bytes to fill the slice. Each group of 8 bytes is treated as an i64 in big endian

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

Reads bytes to fill the slice. Each group of 8 bytes is treated as an i64 in native endian

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

Reads bytes to fill the slice. Each group of 16 bytes is treated as an i128 in little endian

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

Reads bytes to fill the slice. Each group of 16 bytes is treated as an i128 in big endian

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

Reads bytes to fill the slice. Each group of 16 bytes is treated as an i128 in native endian

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

Reads bytes to fill the slice. Each group of 8 bytes is treated as an f64 in little endian

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

Reads bytes to fill the slice. Each group of 8 bytes is treated as an f64 in big endian

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

Reads bytes to fill the slice. Each group of 8 bytes is treated as an f64 in native endian

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

Reads bytes to fill the slice. Each group of 4 bytes is treated as an f32 in little endian

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

Reads bytes to fill the slice. Each group of 4 bytes is treated as an f32 in big endian

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

Reads bytes to fill the slice. Each group of 4 bytes is treated as an f32 in native endian

fn read_u8_vec(&mut self, size: usize) -> Result<Vec<u8>>

reads size amount of data into a new Vec

fn read_i8_vec(&mut self, size: usize) -> Result<Vec<i8>>

reads size amount of data into a new Vec

fn read_u16_vec_le(&mut self, size: usize) -> Result<Vec<u16>>

reads size amount of data into a new Vec. Each group of 2 bytes is treated as an u16 in little endian Size refers to the size of the Vec not the amount of bytes.

fn read_u16_vec_be(&mut self, size: usize) -> Result<Vec<u16>>

reads size amount of data into a new Vec. Each group of 2 bytes is treated as an u16 in big endian Size refers to the size of the Vec not the amount of bytes.

fn read_u16_vec_ne(&mut self, size: usize) -> Result<Vec<u16>>

reads size amount of data into a new Vec. Each group of 2 bytes is treated as an u16 in native endian Size refers to the size of the Vec not the amount of bytes.

fn read_u32_vec_le(&mut self, size: usize) -> Result<Vec<u32>>

reads size amount of data into a new Vec. Each group of 4 bytes is treated as an u32 in little endian Size refers to the size of the Vec not the amount of bytes.

fn read_u32_vec_be(&mut self, size: usize) -> Result<Vec<u32>>

reads size amount of data into a new Vec. Each group of 4 bytes is treated as an u32 in big endian Size refers to the size of the Vec not the amount of bytes.

fn read_u32_vec_ne(&mut self, size: usize) -> Result<Vec<u32>>

reads size amount of data into a new Vec. Each group of 4 bytes is treated as an u32 in native endian Size refers to the size of the Vec not the amount of bytes.

fn read_u64_vec_le(&mut self, size: usize) -> Result<Vec<u64>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an u64 in little endian Size refers to the size of the Vec not the amount of bytes.

fn read_u64_vec_be(&mut self, size: usize) -> Result<Vec<u64>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an u64 in big endian Size refers to the size of the Vec not the amount of bytes.

fn read_u64_vec_ne(&mut self, size: usize) -> Result<Vec<u64>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an u64 in native endian Size refers to the size of the Vec not the amount of bytes.

fn read_u128_vec_le(&mut self, size: usize) -> Result<Vec<u128>>

reads size amount of data into a new Vec. Each group of 16 bytes is treated as an u128 in little endian Size refers to the size of the Vec not the amount of bytes.

fn read_u128_vec_be(&mut self, size: usize) -> Result<Vec<u128>>

reads size amount of data into a new Vec. Each group of 16 bytes is treated as an u128 in big endian Size refers to the size of the Vec not the amount of bytes.

fn read_u128_vec_ne(&mut self, size: usize) -> Result<Vec<u128>>

reads size amount of data into a new Vec. Each group of 16 bytes is treated as an u128 in native endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i16_vec_le(&mut self, size: usize) -> Result<Vec<i16>>

reads size amount of data into a new Vec. Each group of 2 bytes is treated as an i16 in little endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i16_vec_be(&mut self, size: usize) -> Result<Vec<i16>>

reads size amount of data into a new Vec. Each group of 2 bytes is treated as an i16 in big endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i16_vec_ne(&mut self, size: usize) -> Result<Vec<i16>>

reads size amount of data into a new Vec. Each group of 2 bytes is treated as an i16 in native endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i32_vec_le(&mut self, size: usize) -> Result<Vec<i32>>

reads size amount of data into a new Vec. Each group of 4 bytes is treated as an i32 in little endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i32_vec_be(&mut self, size: usize) -> Result<Vec<i32>>

reads size amount of data into a new Vec. Each group of 4 bytes is treated as an i32 in big endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i32_vec_ne(&mut self, size: usize) -> Result<Vec<i32>>

reads size amount of data into a new Vec. Each group of 4 bytes is treated as an i32 in native endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i64_vec_le(&mut self, size: usize) -> Result<Vec<i64>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an i64 in little endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i64_vec_be(&mut self, size: usize) -> Result<Vec<i64>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an i64 in big endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i64_vec_ne(&mut self, size: usize) -> Result<Vec<i64>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an i64 in native endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i128_vec_le(&mut self, size: usize) -> Result<Vec<i128>>

reads size amount of data into a new Vec. Each group of 16 bytes is treated as an i128 in little endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i128_vec_be(&mut self, size: usize) -> Result<Vec<i128>>

reads size amount of data into a new Vec. Each group of 16 bytes is treated as an i128 in big endian. Size refers to the size of the Vec not the amount of bytes.

fn read_i128_vec_ne(&mut self, size: usize) -> Result<Vec<i128>>

reads size amount of data into a new Vec. Each group of 16 bytes is treated as an i128 in native endian. Size refers to the size of the Vec not the amount of bytes.

fn read_f64_vec_le(&mut self, size: usize) -> Result<Vec<f64>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an f64 in little endian. Size refers to the size of the Vec not the amount of bytes.

fn read_f64_vec_be(&mut self, size: usize) -> Result<Vec<f64>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an f64 in big endian. Size refers to the size of the Vec not the amount of bytes.

fn read_f64_vec_ne(&mut self, size: usize) -> Result<Vec<f64>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an f64 in native endian. Size refers to the size of the Vec not the amount of bytes.

fn read_f32_vec_le(&mut self, size: usize) -> Result<Vec<f32>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an f32 in little endian. Size refers to the size of the Vec not the amount of bytes.

fn read_f32_vec_be(&mut self, size: usize) -> Result<Vec<f32>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an f32 in big endian. Size refers to the size of the Vec not the amount of bytes.

fn read_f32_vec_ne(&mut self, size: usize) -> Result<Vec<f32>>

reads size amount of data into a new Vec. Each group of 8 bytes is treated as an f32 in native endian. Size refers to the size of the Vec not the amount of bytes.

Implementors

impl<T> NumRead for T

where T: Read,