use std::ops::Range;
use super::{py_align, py_read, py_string_to_null_found, py_string_window, py_unpack_from};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum ReaderKind {
#[default]
Memory,
Stream,
BytesIo,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, thiserror::Error)]
pub enum StreamRefusal {
#[error("Position cannot be negative")]
NegativePosition,
#[error("cannot fit 'int' into an offset-sized integer")]
PositionTooLarge,
#[error("read length must be non-negative or -1")]
NegativeRead,
#[error("byte string is too large")]
ReadTooLarge,
#[error("cannot fit 'int' into an index-sized integer")]
ReadSizeOverflow,
}
impl StreamRefusal {
#[must_use]
pub fn exception(self) -> &'static str {
match self {
Self::NegativePosition | Self::PositionTooLarge | Self::NegativeRead => "ValueError",
Self::ReadTooLarge | Self::ReadSizeOverflow => "OverflowError",
}
}
#[must_use]
pub fn message(self) -> &'static str {
match self {
Self::NegativePosition => "Position cannot be negative",
Self::PositionTooLarge => "cannot fit 'int' into an offset-sized integer",
Self::NegativeRead => "read length must be non-negative or -1",
Self::ReadTooLarge => "byte string is too large",
Self::ReadSizeOverflow => "cannot fit 'int' into an index-sized integer",
}
}
}
impl From<StreamRefusal> for crate::error::Error {
fn from(e: StreamRefusal) -> Self {
Self::Malformed {
what: STREAM_READER,
detail: e.message().into(),
}
}
}
const _: () = {
crate::send_sync::<ReaderKind>();
crate::send_sync::<StreamRefusal>();
};
pub const STREAM_READER: &str = "stream reader";
const READ_TOO_LARGE: i64 = i64::MAX - 32;
impl ReaderKind {
pub fn seek(self, pos: i128) -> Result<i128, StreamRefusal> {
match self {
Self::Stream | Self::BytesIo if pos < 0 => Err(StreamRefusal::NegativePosition),
Self::Stream | Self::BytesIo if pos > i128::from(i64::MAX) => {
Err(StreamRefusal::PositionTooLarge)
}
Self::Memory | Self::Stream | Self::BytesIo => Ok(pos),
}
}
pub fn align(self, pos: i128, n: u32) -> Result<i128, StreamRefusal> {
self.seek(py_align(pos, n))
}
pub fn read(
self,
len: usize,
pos: i128,
size: i64,
) -> Result<(Range<usize>, i128), StreamRefusal> {
match self {
Self::Memory => Ok(py_read(len, pos, size)),
Self::Stream => stream_read(len, pos, size),
Self::BytesIo => Ok(stream_read_range(len, pos, size.max(-1))),
}
}
pub fn read_u64(
self,
len: usize,
pos: i128,
size: u64,
) -> Result<(Range<usize>, i128), StreamRefusal> {
match (i64::try_from(size), self) {
(Ok(size), _) => self.read(len, pos, size),
(Err(_), Self::Memory) => Ok(py_read(len, pos, i64::MAX)),
(Err(_), Self::Stream | Self::BytesIo) => Err(StreamRefusal::ReadSizeOverflow),
}
}
#[must_use]
pub fn unpack(self, len: usize, pos: i128, n: usize) -> (Option<usize>, i128) {
let step = i128::try_from(n).unwrap_or(i128::MAX);
match self {
Self::Memory => match py_unpack_from(len, pos, n) {
Some(at) => (Some(at), pos.saturating_add(step)),
None => (None, pos),
},
Self::Stream | Self::BytesIo => {
let size = i64::try_from(n).unwrap_or(i64::MAX);
match stream_read(len, pos, size) {
Ok((range, next)) if range.len() == n => (Some(range.start), next),
Ok((_, next)) => (None, next),
Err(_) => (None, pos),
}
}
}
}
#[must_use]
pub fn string_to_null(
self,
data: &[u8],
pos: i128,
max_length: usize,
) -> Option<(Range<usize>, i128)> {
let window = py_string_window(data.len(), pos, max_length);
let nul = data
.get(window.clone())
.and_then(|w| w.iter().position(|b| *b == 0))
.map(|k| window.start + k);
self.string_to_null_found(data.len(), pos, max_length, nul)
}
#[must_use]
pub(crate) fn string_to_null_found(
self,
len: usize,
pos: i128,
max_length: usize,
nul: Option<usize>,
) -> Option<(Range<usize>, i128)> {
match self {
Self::Memory => py_string_to_null_found(len, pos, max_length, nul),
Self::Stream | Self::BytesIo => stream_string_to_null(len, pos, max_length, nul),
}
}
}
fn stream_read(len: usize, pos: i128, size: i64) -> Result<(Range<usize>, i128), StreamRefusal> {
if size < -1 {
return Err(StreamRefusal::NegativeRead);
}
if size >= READ_TOO_LARGE {
return Err(StreamRefusal::ReadTooLarge);
}
Ok(stream_read_range(len, pos, size))
}
fn stream_read_range(len: usize, pos: i128, size: i64) -> (Range<usize>, i128) {
let l = i128::try_from(len).unwrap_or(i128::MAX);
let start = pos.clamp(0, l);
if size == 0 || pos >= l {
let at = usize::try_from(start).unwrap_or(len);
return (at..at, pos);
}
let end = if size == -1 {
l
} else {
start.saturating_add(i128::from(size)).min(l)
};
let range = usize::try_from(start).unwrap_or(len)..usize::try_from(end).unwrap_or(len);
(range, end)
}
fn stream_string_to_null(
len: usize,
pos: i128,
max_length: usize,
nul: Option<usize>,
) -> Option<(Range<usize>, i128)> {
let l = i128::try_from(len).ok()?;
let start = usize::try_from(pos.clamp(0, l)).ok()?;
if max_length == 0 || pos == l {
return Some((start..start, pos));
}
if pos > l {
return None;
}
if let Some(nul) = nul {
return Some((start..nul, i128::try_from(nul).ok()? + 1));
}
let read = usize::try_from(l - pos).ok()?.min(max_length);
let end = start.checked_add(read)?;
Some((start..end - 1, i128::try_from(end).ok()?))
}
#[cfg(test)]
mod tests {
use super::{ReaderKind, StreamRefusal};
#[test]
fn the_memory_kind_is_the_free_functions() {
let m = ReaderKind::Memory;
assert_eq!(m.seek(-5), Ok(-5));
assert_eq!(m.read(10, 3, -2), Ok((3..3, 1)));
assert_eq!(m.unpack(10, -4, 4), (Some(6), 0));
assert_eq!(
m.read_u64(10, 2, u64::MAX),
Ok((2..10, 2 + i128::from(i64::MAX)))
);
}
#[test]
fn the_stream_kind_refuses_what_a_buffered_file_refuses() {
let s = ReaderKind::Stream;
assert_eq!(s.seek(-1), Err(StreamRefusal::NegativePosition));
assert_eq!(
s.seek(i128::from(i64::MAX) + 1),
Err(StreamRefusal::PositionTooLarge)
);
assert_eq!(s.read(10, 3, -2), Err(StreamRefusal::NegativeRead));
assert_eq!(
s.read(10, 3, i64::MAX - 32),
Err(StreamRefusal::ReadTooLarge)
);
assert_eq!(s.read(10, 20, i64::MAX), Err(StreamRefusal::ReadTooLarge));
assert_eq!(
s.read_u64(10, 0, 1 << 63),
Err(StreamRefusal::ReadSizeOverflow)
);
let near = i128::from(i64::MAX) - 2;
assert_eq!(s.align(near, 4), Err(StreamRefusal::PositionTooLarge));
assert_eq!(s.align(near - 1, 4), Ok(near - 1));
assert_eq!(ReaderKind::Memory.align(near, 4), Ok(near + 3));
assert_eq!(s.read(10, 15, -1), Ok((10..10, 15)));
assert_eq!(s.unpack(10, 8, 4), (None, 10));
assert_eq!(s.unpack(10, 12, 0), (Some(10), 12));
assert_eq!(s.string_to_null(b"abc", 7, 0), Some((3..3, 7)));
assert_eq!(s.string_to_null(b"abc", 7, 1), None);
}
#[test]
fn the_stream_kind_reads_on_where_the_machine_decides() {
let s = ReaderKind::Stream;
assert_eq!(s.seek(i128::from(i64::MAX)), Ok(i128::from(i64::MAX)));
assert_eq!(s.read(10, 3, i64::MAX - 33), Ok((3..10, 10)));
assert_eq!(s.read_u64(10, 5, 1 << 32), Ok((5..10, 10)));
}
}