use std::fmt::Debug;
use std::fmt::Formatter;
use std::fmt::Result as FmtResult;
use std::io::Error as IoError;
use std::io::ErrorKind as IoErrorKind;
use std::io::Result as IoResult;
use qubit_io::ByteInput;
use qubit_io::Input;
use crate::error::FsEffectState;
use crate::error::FsError;
use crate::error::FsErrorKind;
use crate::metadata::OpenedFileInfo;
pub struct FileReader {
inner: Box<dyn ByteInput + Send>,
info: OpenedFileInfo,
}
impl FileReader {
#[inline]
#[must_use]
pub(crate) fn new(info: OpenedFileInfo, inner: Box<dyn ByteInput + Send>) -> Self {
Self { inner, info }
}
#[inline]
#[must_use]
pub fn info(&self) -> &OpenedFileInfo {
&self.info
}
}
impl Input for FileReader {
type Item = u8;
#[inline]
fn is_buffered(&self) -> bool {
self.inner.is_buffered()
}
#[inline]
unsafe fn read_unchecked(&mut self, output: &mut [u8], index: usize, count: usize) -> IoResult<usize> {
unsafe { self.inner.read_unchecked(output, index, count) }.map_err(|error| {
if error.kind() != IoErrorKind::Interrupted {
return error;
}
let unsafe_typed = error
.get_ref()
.and_then(|source| source.downcast_ref::<FsError>())
.is_some_and(|typed| {
typed.kind() != FsErrorKind::Interrupted
|| !matches!(typed.effect_state(), None | Some(FsEffectState::Unchanged))
});
if unsafe_typed {
let source = error.into_inner().expect("typed interruption retains its source");
IoError::other(source)
} else {
error
}
})
}
}
impl Debug for FileReader {
#[inline]
fn fmt(&self, formatter: &mut Formatter<'_>) -> FmtResult {
formatter
.debug_struct("FileReader")
.field("info", &self.info)
.finish_non_exhaustive()
}
}