use std::fs::File;
use std::io;
use std::sync::Arc;
pub trait ReadAt: Send + Sync {
fn read_exact_at(&self, buf: &mut [u8], off: u64) -> io::Result<()>;
fn len(&self) -> io::Result<u64>;
fn is_empty(&self) -> io::Result<bool> {
Ok(self.len()? == 0)
}
}
impl ReadAt for File {
fn read_exact_at(&self, buf: &mut [u8], off: u64) -> io::Result<()> {
crate::sys::read_exact_at(self, buf, off)
}
fn len(&self) -> io::Result<u64> {
Ok(self.metadata()?.len())
}
}
impl<R: ReadAt + ?Sized> ReadAt for Arc<R> {
fn read_exact_at(&self, buf: &mut [u8], off: u64) -> io::Result<()> {
(**self).read_exact_at(buf, off)
}
fn len(&self) -> io::Result<u64> {
(**self).len()
}
}
impl<R: ReadAt + ?Sized> ReadAt for Box<R> {
fn read_exact_at(&self, buf: &mut [u8], off: u64) -> io::Result<()> {
(**self).read_exact_at(buf, off)
}
fn len(&self) -> io::Result<u64> {
(**self).len()
}
}
pub struct Slice<R> {
inner: R,
off: u64,
len: u64,
}
impl<R: ReadAt> Slice<R> {
pub fn new(inner: R, off: u64, len: u64) -> Slice<R> {
Slice { inner, off, len }
}
}
impl<R: ReadAt> ReadAt for Slice<R> {
fn read_exact_at(&self, buf: &mut [u8], off: u64) -> io::Result<()> {
if off > self.len || buf.len() as u64 > self.len - off {
return Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
format!(
"read of {} bytes at {off} exceeds the slice's {} bytes",
buf.len(),
self.len
),
));
}
self.inner.read_exact_at(buf, self.off + off)
}
fn len(&self) -> io::Result<u64> {
Ok(self.len)
}
}
pub struct Extents<R> {
inner: R,
runs: Vec<(u64, u64, u64)>,
len: u64,
}
impl<R: ReadAt> Extents<R> {
pub fn new(inner: R, extents: &[(u64, u64)]) -> Extents<R> {
let mut runs = Vec::with_capacity(extents.len());
let mut logical = 0u64;
for &(off, len) in extents {
if len == 0 {
continue;
}
runs.push((logical, off, len));
logical += len;
}
Extents { inner, runs, len: logical }
}
}
impl<R: ReadAt> ReadAt for Extents<R> {
fn read_exact_at(&self, buf: &mut [u8], off: u64) -> io::Result<()> {
if off > self.len || buf.len() as u64 > self.len - off {
return Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
format!(
"read of {} bytes at {off} exceeds the member's {} bytes",
buf.len(),
self.len
),
));
}
if buf.is_empty() {
return Ok(());
}
if self.runs.len() == 1 {
let (_, phys, _) = self.runs[0];
return self.inner.read_exact_at(buf, phys + off);
}
let mut i = self.runs.partition_point(|&(start, _, _)| start <= off) - 1;
let mut at = off;
let mut filled = 0usize;
while filled < buf.len() {
let (start, phys, len) = self.runs[i];
let within = at - start;
let take = ((len - within) as usize).min(buf.len() - filled);
self.inner.read_exact_at(&mut buf[filled..filled + take], phys + within)?;
filled += take;
at += take as u64;
i += 1;
}
Ok(())
}
fn len(&self) -> io::Result<u64> {
Ok(self.len)
}
}
#[cfg(test)]
mod tests {
use super::*;
struct Mem(Vec<u8>);
impl ReadAt for Mem {
fn read_exact_at(&self, buf: &mut [u8], off: u64) -> io::Result<()> {
let off = off as usize;
if off > self.0.len() || buf.len() > self.0.len() - off {
return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "past the end"));
}
buf.copy_from_slice(&self.0[off..off + buf.len()]);
Ok(())
}
fn len(&self) -> io::Result<u64> {
Ok(self.0.len() as u64)
}
}
#[test]
fn a_slice_translates_and_bounds() {
let m = Mem((0u8..100).collect());
let s = Slice::new(m, 10, 20);
let mut b = [0u8; 5];
s.read_exact_at(&mut b, 0).unwrap();
assert_eq!(b, [10, 11, 12, 13, 14]);
s.read_exact_at(&mut b, 15).unwrap();
assert_eq!(b, [25, 26, 27, 28, 29]);
assert_eq!(s.len().unwrap(), 20);
assert!(s.read_exact_at(&mut b, 16).is_err(), "a slice must not read its neighbour");
assert!(s.read_exact_at(&mut b, u64::MAX - 2).is_err());
}
#[test]
fn extents_stitch_scattered_ranges_into_one_logical_space() {
let m = Mem((0u8..100).collect());
let e = Extents::new(m, &[(10, 5), (20, 8)]);
assert_eq!(e.len().unwrap(), 13);
let mut b = [0u8; 3];
e.read_exact_at(&mut b, 1).unwrap();
assert_eq!(b, [11, 12, 13]);
let mut b = [0u8; 6];
e.read_exact_at(&mut b, 3).unwrap();
assert_eq!(b, [13, 14, 20, 21, 22, 23]);
let mut all = [0u8; 13];
e.read_exact_at(&mut all, 0).unwrap();
assert_eq!(&all[..5], &[10, 11, 12, 13, 14]);
assert_eq!(&all[5..], &[20, 21, 22, 23, 24, 25, 26, 27]);
let mut b = [0u8; 2];
assert!(e.read_exact_at(&mut b, 12).is_err());
assert!(e.read_exact_at(&mut b, u64::MAX - 1).is_err());
let m = Mem((0u8..100).collect());
let e = Extents::new(m, &[(10, 0), (30, 4), (50, 0)]);
assert_eq!(e.len().unwrap(), 4);
let mut b = [0u8; 4];
e.read_exact_at(&mut b, 0).unwrap();
assert_eq!(b, [30, 31, 32, 33]);
let e = Extents::new(Mem(Vec::new()), &[]);
assert_eq!(e.len().unwrap(), 0);
assert!(e.is_empty().unwrap());
let mut b = [0u8; 1];
assert!(e.read_exact_at(&mut b, 0).is_err());
}
}