Trait Bits

pub trait Bits {
    // Required method
    fn next_u8(&mut self) -> Result<Option<u8>, BitsError>;

    // Provided methods
    fn read_u8(&mut self) -> Result<u8, BitsError> { ... }
    fn read_i8(&mut self) -> Result<i8, BitsError> { ... }
    fn next_i8(&mut self) -> Result<Option<i8>, BitsError> { ... }
    fn read_bool(&mut self) -> Result<bool, BitsError> { ... }
    fn next_bool(&mut self) -> Result<Option<bool>, BitsError> { ... }
    fn read_be_utf8_char(&mut self) -> Result<char, BitsError> { ... }
    fn read_be_u16(&mut self) -> Result<u16, BitsError> { ... }
    fn read_le_u16(&mut self) -> Result<u16, BitsError> { ... }
    fn next_be_u16(&mut self) -> Result<Option<u16>, BitsError> { ... }
    fn next_le_u16(&mut self) -> Result<Option<u16>, BitsError> { ... }
    fn read_be_u32(&mut self) -> Result<u32, BitsError> { ... }
    fn read_le_u32(&mut self) -> Result<u32, BitsError> { ... }
    fn next_be_u32(&mut self) -> Result<Option<u32>, BitsError> { ... }
    fn next_le_u32(&mut self) -> Result<Option<u32>, BitsError> { ... }
    fn read_be_u64(&mut self) -> Result<u64, BitsError> { ... }
    fn read_le_u64(&mut self) -> Result<u64, BitsError> { ... }
    fn next_be_u64(&mut self) -> Result<Option<u64>, BitsError> { ... }
    fn next_le_u64(&mut self) -> Result<Option<u64>, BitsError> { ... }
    fn read_be_u128(&mut self) -> Result<u128, BitsError> { ... }
    fn next_be_u128(&mut self) -> Result<Option<u128>, BitsError> { ... }
    fn read_be_i128(&mut self) -> Result<i128, BitsError> { ... }
    fn next_be_i128(&mut self) -> Result<Option<i128>, BitsError> { ... }
    fn read_be_f32(&mut self) -> Result<f32, BitsError> { ... }
    fn read_le_f32(&mut self) -> Result<f32, BitsError> { ... }
    fn read_f32(&mut self, order: ByteOrder) -> Result<f32, BitsError> { ... }
    fn next_be_f32(&mut self) -> Result<Option<f32>, BitsError> { ... }
    fn next_le_f32(&mut self) -> Result<Option<f32>, BitsError> { ... }
    fn read_be_f64(&mut self) -> Result<f64, BitsError> { ... }
    fn read_le_f64(&mut self) -> Result<f64, BitsError> { ... }
    fn next_be_f64(&mut self) -> Result<Option<f64>, BitsError> { ... }
    fn next_le_f64(&mut self) -> Result<Option<f64>, BitsError> { ... }
    fn read_f64(&mut self, order: ByteOrder) -> Result<f64, BitsError> { ... }
    fn read_be_i16(&mut self) -> Result<i16, BitsError> { ... }
    fn read_le_i16(&mut self) -> Result<i16, BitsError> { ... }
    fn next_be_i16(&mut self) -> Result<Option<i16>, BitsError> { ... }
    fn next_le_i16(&mut self) -> Result<Option<i16>, BitsError> { ... }
    fn read_be_i32(&mut self) -> Result<i32, BitsError> { ... }
    fn read_le_i32(&mut self) -> Result<i32, BitsError> { ... }
    fn next_be_i32(&mut self) -> Result<Option<i32>, BitsError> { ... }
    fn next_le_i32(&mut self) -> Result<Option<i32>, BitsError> { ... }
    fn read_be_i64(&mut self) -> Result<i64, BitsError> { ... }
    fn read_le_i64(&mut self) -> Result<i64, BitsError> { ... }
    fn next_be_i64(&mut self) -> Result<Option<i64>, BitsError> { ... }
    fn next_le_i64(&mut self) -> Result<Option<i64>, BitsError> { ... }
    fn read_le_i128(&mut self) -> Result<i128, BitsError> { ... }
    fn next_le_i128(&mut self) -> Result<Option<i128>, BitsError> { ... }
    fn read_le_u128(&mut self) -> Result<u128, BitsError> { ... }
    fn next_le_u128(&mut self) -> Result<Option<u128>, BitsError> { ... }
    fn advance(&mut self, len: usize) -> Result<usize, BitsError> { ... }
    fn read_u8_blob_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>
       where T: MutBits { ... }
    fn read_u16_blob_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>
       where T: MutBits { ... }
    fn read_u32_blob_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>
       where T: MutBits { ... }
    fn read_u64_blob_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>
       where T: MutBits { ... }
    fn read_exact<const N: usize>(&mut self) -> Result<[u8; N], BitsError> { ... }
    fn read_exact_into<T>(
        &mut self,
        size: usize,
        into: &mut T,
    ) -> Result<(), BitsError>
       where T: MutBits { ... }
    fn read_all_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>
       where T: MutBits { ... }
    fn read_some_into<T>(&mut self, buf: &mut T) -> Result<usize, BitsError>
       where T: MutBits { ... }
    fn read_u16(&mut self, order: ByteOrder) -> Result<u16, BitsError> { ... }
    fn read_u32(&mut self, order: ByteOrder) -> Result<u32, BitsError> { ... }
    fn read_u64(&mut self, order: ByteOrder) -> Result<u64, BitsError> { ... }
    fn read_u128(&mut self, order: ByteOrder) -> Result<u128, BitsError> { ... }
    fn read_i16(&mut self, order: ByteOrder) -> Result<i16, BitsError> { ... }
    fn read_i32(&mut self, order: ByteOrder) -> Result<i32, BitsError> { ... }
    fn read_i64(&mut self, order: ByteOrder) -> Result<i64, BitsError> { ... }
    fn read_i128(&mut self, order: ByteOrder) -> Result<i128, BitsError> { ... }
}

Read methods for the primitive types

Required Methods

fn next_u8(&mut self) -> Result<Option<u8>, BitsError>

Optionally returns a single u8

Provided Methods

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

Reads a single u8

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

Reads a single i8

fn next_i8(&mut self) -> Result<Option<i8>, BitsError>

Optionally returns a single i8

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

Reads a single bool (u8), returning true if 1, false if 0, or InvalidInput if anything else.

fn next_bool(&mut self) -> Result<Option<bool>, BitsError>

Reads a single bool (u8), returning true if 1, false if 0, or InvalidInput if anything else.

fn read_be_utf8_char(&mut self) -> Result<char, BitsError>

Reads 1, 2, 3, or 4 bytes to construct a UTF-8 charpoint.

fn read_be_u16(&mut self) -> Result<u16, BitsError>

Reads a single u16 in big-endian order, 2 bytes, MSB first.

fn read_le_u16(&mut self) -> Result<u16, BitsError>

Reads a single u16 in little-endian order, 2 bytes, LSB first.

fn next_be_u16(&mut self) -> Result<Option<u16>, BitsError>

Optionally reads a single u16 in big-endian order, 2 bytes, MSB first.

fn next_le_u16(&mut self) -> Result<Option<u16>, BitsError>

Optionally reads a single u16 in little-endian order, 2 bytes, LSB first.

fn read_be_u32(&mut self) -> Result<u32, BitsError>

Reads a single u32 in big-endian order, 4 bytes, MSB first.

fn read_le_u32(&mut self) -> Result<u32, BitsError>

Reads a single u32 in little-endian order, 4 bytes, LSB first.

fn next_be_u32(&mut self) -> Result<Option<u32>, BitsError>

Optionally reads a single u32 in big-endian order, 4 bytes, MSB first.

fn next_le_u32(&mut self) -> Result<Option<u32>, BitsError>

Optionally reads a single u32 in little-endian order, 4 bytes, LSB first.

fn read_be_u64(&mut self) -> Result<u64, BitsError>

Reads a single u64 in big-endian order, 8 bytes, MSB first.

fn read_le_u64(&mut self) -> Result<u64, BitsError>

Reads a single u64 in big-endian order, 8 bytes, MSB first.

fn next_be_u64(&mut self) -> Result<Option<u64>, BitsError>

Optionally reads a single u64 in big-endian order, 8 bytes, MSB first.

fn next_le_u64(&mut self) -> Result<Option<u64>, BitsError>

Optionally reads a single u64 in little-endian order, 4 bytes, LSB first.

fn read_be_u128(&mut self) -> Result<u128, BitsError>

Reads a single u128 in big-endian order, 16 bytes, MSB first.

fn next_be_u128(&mut self) -> Result<Option<u128>, BitsError>

Optionally reads a single u128 in big-endian order, 16 bytes, MSB first.

fn read_be_i128(&mut self) -> Result<i128, BitsError>

Reads a single i128 in big-endian order, 16 bytes, MSB first.

fn next_be_i128(&mut self) -> Result<Option<i128>, BitsError>

Optionally reads a single i128 in big-endian order, 16 bytes, MSB first.

fn read_be_f32(&mut self) -> Result<f32, BitsError>

Reads a single f32, 4 bytes. Standard IEEE754 encoding

fn read_le_f32(&mut self) -> Result<f32, BitsError>

Reads a single f32, 4 bytes. Reversed IEEE754 encoding

fn read_f32(&mut self, order: ByteOrder) -> Result<f32, BitsError>

Reads a single f32, 4 bytes. Specified byte ordering.

fn next_be_f32(&mut self) -> Result<Option<f32>, BitsError>

Optionally reads a single f32, 4 bytes. Standard IEEE754 encoding

fn next_le_f32(&mut self) -> Result<Option<f32>, BitsError>

Optionally reads a single f32, 4 bytes. Reversed IEEE754 encoding

fn read_be_f64(&mut self) -> Result<f64, BitsError>

Reads a single f64, 8 bytes. Standard IEEE754 encoding

fn read_le_f64(&mut self) -> Result<f64, BitsError>

Reads a single f64, 8 bytes. Reversed IEEE754 encoding

fn next_be_f64(&mut self) -> Result<Option<f64>, BitsError>

Optionally reads a single f64, 8 bytes. Standard IEEE754 encoding

fn next_le_f64(&mut self) -> Result<Option<f64>, BitsError>

Optionally reads a single f64, 8 bytes. Reversed IEEE754 encoding

fn read_f64(&mut self, order: ByteOrder) -> Result<f64, BitsError>

Reads a single f64, 8 bytes. Specified byte ordering.

fn read_be_i16(&mut self) -> Result<i16, BitsError>

Reads a single i16 in big-endian order, 2 bytes, MSB first.

fn read_le_i16(&mut self) -> Result<i16, BitsError>

Reads a single i16 in little-endian order, 2 bytes, LSB first.

fn next_be_i16(&mut self) -> Result<Option<i16>, BitsError>

Optionally reads a single i16 in big-endian order, 2 bytes, MSB first.

fn next_le_i16(&mut self) -> Result<Option<i16>, BitsError>

Optionally reads a single i16 in little-endian order, 2 bytes, LSB first.

fn read_be_i32(&mut self) -> Result<i32, BitsError>

Reads a single i32 in big-endian order, 4 bytes, MSB first.

fn read_le_i32(&mut self) -> Result<i32, BitsError>

Reads a single i32 in little-endian order, 4 bytes, LSB first.

fn next_be_i32(&mut self) -> Result<Option<i32>, BitsError>

Optionally reads a single i32 in big-endian order, 4 bytes, MSB first.

fn next_le_i32(&mut self) -> Result<Option<i32>, BitsError>

Optionally reads a single i32 in little-endian order, 4 bytes,LSB first.

fn read_be_i64(&mut self) -> Result<i64, BitsError>

Reads a single i64 in big-endian order, 8 bytes, MSB first.

fn read_le_i64(&mut self) -> Result<i64, BitsError>

Reads a single i64 in little-endian order, 8 bytes, LSB first.

fn next_be_i64(&mut self) -> Result<Option<i64>, BitsError>

Optionally reads a single i64 in big-endian order, 8 bytes, MSB first.

fn next_le_i64(&mut self) -> Result<Option<i64>, BitsError>

Optionally reads a single i64 in little-endian order, 8 bytes, LSB first.

fn read_le_i128(&mut self) -> Result<i128, BitsError>

Reads a single i128 in little-endian order, 8 bytes, LSB first.

fn next_le_i128(&mut self) -> Result<Option<i128>, BitsError>

Optionally reads a single i64 in little-endian order, 8 bytes, LSB first.

fn read_le_u128(&mut self) -> Result<u128, BitsError>

Reads a single u128 in little-endian order, 8 bytes, LSB first.

fn next_le_u128(&mut self) -> Result<Option<u128>, BitsError>

Optionally reads a single i64 in little-endian order, 8 bytes, LSB first.

fn advance(&mut self, len: usize) -> Result<usize, BitsError>

Advances the stream by at most ‘len’ bytes. The actual amount of bytes advanced may be less, and is returned in [Ok(usize)]

fn read_u8_blob_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>

where T: MutBits,

fn read_u16_blob_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>

where T: MutBits,

fn read_u32_blob_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>

where T: MutBits,

fn read_u64_blob_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>

where T: MutBits,

fn read_exact<const N: usize>(&mut self) -> Result<[u8; N], BitsError>

Reads the specified amount of bytes into a stack-allocated array.

fn read_exact_into<T>( &mut self, size: usize, into: &mut T, ) -> Result<(), BitsError>

where T: MutBits,

Reads the specified amount of bytes into the specified target.

fn read_all_into<T>(&mut self, into: &mut T) -> Result<(), BitsError>

where T: MutBits,

Reads to the end of the stream, and writes it into the specified target.

fn read_some_into<T>(&mut self, buf: &mut T) -> Result<usize, BitsError>

where T: MutBits,

Reads some subset of the data into the specified target.

fn read_u16(&mut self, order: ByteOrder) -> Result<u16, BitsError>

Reads a single u16 in the specified order order, 2 bytes.

fn read_u32(&mut self, order: ByteOrder) -> Result<u32, BitsError>

Reads a single u32 in the specified order order, 4 bytes.

fn read_u64(&mut self, order: ByteOrder) -> Result<u64, BitsError>

Reads a single u64 in the specified order order, 8 bytes.

fn read_u128(&mut self, order: ByteOrder) -> Result<u128, BitsError>

Reads a single u128 in the specified order order, 16 bytes.

fn read_i16(&mut self, order: ByteOrder) -> Result<i16, BitsError>

Reads a single i16 in the specified order order, 2 bytes.

fn read_i32(&mut self, order: ByteOrder) -> Result<i32, BitsError>

Reads a single i32 in the specified order order, 4 bytes.

fn read_i64(&mut self, order: ByteOrder) -> Result<i64, BitsError>

Reads a single i64 in the specified order order, 4 bytes.

fn read_i128(&mut self, order: ByteOrder) -> Result<i128, BitsError>

Reads a single i128 in the specified order order, 16 bytes.

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 Bits for &[u8]

fn next_u8(&mut self) -> Result<Option<u8>, BitsError>

fn read_some_into<T>(&mut self, into: &mut T) -> Result<usize, BitsError>

where T: MutBits,

impl Bits for &mut [u8]

fn next_u8(&mut self) -> Result<Option<u8>, BitsError>

fn read_some_into<T>(&mut self, into: &mut T) -> Result<usize, BitsError>

where T: MutBits,

Implementors

impl<'a, const N: usize> Bits for BitsArray<'a, N>