use crate::ContentPath;
use std::{
fmt::Debug,
io::{Read, Seek, SeekFrom},
ops::{Deref, DerefMut},
};
pub trait ContentType: Copy + Eq + PartialEq + Debug + Ord + PartialOrd {
const COUNT: u16;
fn as_u16(&self) -> u16;
fn from_u16(value: u16) -> Option<Self>;
}
pub trait Content<T: ContentType> {
fn content_type(&self) -> Option<T> {
None
}
fn set_content_type(&mut self, ty: T);
fn path(&self) -> &ContentPath;
fn size(&self) -> u64;
fn read(&mut self, offset: u64, count: u32) -> Option<&[u8]>;
}
pub trait ContentReadExt<T: ContentType>: Content<T> {
fn read_exact(&mut self, offset: u64, count: u32) -> Option<&[u8]> {
if count == 0 {
return Some(&[]);
}
let slice = self.read(offset, count)?;
(slice.len() == count as usize).then_some(slice)
}
fn read_into(&mut self, offset: u64, count: u32, output_buf: &mut [u8]) -> Option<usize> {
let size = self.size();
if offset > size {
return None;
}
if offset == size {
return Some(0);
}
let count = (size - offset).min(count as u64).min(output_buf.len() as u64) as usize;
let mut filled = 0usize;
while filled < count {
let want = ((count - filled).min(u32::MAX as usize)) as u32;
let src = self.read(offset + filled as u64, want)?;
if src.is_empty() {
break;
}
let n = src.len().min(count - filled);
output_buf[filled..filled + n].copy_from_slice(&src[..n]);
filled += n;
}
Some(filled)
}
unsafe fn read_struct<S: Copy>(&mut self, offset: u64) -> Option<S> {
let size = std::mem::size_of::<S>();
if size == 0 {
return Some(unsafe { std::mem::zeroed() });
}
if size > u32::MAX as usize {
return None;
}
let mut buf = std::mem::MaybeUninit::<S>::uninit();
let output_bytes: &mut [u8] = unsafe { std::slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut u8, size) };
match self.read_into(offset, size as u32, output_bytes) {
Some(n) if n == size => Some(unsafe { buf.assume_init() }),
_ => None,
}
}
fn read_byte(&mut self, offset: u64) -> Option<u8> {
self.read_exact(offset, 1).map(|b| b[0])
}
fn read_be_u16(&mut self, offset: u64) -> Option<u16> {
self.read_exact(offset, 2).map(|b| u16::from_be_bytes([b[0], b[1]]))
}
fn read_le_u16(&mut self, offset: u64) -> Option<u16> {
self.read_exact(offset, 2).map(|b| u16::from_le_bytes([b[0], b[1]]))
}
fn read_be_u32(&mut self, offset: u64) -> Option<u32> {
self.read_exact(offset, 4).map(|b| u32::from_be_bytes([b[0], b[1], b[2], b[3]]))
}
fn read_le_u32(&mut self, offset: u64) -> Option<u32> {
self.read_exact(offset, 4).map(|b| u32::from_le_bytes([b[0], b[1], b[2], b[3]]))
}
fn read_be_u64(&mut self, offset: u64) -> Option<u64> {
self.read_exact(offset, 8)
.map(|b| u64::from_be_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]))
}
fn read_le_u64(&mut self, offset: u64) -> Option<u64> {
self.read_exact(offset, 8)
.map(|b| u64::from_le_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]))
}
fn read_be_i16(&mut self, offset: u64) -> Option<i16> {
self.read_exact(offset, 2).map(|b| i16::from_be_bytes([b[0], b[1]]))
}
fn read_le_i16(&mut self, offset: u64) -> Option<i16> {
self.read_exact(offset, 2).map(|b| i16::from_le_bytes([b[0], b[1]]))
}
fn read_be_i32(&mut self, offset: u64) -> Option<i32> {
self.read_exact(offset, 4).map(|b| i32::from_be_bytes([b[0], b[1], b[2], b[3]]))
}
fn read_le_i32(&mut self, offset: u64) -> Option<i32> {
self.read_exact(offset, 4).map(|b| i32::from_le_bytes([b[0], b[1], b[2], b[3]]))
}
fn read_be_i64(&mut self, offset: u64) -> Option<i64> {
self.read_exact(offset, 8)
.map(|b| i64::from_be_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]))
}
fn read_le_i64(&mut self, offset: u64) -> Option<i64> {
self.read_exact(offset, 8)
.map(|b| i64::from_le_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]))
}
}
impl<T: ContentType, C: Content<T> + ?Sized> ContentReadExt<T> for C {}
impl ContentType for bool {
const COUNT: u16 = 2;
fn as_u16(&self) -> u16 {
*self as u16
}
fn from_u16(value: u16) -> Option<Self> {
if value == 0 {
Some(false)
} else if value == 1 {
Some(true)
} else {
None
}
}
}
#[derive(Debug, Copy, Clone)]
pub(crate) struct ContentPtr<T: ContentType> {
content: *mut dyn Content<T>,
}
impl<T: ContentType> ContentPtr<T> {
#[inline(always)]
pub(crate) fn new(content: &mut dyn Content<T>) -> Self {
Self {
content: unsafe { std::mem::transmute::<*mut dyn Content<T>, *mut (dyn Content<T> + 'static)>(content as *mut _) },
}
}
#[inline(always)]
pub(crate) fn as_mut(&mut self) -> &mut dyn Content<T> {
unsafe { &mut *self.content }
}
#[inline(always)]
pub(crate) fn as_ref(&self) -> &dyn Content<T> {
unsafe { &*self.content }
}
}
pub struct OwnedContentPtr<T: ContentType> {
content: *mut dyn Content<T>,
}
impl<T: ContentType> OwnedContentPtr<T> {
#[inline(always)]
pub(crate) fn new(content: ContentPtr<T>) -> Self {
Self { content: content.content }
}
}
impl<T: ContentType> Deref for OwnedContentPtr<T> {
type Target = dyn Content<T>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
unsafe { &*self.content }
}
}
impl<T: ContentType> DerefMut for OwnedContentPtr<T> {
#[inline(always)]
fn deref_mut(&mut self) -> &mut Self::Target {
unsafe { &mut *self.content }
}
}
pub struct ContentReader<T: ContentType> {
content: OwnedContentPtr<T>,
offset: u64,
}
impl<T: ContentType> ContentReader<T> {
pub fn new(content: OwnedContentPtr<T>) -> Self {
Self { content, offset: 0 }
}
}
impl<T: ContentType> Read for ContentReader<T> {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
if buf.is_empty() {
return Ok(0);
}
let len = self.content.size();
if self.offset >= len {
return Ok(0); }
let remaining = len - self.offset;
let want = (buf.len() as u64).min(remaining).min(u32::MAX as u64) as u32;
match self.content.read(self.offset, want) {
Some(src) => {
let n = src.len().min(buf.len());
buf[..n].copy_from_slice(&src[..n]);
self.offset += n as u64;
Ok(n)
}
None => Err(std::io::Error::new(
std::io::ErrorKind::UnexpectedEof,
"Content::read failed before end of content",
)),
}
}
}
impl<T: ContentType> Seek for ContentReader<T> {
fn seek(&mut self, pos: SeekFrom) -> std::io::Result<u64> {
let (base, delta) = match pos {
SeekFrom::Start(o) => {
self.offset = o;
return Ok(o);
}
SeekFrom::End(o) => (self.content.size(), o),
SeekFrom::Current(o) => (self.offset, o),
};
let new = if delta >= 0 {
base.checked_add(delta as u64)
} else {
base.checked_sub(delta.unsigned_abs())
};
match new {
Some(p) => {
self.offset = p;
Ok(p)
}
None => Err(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"seek to a negative or overflowing position",
)),
}
}
}