Struct bitstream_io::read::BitReader [−][src]
pub struct BitReader<R: Read, E: Endianness> { /* fields omitted */ }
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
Wraps a BitReader around something that implements Read
Wraps a BitReader around something that implements Read
with the given endianness.
If stream is byte-aligned, provides mutable reference
to internal reader. Otherwise returns None
Converts BitReader
to ByteReader
in the same endianness.
Warning
Any unread partial bits are discarded.
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.
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);
Trait Implementations
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);
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
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
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);
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");
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);
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);
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);
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);
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');
Auto Trait Implementations
impl<R, E> RefUnwindSafe for BitReader<R, E> where
E: RefUnwindSafe,
R: RefUnwindSafe,
impl<R, E> UnwindSafe for BitReader<R, E> where
E: UnwindSafe,
R: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more