Struct bitstream_io::read::BitReader [−][src]
pub struct BitReader<'a, E: Endianness> { /* fields omitted */ }
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.
Methods
impl<'a, E: Endianness> BitReader<'a, E>
[src]
impl<'a, E: Endianness> BitReader<'a, E>
pub fn new(reader: &mut Read) -> BitReader<E>
[src]
pub fn new(reader: &mut Read) -> BitReader<E>
Wraps a BitReader around something that implements Read
pub fn read_bit(&mut self) -> Result<bool, Error>
[src]
pub fn read_bit(&mut self) -> Result<bool, Error>
Reads a single bit from the stream.
true
indicates 1, false
indicates 0
Errors
Passes along any I/O error from the underlying stream.
Examples
use std::io::{Read, Cursor}; use bitstream_io::{BigEndian, BitReader}; let data = [0b10110111]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); 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}; let data = [0b10110111]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<LittleEndian>::new(&mut cursor); 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);
pub fn read<U>(&mut self, bits: u32) -> Result<U, Error> where
U: Numeric,
[src]
pub 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.
Errors
Passes along any I/O error from the underlying stream. Also returns an error if the output type is too small to hold the requested number of bits.
Examples
use std::io::{Read, Cursor}; use bitstream_io::{BigEndian, BitReader}; let data = [0b10110111]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); 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}; let data = [0b10110111]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<LittleEndian>::new(&mut cursor); 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}; let data = [0;10]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); 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
pub fn skip(&mut self, bits: u32) -> Result<(), Error>
[src]
pub 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.
Errors
Passes along any I/O error from the underlying stream.
Examples
use std::io::{Read, Cursor}; use bitstream_io::{BigEndian, BitReader}; let data = [0b10110111]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); assert!(reader.skip(3).is_ok()); assert_eq!(reader.read::<u8>(5).unwrap(), 0b10111);
use std::io::{Read, Cursor}; use bitstream_io::{LittleEndian, BitReader}; let data = [0b10110111]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<LittleEndian>::new(&mut cursor); assert!(reader.skip(3).is_ok()); assert_eq!(reader.read::<u8>(5).unwrap(), 0b10110);
pub fn read_bytes(&mut self, buf: &mut [u8]) -> Result<(), Error>
[src]
pub 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.
Errors
Passes along any I/O error from the underlying stream.
Example
use std::io::{Read, Cursor}; use bitstream_io::{BigEndian, BitReader}; let data = b"foobar"; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); assert!(reader.skip(24).is_ok()); let mut buf = [0;3]; assert!(reader.read_bytes(&mut buf).is_ok()); assert_eq!(&buf, b"bar");
pub fn read_unary0(&mut self) -> Result<u32, Error>
[src]
pub 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.
Errors
Passes along any I/O error from the underlying stream.
Examples
use std::io::{Read, Cursor}; use bitstream_io::{BigEndian, BitReader}; let data = [0b01110111, 0b11111110]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); 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}; let data = [0b11101110, 0b01111111]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<LittleEndian>::new(&mut cursor); assert_eq!(reader.read_unary0().unwrap(), 0); assert_eq!(reader.read_unary0().unwrap(), 3); assert_eq!(reader.read_unary0().unwrap(), 10);
pub fn read_unary1(&mut self) -> Result<u32, Error>
[src]
pub 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.
Errors
Passes along any I/O error from the underlying stream.
Examples
use std::io::{Read, Cursor}; use bitstream_io::{BigEndian, BitReader}; let data = [0b10001000, 0b00000001]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); 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}; let data = [0b00010001, 0b10000000]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<LittleEndian>::new(&mut cursor); assert_eq!(reader.read_unary1().unwrap(), 0); assert_eq!(reader.read_unary1().unwrap(), 3); assert_eq!(reader.read_unary1().unwrap(), 10);
pub fn byte_aligned(&self) -> bool
[src]
pub fn byte_aligned(&self) -> bool
Returns true if the stream is aligned at a whole byte.
Example
use std::io::{Read, Cursor}; use bitstream_io::{BigEndian, BitReader}; let data = [0]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); 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);
pub fn byte_align(&mut self)
[src]
pub fn byte_align(&mut self)
Throws away all unread bit values until the next whole byte. Does nothing if the stream is already aligned.
Example
use std::io::{Read, Cursor}; use bitstream_io::{BigEndian, BitReader}; let data = [0x00, 0xFF]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); assert_eq!(reader.read::<u8>(4).unwrap(), 0); reader.byte_align(); assert_eq!(reader.read::<u8>(8).unwrap(), 0xFF);
pub fn read_huffman<T>(
&mut self,
tree: &[ReadHuffmanTree<E, T>]
) -> Result<T, Error> where
T: Clone,
[src]
pub fn read_huffman<T>(
&mut self,
tree: &[ReadHuffmanTree<E, T>]
) -> Result<T, Error> where
T: Clone,
Given a compiled Huffman tree, reads bits from the stream until the next symbol is encountered.
Errors
Passes along any I/O error from the underlying stream.
Example
use std::io::{Read, Cursor}; use bitstream_io::{BigEndian, BitReader}; 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 cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); assert_eq!(reader.read_huffman(&tree).unwrap(), 'b'); assert_eq!(reader.read_huffman(&tree).unwrap(), 'c'); assert_eq!(reader.read_huffman(&tree).unwrap(), 'd');
pub fn into_unread(self) -> (u32, u8)
[src]
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}; let data = [0b1010_0101, 0b0101_1010]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); 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}; let data = [0b1010_0101, 0b0101_1010]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); assert_eq!(reader.read::<u16>(8).unwrap(), 0b1010_0101); let (bits, value) = reader.into_unread(); assert_eq!(bits, 0); assert_eq!(value, 0);
impl<'a> BitReader<'a, BigEndian>
[src]
impl<'a> BitReader<'a, BigEndian>
pub fn read_signed<S>(&mut self, bits: u32) -> Result<S, Error> where
S: SignedNumeric,
[src]
pub 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.
Errors
Passes along any I/O error from the underlying stream. Also returns an error if the output type is too small to hold the requested number of bits.
Examples
use std::io::{Read, Cursor}; use bitstream_io::{BigEndian, BitReader}; let data = [0b10110111]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<BigEndian>::new(&mut cursor); 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::{BigEndian, BitReader}; let data = [0;10]; let mut cursor = Cursor::new(&data); let mut r = BitReader::<BigEndian>::new(&mut cursor); 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
impl<'a> BitReader<'a, LittleEndian>
[src]
impl<'a> BitReader<'a, LittleEndian>
pub fn read_signed<S>(&mut self, bits: u32) -> Result<S, Error> where
S: SignedNumeric,
[src]
pub 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.
Errors
Passes along any I/O error from the underlying stream. Also returns an error if the output type is too small to hold the requested number of bits.
Examples
use std::io::{Read, Cursor}; use bitstream_io::{LittleEndian, BitReader}; let data = [0b10110111]; let mut cursor = Cursor::new(&data); let mut reader = BitReader::<LittleEndian>::new(&mut cursor); 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::{LittleEndian, BitReader}; let data = [0;10]; let mut cursor = Cursor::new(&data); let mut r = BitReader::<LittleEndian>::new(&mut cursor); 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