Struct bitstream_io::read::BitReader
source · pub struct BitReader<R: Read, E: Endianness> { /* private fields */ }
Expand description
For reading non-aligned bits from a stream of bytes in a given endianness.
This will read exactly as many whole bytes needed to return the requested number of bits. It may cache up to a single partial byte but no more.
Implementations
sourceimpl<R: Read, E: Endianness> BitReader<R, E>
impl<R: Read, E: Endianness> BitReader<R, E>
sourcepub fn new(reader: R) -> BitReader<R, E>
pub fn new(reader: R) -> BitReader<R, E>
Wraps a BitReader around something that implements Read
sourcepub fn endian(reader: R, _endian: E) -> BitReader<R, E>
pub fn endian(reader: R, _endian: E) -> BitReader<R, E>
Wraps a BitReader around something that implements Read
with the given endianness.
sourcepub fn into_reader(self) -> R
pub fn into_reader(self) -> R
sourcepub fn reader(&mut self) -> Option<&mut R>
pub fn reader(&mut self) -> Option<&mut R>
If stream is byte-aligned, provides mutable reference
to internal reader. Otherwise returns None
sourcepub fn into_bytereader(self) -> ByteReader<R, E>
pub fn into_bytereader(self) -> ByteReader<R, E>
Converts BitReader
to ByteReader
in the same endianness.
Warning
Any unread partial bits are discarded.
sourcepub fn bytereader(&mut self) -> Option<ByteReader<&mut R, E>>
pub fn bytereader(&mut self) -> Option<ByteReader<&mut R, E>>
If stream is byte-aligned, provides temporary ByteReader
in the same endianness. Otherwise returns None
Warning
Any reader bits left over when ByteReader
is dropped are lost.
sourcepub fn into_unread(self) -> (u32, u8)
pub fn into_unread(self) -> (u32, u8)
Consumes reader and returns any un-read partial byte
as a (bits, value)
tuple.
Examples
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0b1010_0101, 0b0101_1010];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.read::<u16>(9).unwrap(), 0b1010_0101_0);
let (bits, value) = reader.into_unread();
assert_eq!(bits, 7);
assert_eq!(value, 0b101_1010);
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0b1010_0101, 0b0101_1010];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.read::<u16>(8).unwrap(), 0b1010_0101);
let (bits, value) = reader.into_unread();
assert_eq!(bits, 0);
assert_eq!(value, 0);
sourceimpl<R, E> BitReader<R, E>where
E: Endianness,
R: Read + Seek,
impl<R, E> BitReader<R, E>where
E: Endianness,
R: Read + Seek,
sourcepub fn seek_bits(&mut self, from: SeekFrom) -> Result<u64>
pub fn seek_bits(&mut self, from: SeekFrom) -> Result<u64>
Example
use std::io::{Read, Cursor, SeekFrom};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0x00, 0xFF];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.position_in_bits().unwrap(), 0);
let pos = reader.seek_bits(SeekFrom::Start(5)).unwrap();
assert!(pos == 5 && 5 == reader.position_in_bits().unwrap());
let pos = reader.seek_bits(SeekFrom::Current(-2)).unwrap();
assert!(pos == 3 && 3 == reader.position_in_bits().unwrap()); ///
let pos = reader.seek_bits(SeekFrom::End(5)).unwrap();
assert!(pos == 11 && 11 == reader.position_in_bits().unwrap());
sourcepub fn position_in_bits(&mut self) -> Result<u64>
pub fn position_in_bits(&mut self) -> Result<u64>
Example
use std::fs::read;
use std::io::{Read, Cursor, SeekFrom};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0x00, 0xFF];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.position_in_bits().unwrap(), 0);
let _: i32 = reader.read_signed(5).unwrap();
assert_eq!(reader.position_in_bits().unwrap(), 5);
reader.read_bit().unwrap();
assert_eq!(reader.position_in_bits().unwrap(), 6);
Trait Implementations
sourceimpl<R: Read, E: Endianness> BitRead for BitReader<R, E>
impl<R: Read, E: Endianness> BitRead for BitReader<R, E>
sourcefn read_bit(&mut self) -> Result<bool>
fn read_bit(&mut self) -> Result<bool>
Examples
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0b10110111];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.read_bit().unwrap(), true);
assert_eq!(reader.read_bit().unwrap(), false);
assert_eq!(reader.read_bit().unwrap(), true);
assert_eq!(reader.read_bit().unwrap(), true);
assert_eq!(reader.read_bit().unwrap(), false);
assert_eq!(reader.read_bit().unwrap(), true);
assert_eq!(reader.read_bit().unwrap(), true);
assert_eq!(reader.read_bit().unwrap(), true);
use std::io::{Read, Cursor};
use bitstream_io::{LittleEndian, BitReader, BitRead};
let data = [0b10110111];
let mut reader = BitReader::endian(Cursor::new(&data), LittleEndian);
assert_eq!(reader.read_bit().unwrap(), true);
assert_eq!(reader.read_bit().unwrap(), true);
assert_eq!(reader.read_bit().unwrap(), true);
assert_eq!(reader.read_bit().unwrap(), false);
assert_eq!(reader.read_bit().unwrap(), true);
assert_eq!(reader.read_bit().unwrap(), true);
assert_eq!(reader.read_bit().unwrap(), false);
assert_eq!(reader.read_bit().unwrap(), true);
sourcefn read<U>(&mut self, bits: u32) -> Result<U>where
U: Numeric,
fn read<U>(&mut self, bits: u32) -> Result<U>where
U: Numeric,
Examples
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0b10110111];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.read::<u8>(1).unwrap(), 0b1);
assert_eq!(reader.read::<u8>(2).unwrap(), 0b01);
assert_eq!(reader.read::<u8>(5).unwrap(), 0b10111);
use std::io::{Read, Cursor};
use bitstream_io::{LittleEndian, BitReader, BitRead};
let data = [0b10110111];
let mut reader = BitReader::endian(Cursor::new(&data), LittleEndian);
assert_eq!(reader.read::<u8>(1).unwrap(), 0b1);
assert_eq!(reader.read::<u8>(2).unwrap(), 0b11);
assert_eq!(reader.read::<u8>(5).unwrap(), 0b10110);
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0;10];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert!(reader.read::<u8>(9).is_err()); // can't read 9 bits to u8
assert!(reader.read::<u16>(17).is_err()); // can't read 17 bits to u16
assert!(reader.read::<u32>(33).is_err()); // can't read 33 bits to u32
assert!(reader.read::<u64>(65).is_err()); // can't read 65 bits to u64
sourcefn read_signed<S>(&mut self, bits: u32) -> Result<S>where
S: SignedNumeric,
fn read_signed<S>(&mut self, bits: u32) -> Result<S>where
S: SignedNumeric,
Examples
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0b10110111];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.read_signed::<i8>(4).unwrap(), -5);
assert_eq!(reader.read_signed::<i8>(4).unwrap(), 7);
use std::io::{Read, Cursor};
use bitstream_io::{LittleEndian, BitReader, BitRead};
let data = [0b10110111];
let mut reader = BitReader::endian(Cursor::new(&data), LittleEndian);
assert_eq!(reader.read_signed::<i8>(4).unwrap(), 7);
assert_eq!(reader.read_signed::<i8>(4).unwrap(), -5);
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0;10];
let mut r = BitReader::endian(Cursor::new(&data), BigEndian);
assert!(r.read_signed::<i8>(9).is_err()); // can't read 9 bits to i8
assert!(r.read_signed::<i16>(17).is_err()); // can't read 17 bits to i16
assert!(r.read_signed::<i32>(33).is_err()); // can't read 33 bits to i32
assert!(r.read_signed::<i64>(65).is_err()); // can't read 65 bits to i64
sourcefn skip(&mut self, bits: u32) -> Result<()>
fn skip(&mut self, bits: u32) -> Result<()>
Examples
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0b10110111];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert!(reader.skip(3).is_ok());
assert_eq!(reader.read::<u8>(5).unwrap(), 0b10111);
use std::io::{Read, Cursor};
use bitstream_io::{LittleEndian, BitReader, BitRead};
let data = [0b10110111];
let mut reader = BitReader::endian(Cursor::new(&data), LittleEndian);
assert!(reader.skip(3).is_ok());
assert_eq!(reader.read::<u8>(5).unwrap(), 0b10110);
sourcefn read_bytes(&mut self, buf: &mut [u8]) -> Result<()>
fn read_bytes(&mut self, buf: &mut [u8]) -> Result<()>
Example
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = b"foobar";
let mut reader = BitReader::endian(Cursor::new(data), BigEndian);
assert!(reader.skip(24).is_ok());
let mut buf = [0;3];
assert!(reader.read_bytes(&mut buf).is_ok());
assert_eq!(&buf, b"bar");
sourcefn read_unary0(&mut self) -> Result<u32>
fn read_unary0(&mut self) -> Result<u32>
Examples
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0b01110111, 0b11111110];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.read_unary0().unwrap(), 0);
assert_eq!(reader.read_unary0().unwrap(), 3);
assert_eq!(reader.read_unary0().unwrap(), 10);
use std::io::{Read, Cursor};
use bitstream_io::{LittleEndian, BitReader, BitRead};
let data = [0b11101110, 0b01111111];
let mut reader = BitReader::endian(Cursor::new(&data), LittleEndian);
assert_eq!(reader.read_unary0().unwrap(), 0);
assert_eq!(reader.read_unary0().unwrap(), 3);
assert_eq!(reader.read_unary0().unwrap(), 10);
sourcefn read_unary1(&mut self) -> Result<u32>
fn read_unary1(&mut self) -> Result<u32>
Examples
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0b10001000, 0b00000001];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.read_unary1().unwrap(), 0);
assert_eq!(reader.read_unary1().unwrap(), 3);
assert_eq!(reader.read_unary1().unwrap(), 10);
use std::io::{Read, Cursor};
use bitstream_io::{LittleEndian, BitReader, BitRead};
let data = [0b00010001, 0b10000000];
let mut reader = BitReader::endian(Cursor::new(&data), LittleEndian);
assert_eq!(reader.read_unary1().unwrap(), 0);
assert_eq!(reader.read_unary1().unwrap(), 3);
assert_eq!(reader.read_unary1().unwrap(), 10);
sourcefn byte_aligned(&self) -> bool
fn byte_aligned(&self) -> bool
Example
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.byte_aligned(), true);
assert!(reader.skip(1).is_ok());
assert_eq!(reader.byte_aligned(), false);
assert!(reader.skip(7).is_ok());
assert_eq!(reader.byte_aligned(), true);
sourcefn byte_align(&mut self)
fn byte_align(&mut self)
Example
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, BitRead};
let data = [0x00, 0xFF];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.read::<u8>(4).unwrap(), 0);
reader.byte_align();
assert_eq!(reader.read::<u8>(8).unwrap(), 0xFF);
sourceimpl<R: Read, E: Endianness> HuffmanRead<E> for BitReader<R, E>
impl<R: Read, E: Endianness> HuffmanRead<E> for BitReader<R, E>
sourcefn read_huffman<T>(&mut self, tree: &[ReadHuffmanTree<E, T>]) -> Result<T>where
T: Clone,
fn read_huffman<T>(&mut self, tree: &[ReadHuffmanTree<E, T>]) -> Result<T>where
T: Clone,
Example
use std::io::{Read, Cursor};
use bitstream_io::{BigEndian, BitReader, HuffmanRead};
use bitstream_io::huffman::compile_read_tree;
let tree = compile_read_tree(
vec![('a', vec![0]),
('b', vec![1, 0]),
('c', vec![1, 1, 0]),
('d', vec![1, 1, 1])]).unwrap();
let data = [0b10110111];
let mut reader = BitReader::endian(Cursor::new(&data), BigEndian);
assert_eq!(reader.read_huffman(&tree).unwrap(), 'b');
assert_eq!(reader.read_huffman(&tree).unwrap(), 'c');
assert_eq!(reader.read_huffman(&tree).unwrap(), 'd');