Struct BitReader 

pub struct BitReader<R: Read> { /* private fields */ }

Implementations

impl<R: Read> BitReader<R>

pub fn new(inner: R) -> Self

pub fn with_byte_order(byte_order: ByteOrder, inner: R) -> Self

impl<R: Read> BitReader<R>

pub fn is_byte_aligned(&self) -> bool

Returns true if at byte boundary (no pending bits)

When true:

• read() operations are permitted
• Next bit read will start from a fresh byte

Trait Implementations

impl<R: Read> BitRead for BitReader<R>

fn read_bits(&mut self, n: usize) -> Result<Self::Output>

Reads exactly n bits from the stream (1-64 bits)

Arguments

• n - Number of bits to read (1 to 64 inclusive)

Returns

Bits read

Errors

Returns error if n is not between 1-64 or not enough bits are available

type Output = u64

impl<R: Read> Read for BitReader<R>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Reads bytes from the underlying bit stream.

This method behaves differently depending on the bit buffer state:

• When the bit buffer is empty (byte-aligned state), it delegates directly to the inner reader
• When the bit buffer contains unconsumed bits (non-byte-aligned state), it returns an UnalignedAccess error

Byte Alignment Requirement

The fundamental reason for this behavior is bit stream integrity. When partially consumed bits exist in the buffer:

1. Direct byte access would bypass the bit buffer’s state tracking
2. Reading bytes would consume underlying bytes that contain the remaining portions of partially read bit sequences
3. This would irreversibly corrupt the bit-level parsing state

Correct Usage

To read byte data:

1. Use is_byte_aligned() to check if you’re in byte-aligned state
2. For mixed bit/byte reading, always consume all bits in the current byte before reading bytes

Errors

Returns BitReadWriteError::UnalignedAccess (wrapped in io::Error) when called with non-empty bit buffer. This prevents:

• Undefined state transitions
• Silent data corruption
• Loss of partially buffered bits

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_, u8>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact( &mut self, cursor: BorrowedCursor<'_, u8>, ) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

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

where Self: Sized,

🔬This is a nightly-only experimental API. (read_array)

Read and return a fixed array of bytes from this source.

fn read_le<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

🔬This is a nightly-only experimental API. (read_le)

Read and return a type (e.g. an integer) in little-endian order.

fn read_be<T>(&mut self) -> Result<T, Error>

where T: FromEndianBytes, Self: Sized,

🔬This is a nightly-only experimental API. (read_le)

Read and return a type (e.g. an integer) in big-endian order.