Trait bite::Endianness [−] [src]

pub trait Endianness: Clone + Copy + Debug + Eq + Hash + Ord + PartialEq + PartialOrd {
    fn read_u8(stream: &[u8]) -> u8;

    fn read_u16(stream: &[u8]) -> u16;

    fn read_u32(stream: &[u8]) -> u32;

    fn read_u64(stream: &[u8]) -> u64;

    fn read_u128(stream: &[u8]) -> u128;

    fn read_uint(stream: &[u8], bytes: usize) -> u64;

    fn read_uint128(stream: &[u8], bytes: usize) -> u128;

    fn write_u8(stream: &mut [u8], value: u8);

    fn write_u16(stream: &mut [u8], value: u16);

    fn write_u32(stream: &mut [u8], value: u32);

    fn write_u64(stream: &mut [u8], value: u64);

    fn write_u128(stream: &mut [u8], value: u128);

    fn write_uint(stream: &mut [u8], value: u64, bytes: usize);

    fn write_uint128(stream: &mut [u8], value: u128, bytes: usize);

    fn convert_slice_u16(values: &mut [u16]);

    fn convert_slice_u32(values: &mut [u32]);

    fn convert_slice_u64(values: &mut [u64]);

    fn convert_slice_u128(values: &mut [u128]);

    fn convert_slice_f32(values: &mut [f32]);

    fn convert_slice_f64(values: &mut [f64]);

    fn read_slice_u16(stream: &[u8], values: &mut [u16]);

    fn read_slice_u32(stream: &[u8], values: &mut [u32]);

    fn read_slice_u64(stream: &[u8], values: &mut [u64]);

    fn read_slice_u128(stream: &[u8], values: &mut [u128]);

    fn write_slice_u16(stream: &mut [u8], values: &[u16]);

    fn write_slice_u32(stream: &mut [u8], values: &[u32]);

    fn write_slice_u64(stream: &mut [u8], values: &[u64]);

    fn write_slice_u128(stream: &mut [u8], values: &[u128]);

    fn read_u24(stream: &[u8]) -> u32 { ... }

    fn read_i24(stream: &[u8]) -> i32 { ... }

    fn read_i8(stream: &[u8]) -> i8 { ... }

    fn read_i16(stream: &[u8]) -> i16 { ... }

    fn read_i32(stream: &[u8]) -> i32 { ... }

    fn read_i64(stream: &[u8]) -> i64 { ... }

    fn read_i128(stream: &[u8]) -> i128 { ... }

    fn read_int(stream: &[u8], bytes: usize) -> i64 { ... }

    fn read_int128(stream: &[u8], bytes: usize) -> i128 { ... }

    fn read_f32(stream: &[u8]) -> f32 { ... }

    fn read_f64(stream: &[u8]) -> f64 { ... }

    fn write_u24(stream: &mut [u8], value: u32) { ... }

    fn write_i24(stream: &mut [u8], value: i32) { ... }

    fn write_i16(stream: &mut [u8], value: i16) { ... }

    fn write_i32(stream: &mut [u8], value: i32) { ... }

    fn write_i64(stream: &mut [u8], value: i64) { ... }

    fn write_i128(stream: &mut [u8], value: i128) { ... }

    fn write_int(stream: &mut [u8], value: i64, bytes: usize) { ... }

    fn write_int128(stream: &mut [u8], value: i128, bytes: usize) { ... }

    fn write_f32(stream: &mut [u8], value: f32) { ... }

    fn write_f64(stream: &mut [u8], value: f64) { ... }

    fn read_slice_i16(stream: &[u8], values: &mut [i16]) { ... }

    fn read_slice_i32(stream: &[u8], values: &mut [i32]) { ... }

    fn read_slice_i64(stream: &[u8], values: &mut [i64]) { ... }

    fn read_slice_i128(stream: &[u8], values: &mut [i128]) { ... }

    fn read_slice_f32_unchecked(stream: &[u8], values: &mut [f32]) { ... }

    fn read_slice_f64_unchecked(stream: &[u8], values: &mut [f64]) { ... }

    fn write_slice_i16(stream: &mut [u8], values: &[i16]) { ... }

    fn write_slice_i32(stream: &mut [u8], values: &[i32]) { ... }

    fn write_slice_i64(stream: &mut [u8], values: &[i64]) { ... }

    fn write_slice_i128(stream: &mut [u8], values: &[i128]) { ... }

    fn write_slice_f32(stream: &mut [u8], values: &[f32]) { ... }

    fn write_slice_f64(stream: &mut [u8], values: &[f64]) { ... }

    fn convert_slice_i16(values: &mut [i16]) { ... }

    fn convert_slice_i32(values: &mut [i32]) { ... }

    fn convert_slice_i64(values: &mut [i64]) { ... }

    fn convert_slice_i128(values: &mut [i128]) { ... }
}

Required Methods

Provided Methods

Implementors