Struct bitstream_io::read::BitReaderLE

pub struct BitReaderLE<'a> { /* fields omitted */ }

A wrapper for reading values from a little-endian stream.

Methods

impl<'a> BitReaderLE<'a>

fn new(reader: &mut Read) -> BitReaderLE

Wraps a little-endian reader around a Read reference.

Trait Implementations

impl<'a> BitRead for BitReaderLE<'a>

fn read_bit(&mut self) -> Result<bool, Error>

Reads a single bit from the stream. true indicates 1, false indicates 0

fn read<U>(&mut self, bits: u32) -> Result<U, Error> where U: Numeric

Reads an unsigned value from the stream with the given number of bits. This method assumes that the programmer is using an output type sufficiently large to hold those bits.

fn skip(&mut self, bits: u32) -> Result<(), Error>

Skips the given number of bits in the stream. Since this method does not need an accumulator, it may be slightly faster than reading to an empty variable. In addition, since there is no accumulator, there is no upper limit on the number of bits which may be skipped. These bits are still read from the stream, however, and are never skipped via a seek method.

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

Completely fills the given buffer with whole bytes. If the stream is already byte-aligned, it will typically map to a faster read_exact call. Otherwise it will read bytes individually in 8-bit increments.

fn read_unary0(&mut self) -> Result<u32, Error>

Counts the number of 1 bits in the stream until the next 0 bit and returns the amount read. Because this field is variably-sized and may be large, its output is always a u32 type.

fn read_unary1(&mut self) -> Result<u32, Error>

Counts the number of 0 bits in the stream until the next 1 bit and returns the amount read. Because this field is variably-sized and may be large, its output is always a u32 type.

fn read_signed<S>(&mut self, bits: u32) -> Result<S, Error> where S: SignedNumeric

Reads a twos-complement signed value from the stream with the given number of bits. This method assumes that the programmer is using an output type sufficiently large to hold those bits.

fn byte_aligned(&self) -> bool

Returns true if the stream is aligned at a whole byte.

fn byte_align(&mut self)

Throws away all unread bit values until the next whole byte.

fn read_huffman<T>(&mut self, tree: &ReadHuffmanTree<T>) -> Result<T, Error> where T: Clone

Given a compiled Huffman tree, reads bits from the stream until the next symbol is encountered.