Struct binreader::SliceAsRefReader

pub struct SliceAsRefReader<R: AsRef<[u8]>> { /* fields omitted */ }

Trait Implementations

impl<R: AsRef<[u8]>> AsRef<[u8]> for SliceAsRefReader<R>

fn as_ref(&self) -> &[u8]

Performs the conversion.

impl<'r, R: AsRef<[u8]>> BinReader<'r> for SliceAsRefReader<R>

fn from_slice(
    slice: &'r [u8],
    initial_offset: usize,
    endidness: Endidness
) -> Result<Self>

fn initial_offset(&self) -> usize

fn size(&self) -> usize

fn remaining(&self) -> usize

fn current_offset(&self) -> usize

fn endidness(&self) -> Endidness

fn advance_to(&mut self, offset: usize) -> Result<()>

fn advance_by(&mut self, num_bytes: usize) -> Result<()>

fn next_u8(&mut self) -> Result<u8>

fn next_n_bytes(&mut self, num_bytes: usize) -> Result<Bytes>

fn lower_offset_limit(&self) -> usize

fn upper_offset_limit(&self) -> usize

fn is_empty(&self) -> bool

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>

Returns true if the next bytes are the same as the ones provided.

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(&mut self, buf: &mut [u8]) -> Result<()>

fn current_byte(&self) -> Result<u8>

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_i8(&mut self) -> Result<i8>

fn next_i8_ne(&mut self) -> Result<i8>

fn next_u16_be(&mut self) -> Result<u16>

fn next_u16_le(&mut self) -> Result<u16>

fn next_i16_be(&mut self) -> Result<i16>

fn next_i16_le(&mut self) -> Result<i16>

fn next_u32_be(&mut self) -> Result<u32>

fn next_u32_le(&mut self) -> Result<u32>

fn next_i32_be(&mut self) -> Result<i32>

fn next_i32_le(&mut self) -> Result<i32>

fn next_u64_be(&mut self) -> Result<u64>

fn next_u64_le(&mut self) -> Result<u64>

fn next_i64_be(&mut self) -> Result<i64>

fn next_i64_le(&mut self) -> Result<i64>

fn next_u128_be(&mut self) -> Result<u128>

fn next_u128_le(&mut self) -> Result<u128>

fn next_i128_be(&mut self) -> Result<i128>

fn next_i128_le(&mut self) -> Result<i128>

fn next_u16(&mut self) -> Result<u16>

fn next_u32(&mut self) -> Result<u32>

fn next_u64(&mut self) -> Result<u64>

fn next_u128(&mut self) -> Result<u128>

fn next_i16(&mut self) -> Result<i16>

fn next_i32(&mut self) -> Result<i32>

fn next_i64(&mut self) -> Result<i64>

fn next_i128(&mut self) -> Result<i128>