use alloc::vec::Vec;
use crate::error::{Error, Result};
use crate::ident::Endian;
pub trait ReadAt {
fn read_at(&self, offset: u64, buf: &mut [u8]) -> Result<usize>;
fn size(&self) -> Option<u64> {
None
}
fn read_exact_at(&self, offset: u64, buf: &mut [u8]) -> Result<()> {
let expected = buf.len();
let mut total = 0usize;
while total < expected {
let current = offset
.checked_add(total as u64)
.ok_or_else(|| Error::offset_out_of_bounds(offset, expected as u64))?;
let count = self.read_at(current, &mut buf[total..])?;
if count == 0 {
return Err(Error::buffer_too_small(expected, total));
}
if count > expected - total {
return Err(Error::generic(
"ReadAt::read_at reported more bytes than the supplied buffer",
));
}
total += count;
}
Ok(())
}
fn read_u16_at(&self, offset: u64, endian: Endian) -> Result<u16> {
let mut buf = [0u8; 2];
self.read_exact_at(offset, &mut buf)?;
Ok(endian.u16(buf))
}
fn read_u32_at(&self, offset: u64, endian: Endian) -> Result<u32> {
let mut buf = [0u8; 4];
self.read_exact_at(offset, &mut buf)?;
Ok(endian.u32(buf))
}
fn read_u64_at(&self, offset: u64, endian: Endian) -> Result<u64> {
let mut buf = [0u8; 8];
self.read_exact_at(offset, &mut buf)?;
Ok(endian.u64(buf))
}
fn read_i32_at(&self, offset: u64, endian: Endian) -> Result<i32> {
let mut buf = [0u8; 4];
self.read_exact_at(offset, &mut buf)?;
Ok(endian.i32(buf))
}
fn read_i64_at(&self, offset: u64, endian: Endian) -> Result<i64> {
let mut buf = [0u8; 8];
self.read_exact_at(offset, &mut buf)?;
Ok(endian.i64(buf))
}
fn read_bytes_at(&self, offset: u64, len: usize) -> Result<Vec<u8>> {
let mut buf = Vec::new();
buf.try_reserve_exact(len)
.map_err(|_| Error::generic("reader request is too large to allocate"))?;
buf.resize(len, 0);
self.read_exact_at(offset, &mut buf)?;
Ok(buf)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SliceReader<'a> {
data: &'a [u8],
}
impl<'a> SliceReader<'a> {
#[must_use]
pub const fn new(data: &'a [u8]) -> Self {
Self { data }
}
#[must_use]
pub const fn as_bytes(&self) -> &'a [u8] {
self.data
}
}
impl ReadAt for SliceReader<'_> {
fn read_at(&self, offset: u64, buf: &mut [u8]) -> Result<usize> {
let Ok(start) = usize::try_from(offset) else {
return Ok(0);
};
let Some(available) = self.data.get(start..) else {
return Ok(0);
};
let count = available.len().min(buf.len());
buf[..count].copy_from_slice(&available[..count]);
Ok(count)
}
fn size(&self) -> Option<u64> {
Some(self.data.len() as u64)
}
}
#[derive(Debug, Clone)]
pub struct VecReader {
data: Vec<u8>,
}
impl VecReader {
#[must_use]
pub const fn new(data: Vec<u8>) -> Self {
Self { data }
}
#[must_use]
pub fn as_bytes(&self) -> &[u8] {
&self.data
}
#[must_use]
pub fn into_bytes(self) -> Vec<u8> {
self.data
}
}
impl ReadAt for VecReader {
fn read_at(&self, offset: u64, buf: &mut [u8]) -> Result<usize> {
SliceReader::new(&self.data).read_at(offset, buf)
}
fn size(&self) -> Option<u64> {
Some(self.data.len() as u64)
}
}
#[cfg(feature = "std")]
pub use file::FileReader;
#[cfg(feature = "std")]
mod file {
use std::cell::RefCell;
use std::fs::File;
use std::io::{Read, Seek, SeekFrom};
use std::path::Path;
use crate::error::Result;
use super::ReadAt;
#[derive(Debug)]
pub struct FileReader {
file: RefCell<File>,
size: u64,
}
impl FileReader {
pub fn new(file: File) -> Result<Self> {
let size = file.metadata()?.len();
Ok(Self {
file: RefCell::new(file),
size,
})
}
pub fn open(path: impl AsRef<Path>) -> Result<Self> {
Self::new(File::open(path)?)
}
}
impl ReadAt for FileReader {
fn read_at(&self, offset: u64, buf: &mut [u8]) -> Result<usize> {
let mut file = self.file.borrow_mut();
file.seek(SeekFrom::Start(offset))?;
Ok(file.read(buf)?)
}
fn size(&self) -> Option<u64> {
Some(self.size)
}
}
}