X-Git-Url: https://git.nihav.org/?p=nihav.git;a=blobdiff_plain;f=nihav-core%2Fsrc%2Fio%2Fbyteio.rs;h=3fbee946a8989872a784adda451e6940582e7519;hp=ff899fc8a0d95b0b0e457813340bfb5c87c42eaa;hb=dee2d2f1b9a9b17593db0e9affdbb588ac72aa4e;hpb=422e87e4397fc168e568e629b8a0f2b6a9f01ad8 diff --git a/nihav-core/src/io/byteio.rs b/nihav-core/src/io/byteio.rs index ff899fc..3fbee94 100644 --- a/nihav-core/src/io/byteio.rs +++ b/nihav-core/src/io/byteio.rs @@ -1,6 +1,5 @@ //! Bytestream reading/writing functionality. pub use std::io::SeekFrom; -use std::fs::File; use std::io::prelude::*; use std::ptr; @@ -50,6 +49,8 @@ pub trait ByteIO { fn is_seekable(&mut self) -> bool; /// Returns stream size or -1 if it is not known. fn size(&mut self) -> i64; + /// Flushes output if possible. + fn flush(&mut self) -> ByteIOResult<()>; } /// High-level bytestream reader. @@ -76,7 +77,7 @@ pub trait ByteIO { /// [`MemoryReader`]: ./struct.MemoryReader.html #[allow(dead_code)] pub struct ByteReader<'a> { - io: &'a mut ByteIO, + io: &'a mut dyn ByteIO, } /// Bytestream reader from memory. @@ -85,9 +86,17 @@ pub struct MemoryReader<'a> { pos: usize, } -/// Bytestream reader from file. -pub struct FileReader<'a> { - file: &'a File, +/// Bytestream reader from anything implementing `std::io::Read` and `std::io::Seek`. +pub struct FileReader { + file: Box, + eof: bool, +} + +/// Bytestream reader from anything implementing `std::io::Read` and `std::io::Seek` that operates only on a part of the input. +pub struct BoundedFileReader { + file: Box, + start: u64, + end: Option, eof: bool, } @@ -200,6 +209,7 @@ write_int_func!(write_u64le, u64, 8, to_le); /// # Ok(()) /// # } /// ```` +#[allow(clippy::identity_op)] pub fn write_u24be(dst: &mut [u8], val: u32) -> ByteIOResult<()> { if dst.len() < 3 { return Err(ByteIOError::WriteError); } dst[0] = (val >> 16) as u8; @@ -208,6 +218,7 @@ pub fn write_u24be(dst: &mut [u8], val: u32) -> ByteIOResult<()> { Ok(()) } /// Writes 24-bit little-endian integer to the provided buffer. +#[allow(clippy::identity_op)] pub fn write_u24le(dst: &mut [u8], val: u32) -> ByteIOResult<()> { if dst.len() < 3 { return Err(ByteIOError::WriteError); } dst[0] = (val >> 0) as u8; @@ -240,7 +251,7 @@ impl<'a> ByteReader<'a> { /// # Ok(()) /// # } /// ```` - pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io } } + pub fn new(io: &'a mut dyn ByteIO) -> Self { ByteReader { io } } /// Reads data into provided buffer. Partial read is treated as success. pub fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult { @@ -536,17 +547,25 @@ impl<'a> ByteIO for MemoryReader<'a> { fn size(&mut self) -> i64 { self.buf.len() as i64 } + + fn flush(&mut self) -> ByteIOResult<()> { Ok(()) } } -impl<'a> FileReader<'a> { +impl FileReader { /// Constructs a new instance of `FileReader`. - pub fn new_read(file: &'a mut File) -> Self { + pub fn new_read(file: T) -> Self { + FileReader { file: Box::new(file), eof : false } + } + /// Constructs a new instance of `FileReader` using a boxed resource. + pub fn new_read_boxed(file: Box) -> Self { FileReader { file, eof : false } } + /// Destroys the reader and releases the reader resource for a further use. + pub fn finish(self) -> Box { self.file } } -impl<'a> ByteIO for FileReader<'a> { +impl ByteIO for FileReader { fn read_byte(&mut self) -> ByteIOResult { let mut byte : [u8; 1] = [0]; let ret = self.file.read(&mut byte); @@ -563,18 +582,30 @@ impl<'a> ByteIO for FileReader<'a> { } fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult { - let ret = self.file.read(buf); - if ret.is_err() { return Err(ByteIOError::ReadError); } - let sz = ret.unwrap(); - if sz < buf.len() { self.eof = true; return Err(ByteIOError::EOF); } - Ok(sz) + match self.file.read_exact(buf) { + Ok(()) => Ok(buf.len()), + Err(err) => { + if err.kind() == std::io::ErrorKind::UnexpectedEof { + self.eof = true; + Err(ByteIOError::EOF) + } else { + Err(ByteIOError::ReadError) + } + }, + } } fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult { let ret = self.file.read(buf); if ret.is_err() { return Err(ByteIOError::ReadError); } let sz = ret.unwrap(); - if sz < buf.len() { self.eof = true; } + if sz < buf.len() { + if let Err(_err) = self.file.read(&mut buf[sz..][..1]) { + self.eof = true; + } else { + return Ok(sz + 1); + } + } Ok(sz) } @@ -612,8 +643,181 @@ impl<'a> ByteIO for FileReader<'a> { fn size(&mut self) -> i64 { -1 } + + fn flush(&mut self) -> ByteIOResult<()> { Ok(()) } } + +impl BoundedFileReader { + + /// Constructs a new instance of `BoundedFileReader`. The reader pretends that data before `start` and after `end` (if set) does not exist. + pub fn new_read(file: T, start: u64, end: Option) -> ByteIOResult { + let mut file = Box::new(file); + if let Some(epos) = end { + if start > epos { + return Err(ByteIOError::WrongRange); + } + } + if start > 0 && file.seek(SeekFrom::Start(start)).is_err() { + return Err(ByteIOError::SeekError); + } + Ok(Self { file, start, end, eof : false }) + } + /// Constructs a new instance of `BoundedFileReader` using a boxed resource. The reader pretends that data before `start` and after `end` (if set) does not exist. + pub fn new_read_boxed(mut file: Box, start: u64, end: Option) -> ByteIOResult { + if let Some(epos) = end { + if start > epos { + return Err(ByteIOError::WrongRange); + } + } + if start > 0 && file.seek(SeekFrom::Start(start)).is_err() { + return Err(ByteIOError::SeekError); + } + Ok(Self { file, start, end, eof : false }) + } + /// Destroys the reader and releases the reader resource for a further use. + pub fn finish(self) -> Box { self.file } + fn real_tell(&mut self) -> u64 { + self.file.seek(SeekFrom::Current(0)).unwrap() + } + fn max_read_len(&mut self, len: usize) -> usize { + if let Some(epos) = self.end { + (len as u64).min(epos - self.real_tell()) as usize + } else { + len + } + } +} + +impl ByteIO for BoundedFileReader { + fn read_byte(&mut self) -> ByteIOResult { + if let Some(epos) = self.end { + if self.real_tell() >= epos { + self.eof = true; + return Err(ByteIOError::EOF); + } + } + let mut byte : [u8; 1] = [0]; + let ret = self.file.read(&mut byte); + if ret.is_err() { return Err(ByteIOError::ReadError); } + let sz = ret.unwrap(); + if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); } + Ok (byte[0]) + } + + fn peek_byte(&mut self) -> ByteIOResult { + let b = self.read_byte()?; + if self.file.seek(SeekFrom::Current(-1)).is_err() { + return Err(ByteIOError::SeekError); + } + Ok(b) + } + + fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult { + let len = self.max_read_len(buf.len()); + match self.file.read_exact(&mut buf[..len]) { + Ok(()) if len == buf.len() => Ok(buf.len()), + Ok(()) => { + self.eof = true; + Err(ByteIOError::EOF) + }, + Err(err) => { + if err.kind() == std::io::ErrorKind::UnexpectedEof { + self.eof = true; + Err(ByteIOError::EOF) + } else { + Err(ByteIOError::ReadError) + } + }, + } + } + + fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult { + let len = self.max_read_len(buf.len()); + let ret = self.file.read(&mut buf[..len]); + if ret.is_err() { return Err(ByteIOError::ReadError); } + let sz = ret.unwrap(); + if sz < len { + if let Err(_err) = self.file.read(&mut buf[sz..][..1]) { + self.eof = true; + } else { + return Ok(sz + 1); + } + } + Ok(sz) + } + + fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult { + let len = self.max_read_len(buf.len()); + let size = self.read_buf(&mut buf[..len])?; + if self.file.seek(SeekFrom::Current(-(size as i64))).is_err() { + return Err(ByteIOError::SeekError); + } + Ok(size) + } + + #[allow(unused_variables)] + fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> { + Err(ByteIOError::NotImplemented) + } + + fn tell(&mut self) -> u64 { + self.file.seek(SeekFrom::Current(0)).unwrap() - self.start + } + + fn seek(&mut self, pos: SeekFrom) -> ByteIOResult { + let res = match pos { + SeekFrom::Start(off) => { + let dpos = self.start + off; + if let Some(epos) = self.end { + if dpos > epos { + return Err(ByteIOError::WrongRange); + } + } + self.file.seek(SeekFrom::Start(dpos)) + }, + SeekFrom::Current(off) => { + let dpos = (self.real_tell() as i64) + off; + let end = self.end.unwrap_or(dpos as u64); + if dpos < 0 || ((dpos as u64) < self.start) || ((dpos as u64) > end) { + return Err(ByteIOError::WrongRange); + } + self.file.seek(pos) + }, + SeekFrom::End(off) => { + if let Some(epos) = self.end { + let dpos = (epos as i64) + off; + if dpos < (self.start as i64) || ((dpos as u64) > epos) { + return Err(ByteIOError::WrongRange); + } + self.file.seek(SeekFrom::Start(dpos as u64)) + } else { + self.file.seek(pos) + } + }, + }; + match res { + Ok(r) => Ok(r), + Err(_) => Err(ByteIOError::SeekError), + } + } + + fn is_eof(&self) -> bool { + self.eof + } + + fn is_seekable(&mut self) -> bool { + true + } + + fn size(&mut self) -> i64 { + -1 + } + + fn flush(&mut self) -> ByteIOResult<()> { Ok(()) } +} + + /// High-level bytestream writer. /// /// User is supposed to create some writer implementing [`ByteIO`] trait e.g. [`MemoryWriter`] and use it to create `ByteWriter` which can be used for writing e.g. various integer types. @@ -638,7 +842,7 @@ impl<'a> ByteIO for FileReader<'a> { /// [`MemoryWriter`]: ./struct.MemoryWriter.html #[allow(dead_code)] pub struct ByteWriter<'a> { - io: &'a mut ByteIO, + io: &'a mut dyn ByteIO, } /// Bytestream writer to memory. @@ -647,9 +851,9 @@ pub struct MemoryWriter<'a> { pos: usize, } -/// Bytestream writer to file. -pub struct FileWriter { - file: File, +/// Bytestream writer to anything implementing `std::io::Write` and `std::io::Seek`. +pub struct FileWriter { + file: Box, } /// Bytestream writer to memory. @@ -664,7 +868,7 @@ pub struct GrowableMemoryWriter<'a> { impl<'a> ByteWriter<'a> { /// Constructs a new instance of `ByteWriter`. - pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io } } + pub fn new(io: &'a mut dyn ByteIO) -> Self { ByteWriter { io } } /// Writes byte array to the output. pub fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> { @@ -761,6 +965,11 @@ impl<'a> ByteWriter<'a> { if sz == -1 { return -1; } sz - (self.tell() as i64) } + + /// Flushes output stream if possible. + pub fn flush(&mut self) -> ByteIOResult<()> { + self.io.flush() + } } impl<'a> MemoryWriter<'a> { @@ -807,9 +1016,7 @@ impl<'a> ByteIO for MemoryWriter<'a> { fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> { if self.pos + buf.len() > self.buf.len() { return Err(ByteIOError::WriteError); } - for i in 0..buf.len() { - self.buf[self.pos + i] = buf[i]; - } + self.buf[self.pos..][..buf.len()].copy_from_slice(buf); self.pos += buf.len(); Ok(()) } @@ -839,6 +1046,8 @@ impl<'a> ByteIO for MemoryWriter<'a> { fn size(&mut self) -> i64 { self.buf.len() as i64 } + + fn flush(&mut self) -> ByteIOResult<()> { Ok(()) } } impl<'a> GrowableMemoryWriter<'a> { @@ -887,9 +1096,7 @@ impl<'a> ByteIO for GrowableMemoryWriter<'a> { if self.pos + buf.len() > self.buf.len() { self.buf.resize(self.pos + buf.len(), 0); } - for i in 0..buf.len() { - self.buf[self.pos + i] = buf[i]; - } + self.buf[self.pos..][..buf.len()].copy_from_slice(buf); self.pos += buf.len(); Ok(()) } @@ -919,16 +1126,18 @@ impl<'a> ByteIO for GrowableMemoryWriter<'a> { fn size(&mut self) -> i64 { self.buf.len() as i64 } + + fn flush(&mut self) -> ByteIOResult<()> { Ok(()) } } -impl FileWriter { +impl FileWriter { /// Constructs a new instance of `FileWriter`. - pub fn new_write(file: File) -> Self { - FileWriter { file } + pub fn new_write(file: T) -> Self { + FileWriter { file: Box::new(file) } } } -impl ByteIO for FileWriter { +impl ByteIO for FileWriter { #[allow(unused_variables)] fn read_byte(&mut self) -> ByteIOResult { Err(ByteIOError::NotImplemented) @@ -984,6 +1193,13 @@ impl ByteIO for FileWriter { fn size(&mut self) -> i64 { -1 } + + fn flush(&mut self) -> ByteIOResult<()> { + match self.file.flush() { + Ok(()) => Ok(()), + Err(_) => Err(ByteIOError::WriteError), + } + } } #[cfg(test)]