use crate::error::{Error, Result};
#[derive(Debug, Clone)]
pub struct ByteReader<'a> {
data: &'a [u8],
pos: usize,
base: u64,
}
macro_rules! read_le {
($($name:ident -> $ty:ty),* $(,)?) => {$(
#[doc = concat!("Reads a little-endian `", stringify!($ty), "`.")]
pub fn $name(&mut self) -> Result<$ty> {
let bytes = self.array::<{ std::mem::size_of::<$ty>() }>()?;
Ok(<$ty>::from_le_bytes(bytes))
}
)*};
}
impl<'a> ByteReader<'a> {
pub fn new(data: &'a [u8]) -> Self {
Self {
data,
pos: 0,
base: 0,
}
}
pub fn with_base(data: &'a [u8], base: u64) -> Self {
Self { data, pos: 0, base }
}
pub fn pos(&self) -> usize {
self.pos
}
pub fn offset(&self) -> u64 {
self.base.saturating_add(self.pos as u64)
}
pub fn len(&self) -> usize {
self.data.len()
}
pub fn is_empty(&self) -> bool {
self.data.is_empty()
}
pub fn remaining(&self) -> usize {
self.data.len().saturating_sub(self.pos)
}
pub fn at_end(&self) -> bool {
self.remaining() == 0
}
pub fn rest(&self) -> &'a [u8] {
self.data.get(self.pos..).unwrap_or(&[])
}
pub fn seek(&mut self, pos: usize) -> Result<()> {
if pos > self.data.len() {
return Err(self.truncated(pos.saturating_sub(self.data.len())));
}
self.pos = pos;
Ok(())
}
pub fn skip(&mut self, n: usize) -> Result<()> {
self.bytes(n).map(|_| ())
}
pub fn bytes(&mut self, n: usize) -> Result<&'a [u8]> {
let end = self.pos.checked_add(n).filter(|&e| e <= self.data.len());
match end.and_then(|e| self.data.get(self.pos..e).map(|s| (s, e))) {
Some((slice, e)) => {
self.pos = e;
Ok(slice)
}
None => Err(self.truncated(n.saturating_sub(self.remaining()))),
}
}
pub fn sub(&mut self, n: usize) -> Result<ByteReader<'a>> {
let base = self.offset();
let data = self.bytes(n)?;
Ok(ByteReader::with_base(data, base))
}
pub fn array<const N: usize>(&mut self) -> Result<[u8; N]> {
let slice = self.bytes(N)?;
let mut out = [0u8; N];
out.copy_from_slice(slice);
Ok(out)
}
pub fn peek(&self, n: usize) -> Result<&'a [u8]> {
self.pos
.checked_add(n)
.and_then(|e| self.data.get(self.pos..e))
.ok_or_else(|| self.truncated(n.saturating_sub(self.remaining())))
}
pub fn u8(&mut self) -> Result<u8> {
Ok(self.array::<1>()?[0])
}
pub fn i8(&mut self) -> Result<i8> {
Ok(i8::from_le_bytes(self.array::<1>()?))
}
read_le! {
u16 -> u16, i16 -> i16, u32 -> u32, i32 -> i32,
u64 -> u64, i64 -> i64, f32 -> f32, f64 -> f64,
}
pub fn u32_usize(&mut self) -> Result<usize> {
let at = self.offset();
let v = self.u32()?;
usize::try_from(v).map_err(|_| Error::invalid(at, "length does not fit in usize"))
}
pub fn truncated(&self, needed: usize) -> Error {
Error::Truncated {
offset: self.offset(),
needed: needed as u64,
}
}
pub fn invalid(&self, message: impl Into<String>) -> Error {
Error::invalid(self.offset(), message)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reads_little_endian_values() {
let data = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08];
let mut r = ByteReader::new(&data);
assert_eq!(r.u16().unwrap(), 0x0201);
assert_eq!(r.u32().unwrap(), 0x0605_0403);
assert_eq!(r.remaining(), 2);
}
#[test]
fn truncation_is_an_error_not_a_panic() {
let mut r = ByteReader::with_base(&[1, 2, 3], 100);
r.skip(2).unwrap();
match r.u32() {
Err(Error::Truncated { offset, needed }) => {
assert_eq!(offset, 102);
assert_eq!(needed, 3);
}
other => panic!("unexpected {other:?}"),
}
assert_eq!(r.pos(), 2, "failed read must not move the cursor");
assert!(r.bytes(usize::MAX).is_err());
assert!(r.seek(4).is_err());
}
#[test]
fn sub_reader_keeps_absolute_offsets() {
let data = [0u8; 16];
let mut r = ByteReader::with_base(&data, 1000);
r.skip(4).unwrap();
let mut s = r.sub(8).unwrap();
assert_eq!(s.offset(), 1004);
s.skip(8).unwrap();
assert!(matches!(s.u8(), Err(Error::Truncated { offset: 1012, .. })));
assert_eq!(r.pos(), 12);
}
}