Trait bitstream_io::read::BitRead [−][src]
pub trait BitRead { fn read_bit(&mut self) -> Result<bool>; fn read<U>(&mut self, bits: u32) -> Result<U>
where
U: Numeric; fn read_signed<S>(&mut self, bits: u32) -> Result<S>
where
S: SignedNumeric; fn skip(&mut self, bits: u32) -> Result<()>; fn byte_aligned(&self) -> bool; fn byte_align(&mut self); fn read_bytes(&mut self, buf: &mut [u8]) -> Result<()> { ... } fn read_unary0(&mut self) -> Result<u32> { ... } fn read_unary1(&mut self) -> Result<u32> { ... } }
Expand description
A trait for anything that can read a variable number of potentially un-aligned values from an input stream
Required methods
Reads a single bit from the stream.
true
indicates 1, false
indicates 0
Errors
Passes along any I/O error from the underlying stream.
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.
fn read_signed<S>(&mut self, bits: u32) -> Result<S> where
S: SignedNumeric,
[src]
fn read_signed<S>(&mut self, bits: u32) -> Result<S> where
S: SignedNumeric,
[src]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.
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.
fn byte_aligned(&self) -> bool
[src]
fn byte_aligned(&self) -> bool
[src]Returns true if the stream is aligned at a whole byte.
fn byte_align(&mut self)
[src]
fn byte_align(&mut self)
[src]Throws away all unread bit values until the next whole byte. Does nothing if the stream is already aligned.
Provided methods
Completely fills the given buffer with whole bytes.
If the stream is already byte-aligned, it will 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.
fn read_unary0(&mut self) -> Result<u32>
[src]
fn read_unary0(&mut self) -> Result<u32>
[src]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.
fn read_unary1(&mut self) -> Result<u32>
[src]
fn read_unary1(&mut self) -> Result<u32>
[src]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.
Implementors
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);