Trait binreader::BinReader[−][src]

pub trait BinReader<'r> where
    Self: Sized + AsRef<[u8]> + Borrow<[u8]> + Read + BufRead, {
Show methods
    fn from_slice_with_offset(
        slice: &'r [u8], 
        initial_offset: usize, 
        endidness: Endidness
    ) -> Result<Self>;
    fn size(&self) -> usize;
    fn initial_offset(&self) -> usize;
    fn current_offset(&self) -> usize;
    fn endidness(&self) -> Endidness;
    fn change_endidness(&mut self, endidness: Endidness);
    fn advance_to(&self, offset: usize) -> Result<()>;
    fn advance_by(&self, num_bytes: isize) -> Result<()>;

    fn from_slice(slice: &'r [u8], endidness: Endidness) -> Result<Self> { ... }
    fn next_n_bytes(&self, num_bytes: usize) -> Result<Bytes> { ... }
    fn lower_offset_limit(&self) -> usize { ... }
    fn upper_offset_limit(&self) -> usize { ... }
    fn is_empty(&self) -> bool { ... }
    fn remaining(&self) -> usize { ... }
    fn validate_offset(&self, offset: usize, size: usize) -> Result<()> { ... }
    fn relative_offset(&self, abs_offset: usize) -> Result<usize> { ... }
    fn next_bytes_are(&self, prefix: &[u8]) -> Result<bool> { ... }
    fn bytes_at(&self, offset: usize, buf: &mut [u8]) -> Result<()> { ... }
    fn subseq(&self, offset: usize, num_bytes: usize) -> Result<&[u8]> { ... }
    fn range(&self, start: usize, end: usize) -> Result<&[u8]> { ... }
    fn next_bytes(&self, buf: &mut [u8]) -> Result<()> { ... }
    fn current_u8(&self) -> Result<u8> { ... }
    fn current_i8_ne(&self) -> Result<i8> { ... }
    fn current_u16_be(&self) -> Result<u16> { ... }
    fn current_u16_le(&self) -> Result<u16> { ... }
    fn current_i16_be(&self) -> Result<i16> { ... }
    fn current_i16_le(&self) -> Result<i16> { ... }
    fn current_u32_be(&self) -> Result<u32> { ... }
    fn current_u32_le(&self) -> Result<u32> { ... }
    fn current_i32_be(&self) -> Result<i32> { ... }
    fn current_i32_le(&self) -> Result<i32> { ... }
    fn current_u64_be(&self) -> Result<u64> { ... }
    fn current_u64_le(&self) -> Result<u64> { ... }
    fn current_i64_be(&self) -> Result<i64> { ... }
    fn current_i64_le(&self) -> Result<i64> { ... }
    fn current_u128_be(&self) -> Result<u128> { ... }
    fn current_u128_le(&self) -> Result<u128> { ... }
    fn current_i128_be(&self) -> Result<i128> { ... }
    fn current_i128_le(&self) -> Result<i128> { ... }
    fn u8_at(&self, offset: usize) -> Result<u8> { ... }
    fn i8_ne_at(&self, offset: usize) -> Result<i8> { ... }
    fn u16_be_at(&self, offset: usize) -> Result<u16> { ... }
    fn u16_le_at(&self, offset: usize) -> Result<u16> { ... }
    fn i16_be_at(&self, offset: usize) -> Result<i16> { ... }
    fn i16_le_at(&self, offset: usize) -> Result<i16> { ... }
    fn u32_be_at(&self, offset: usize) -> Result<u32> { ... }
    fn u32_le_at(&self, offset: usize) -> Result<u32> { ... }
    fn i32_be_at(&self, offset: usize) -> Result<i32> { ... }
    fn i32_le_at(&self, offset: usize) -> Result<i32> { ... }
    fn u64_be_at(&self, offset: usize) -> Result<u64> { ... }
    fn u64_le_at(&self, offset: usize) -> Result<u64> { ... }
    fn i64_be_at(&self, offset: usize) -> Result<i64> { ... }
    fn i64_le_at(&self, offset: usize) -> Result<i64> { ... }
    fn u128_be_at(&self, offset: usize) -> Result<u128> { ... }
    fn u128_le_at(&self, offset: usize) -> Result<u128> { ... }
    fn i128_be_at(&self, offset: usize) -> Result<i128> { ... }
    fn i128_le_at(&self, offset: usize) -> Result<i128> { ... }
    fn u16_at(&self, offset: usize) -> Result<u16> { ... }
    fn u32_at(&self, offset: usize) -> Result<u32> { ... }
    fn u64_at(&self, offset: usize) -> Result<u64> { ... }
    fn u128_at(&self, offset: usize) -> Result<u128> { ... }
    fn i16_at(&self, offset: usize) -> Result<i16> { ... }
    fn i32_at(&self, offset: usize) -> Result<i32> { ... }
    fn i64_at(&self, offset: usize) -> Result<i64> { ... }
    fn i128_at(&self, offset: usize) -> Result<i128> { ... }
    fn next_u8(&self) -> Result<u8> { ... }
    fn next_i8_ne(&self) -> Result<i8> { ... }
    fn next_u16_be(&self) -> Result<u16> { ... }
    fn next_u16_le(&self) -> Result<u16> { ... }
    fn next_i16_be(&self) -> Result<i16> { ... }
    fn next_i16_le(&self) -> Result<i16> { ... }
    fn next_u32_be(&self) -> Result<u32> { ... }
    fn next_u32_le(&self) -> Result<u32> { ... }
    fn next_i32_be(&self) -> Result<i32> { ... }
    fn next_i32_le(&self) -> Result<i32> { ... }
    fn next_u64_be(&self) -> Result<u64> { ... }
    fn next_u64_le(&self) -> Result<u64> { ... }
    fn next_i64_be(&self) -> Result<i64> { ... }
    fn next_i64_le(&self) -> Result<i64> { ... }
    fn next_u128_be(&self) -> Result<u128> { ... }
    fn next_u128_le(&self) -> Result<u128> { ... }
    fn next_i128_be(&self) -> Result<i128> { ... }
    fn next_i128_le(&self) -> Result<i128> { ... }
    fn next_u16(&self) -> Result<u16> { ... }
    fn next_u32(&self) -> Result<u32> { ... }
    fn next_u64(&self) -> Result<u64> { ... }
    fn next_u128(&self) -> Result<u128> { ... }
    fn next_i8(&self) -> Result<i8> { ... }
    fn next_i16(&self) -> Result<i16> { ... }
    fn next_i32(&self) -> Result<i32> { ... }
    fn next_i64(&self) -> Result<i64> { ... }
    fn next_i128(&self) -> Result<i128> { ... }
}

Expand description

The primary trait of this crate; a BinReader is designed to be a common interface between your program and binary data.

While not required, most BinReaders should implement the std::io::Read, std::io::Seek, std::io::BufRead, and std::borrow::Borrow<&[u8]> traits.

Additionally, there are two sub-traits of BinReader:

OwnableBinReader which owns the data contained within it.
SliceableBinReader which allows you to easily create SliceRefBinReaders from another reader.

Offsets

Instead of indexes, BinReaders use offsets. Now, in most cases these are probably going to be the same. However, you can specify an initial offset that will essentially change the index of zero to whatever the initial_offset is. For example:

let test_data = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05];
let reader = RandomAccessBinReader::from_slice_with_offset(&test_data, 100, Endidness::Big);
assert_eq!(reader.u8_at(100).unwrap(), 0);

Validation

One thing you may have noticed is that we had to unwrap the value. Most of a BinReader’s methods first check to make sure the provided offset is valid. For example:

assert!(matches!(reader.u8_at(99), Err(Error::OffsetTooSmall(99))));

Limits

The lower and upper limits of valid offsets can be retrieved via the BinReader::lower_offset_limit and BinReader::upper_offset_limit methods respectively.

An important note: the BinReader::size method returns how much data is in the reader, not what the highest valid offset is.

Trait binreader::BinReader[−][src]

Offsets

Validation

Limits

Required methods

Provided methods

Implementors