X-Git-Url: https://git.nihav.org/?p=nihav.git;a=blobdiff_plain;f=nihav-core%2Fsrc%2Fio%2Fbyteio.rs;h=3fbee946a8989872a784adda451e6940582e7519;hp=7b5f220727e3ef21ceff699e7c40b53ebeb65ccf;hb=dee2d2f1b9a9b17593db0e9affdbb588ac72aa4e;hpb=6c0356da10eef6e02cee247d334f8515dd2952cb

diff --git a/nihav-core/src/io/byteio.rs b/nihav-core/src/io/byteio.rs
index 7b5f220..3fbee94 100644
--- a/nihav-core/src/io/byteio.rs
+++ b/nihav-core/src/io/byteio.rs
@@ -49,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.
@@ -90,6 +92,14 @@ pub struct FileReader<T: Read+Seek> {
     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<T: Read+Seek> {
+    file:     Box<T>,
+    start:    u64,
+    end:      Option<u64>,
+    eof:      bool,
+}
+
 macro_rules! read_int {
     ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
         unsafe {
@@ -537,6 +547,8 @@ impl<'a> ByteIO for MemoryReader<'a> {
     fn size(&mut self) -> i64 {
         self.buf.len() as i64
     }
+
+    fn flush(&mut self) -> ByteIOResult<()> { Ok(()) }
 }
 
 impl<T: Read+Seek> FileReader<T> {
@@ -545,6 +557,12 @@ impl<T: Read+Seek> FileReader<T> {
     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<T>) -> Self {
+        FileReader { file, eof : false }
+    }
+    /// Destroys the reader and releases the reader resource for a further use.
+    pub fn finish(self) -> Box<T> { self.file }
 }
 
 impl<T: Read+Seek> ByteIO for FileReader<T> {
@@ -625,8 +643,181 @@ impl<T: Read+Seek> ByteIO for FileReader<T> {
     fn size(&mut self) -> i64 {
         -1
     }
+
+    fn flush(&mut self) -> ByteIOResult<()> { Ok(()) }
+}
+
+
+impl<T: Read+Seek> BoundedFileReader<T> {
+
+    /// 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<u64>) -> ByteIOResult<Self> {
+        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<T>, start: u64, end: Option<u64>) -> ByteIOResult<Self> {
+        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<T> { 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<T: Read+Seek> ByteIO for BoundedFileReader<T> {
+    fn read_byte(&mut self) -> ByteIOResult<u8> {
+        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<u8> {
+        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<usize> {
+        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<usize> {
+        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<usize> {
+        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<u64> {
+        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.
@@ -774,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> {
@@ -850,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> {
@@ -928,6 +1126,8 @@ impl<'a> ByteIO for GrowableMemoryWriter<'a> {
     fn size(&mut self) -> i64 {
         self.buf.len() as i64
     }
+
+    fn flush(&mut self) -> ByteIOResult<()> { Ok(()) }
 }
 
 impl<T: Write+Seek> FileWriter<T> {
@@ -993,6 +1193,13 @@ impl<T: Write+Seek> ByteIO for FileWriter<T> {
     fn size(&mut self) -> i64 {
         -1
     }
+
+    fn flush(&mut self) -> ByteIOResult<()> {
+        match self.file.flush() {
+            Ok(()) => Ok(()),
+            Err(_) => Err(ByteIOError::WriteError),
+        }
+    }
 }
 
 #[cfg(test)]