-use std::io::SeekFrom;
-use std::fs::File;
+//! Bytestream reading/writing functionality.
+pub use std::io::SeekFrom;
use std::io::prelude::*;
use std::ptr;
+/// A list specifying general bytestream reading and writing errors.
#[derive(Debug)]
pub enum ByteIOError {
+ /// End of stream.
EOF,
+ /// Wrong seek position was provided.
WrongRange,
+ /// Tried to call read() on bytestream writer or write() on bytestream reader.
WrongIOMode,
+ /// Functionality is not implemented.
NotImplemented,
+ /// Read error.
ReadError,
+ /// Write error.
WriteError,
+ /// Seeking failed.
SeekError,
}
+/// A specialised `Result` type for bytestream operations.
pub type ByteIOResult<T> = Result<T, ByteIOError>;
+/// Common trait for bytestream operations.
pub trait ByteIO {
+ /// Reads data into provided buffer. Fails if it cannot fill whole buffer.
fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
+ /// Reads data into provided buffer. Partial read is treated as success.
fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
+ /// Reads data into provided buffer but does not advance read position.
fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
+ /// Reads single byte from the stream.
fn read_byte(&mut self) -> ByteIOResult<u8>;
+ /// Returns the next byte value in the stream without advancing read position.
fn peek_byte(&mut self) -> ByteIOResult<u8>;
+ /// Writes buffer to the stream.
fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()>;
+ /// Returns current read or write position.
fn tell(&mut self) -> u64;
+ /// Seeks to the provided position.
fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64>;
+ /// Tells whether this is end of stream.
fn is_eof(&self) -> bool;
+ /// Reports whether stream is seekable or not.
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.
+///
+/// User is supposed to create some reader implementing [`ByteIO`] trait e.g. [`MemoryReader`] and use it to create `ByteReader` which can be used for reading e.g. various integer types.
+///
+/// # Examples
+///
+/// ````
+/// use nihav_core::io::byteio::{MemoryReader,ByteReader};
+/// # use nihav_core::io::byteio::ByteIOResult;
+///
+/// # fn foo() -> ByteIOResult<()> {
+/// let memory: [u8; 4] = [ 0, 42, 42, 0 ];
+/// let mut mr = MemoryReader::new_read(&memory);
+/// let mut br = ByteReader::new(&mut mr);
+/// let val = br.read_u16be()?; // read 16-bit big-endian integer, should be 42
+/// let val = br.read_u16le()?; // read 16-bit little-endian integer, should be 42 as well
+/// # Ok(())
+/// # }
+/// ````
+///
+/// [`ByteIO`]: ./trait.ByteIO.html
+/// [`MemoryReader`]: ./struct.MemoryReader.html
#[allow(dead_code)]
pub struct ByteReader<'a> {
- io: &'a mut ByteIO,
+ io: &'a mut dyn ByteIO,
}
+/// Bytestream reader from memory.
pub struct MemoryReader<'a> {
buf: &'a [u8],
- size: usize,
pos: usize,
}
-pub struct FileReader<'a> {
- file: &'a File,
+/// Bytestream reader from anything implementing `std::io::Read` and `std::io::Seek`.
+pub struct FileReader<T: Read+Seek> {
+ file: Box<T>,
+ 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_func {
($s: ident, $inttype: ty, $size: expr, $which: ident) => {
+/// Reads integer of certain size and endianness.
pub fn $s(src: &[u8]) -> ByteIOResult<$inttype> {
if src.len() < $size { return Err(ByteIOError::ReadError); }
unsafe {
let mut buf: $inttype = 0;
- ptr::copy_nonoverlapping(src.as_ptr(), &mut buf as *mut $inttype as *mut u8, 1);
+ ptr::copy_nonoverlapping(src.as_ptr(), &mut buf as *mut $inttype as *mut u8, std::mem::size_of::<$inttype>());
Ok(buf.$which())
}
}
read_int_func!(read_u64be, u64, 8, to_be);
read_int_func!(read_u64le, u64, 8, to_le);
+/// Reads 24-bit big-endian integer.
+///
+/// # Example
+///
+/// ````
+/// use nihav_core::io::byteio::read_u24be;
+/// # use nihav_core::io::byteio::ByteIOResult;
+///
+/// # fn foo() -> ByteIOResult<()> {
+/// let src: [u8; 3] = [ 1, 2, 3];
+/// let value = read_u24be(&src)?; // should return 0x010203
+/// # Ok(())
+/// # }
+/// ````
pub fn read_u24be(src: &[u8]) -> ByteIOResult<u32> {
if src.len() < 3 { return Err(ByteIOError::ReadError); }
Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
}
+/// Reads 24-bit little-endian integer.
pub fn read_u24le(src: &[u8]) -> ByteIOResult<u32> {
if src.len() < 3 { return Err(ByteIOError::ReadError); }
Ok((u32::from(src[2]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[0]))
}
+/// Reads 32-bit big-endian floating point number.
+pub fn read_f32be(src: &[u8]) -> ByteIOResult<f32> { Ok(f32::from_bits(read_u32be(src)?)) }
+/// Reads 32-bit little-endian floating point number.
+pub fn read_f32le(src: &[u8]) -> ByteIOResult<f32> { Ok(f32::from_bits(read_u32le(src)?)) }
+/// Reads 64-bit big-endian floating point number.
+pub fn read_f64be(src: &[u8]) -> ByteIOResult<f64> { Ok(f64::from_bits(read_u64be(src)?)) }
+/// Reads 64-bit little-endian floating point number.
+pub fn read_f64le(src: &[u8]) -> ByteIOResult<f64> { Ok(f64::from_bits(read_u64le(src)?)) }
+
+macro_rules! write_int_func {
+ ($s: ident, $inttype: ty, $size: expr, $which: ident) => {
+/// Writes integer of certain size and endianness into byte buffer.
+ pub fn $s(dst: &mut [u8], val: $inttype) -> ByteIOResult<()> {
+ if dst.len() < $size { return Err(ByteIOError::WriteError); }
+ unsafe {
+ let val = val.$which();
+ ptr::copy_nonoverlapping(&val as *const $inttype as *const u8, dst.as_mut_ptr(), std::mem::size_of::<$inttype>());
+ }
+ Ok(())
+ }
+ }
+}
-impl<'a> ByteReader<'a> {
- pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io } }
+write_int_func!(write_u16be, u16, 2, to_be);
+write_int_func!(write_u16le, u16, 2, to_le);
+write_int_func!(write_u32be, u32, 4, to_be);
+write_int_func!(write_u32le, u32, 4, to_le);
+write_int_func!(write_u64be, u64, 8, to_be);
+write_int_func!(write_u64le, u64, 8, to_le);
+
+/// Writes 24-bit big-endian integer to the provided buffer.
+///
+/// # Example
+///
+/// ````
+/// use nihav_core::io::byteio::write_u24be;
+/// # use nihav_core::io::byteio::ByteIOResult;
+///
+/// # fn foo() -> ByteIOResult<()> {
+/// let mut dst = [0u8; 3];
+/// write_u24be(&mut dst, 0x010203)?;
+/// // dst should contain [ 1, 2, 3] now
+/// # 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;
+ dst[1] = (val >> 8) as u8;
+ dst[2] = (val >> 0) as u8;
+ 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;
+ dst[1] = (val >> 8) as u8;
+ dst[2] = (val >> 16) as u8;
+ Ok(())
+}
+/// Writes 32-bit big-endian floating point number to the provided buffer.
+pub fn write_f32be(dst: &mut [u8], val: f32) -> ByteIOResult<()> { write_u32be(dst, val.to_bits()) }
+/// Writes 32-bit little-endian floating point number to the provided buffer.
+pub fn write_f32le(dst: &mut [u8], val: f32) -> ByteIOResult<()> { write_u32le(dst, val.to_bits()) }
+/// Writes 64-bit big-endian floating point number to the provided buffer.
+pub fn write_f64be(dst: &mut [u8], val: f64) -> ByteIOResult<()> { write_u64be(dst, val.to_bits()) }
+/// Writes 64-bit little-endian floating point number to the provided buffer.
+pub fn write_f64le(dst: &mut [u8], val: f64) -> ByteIOResult<()> { write_u64le(dst, val.to_bits()) }
+impl<'a> ByteReader<'a> {
+ /// Constructs a new instance of bytestream reader.
+ ///
+ /// # Examples
+ ///
+ /// ````
+ /// use nihav_core::io::byteio::{MemoryReader,ByteReader};
+ /// # use nihav_core::io::byteio::ByteIOResult;
+ ///
+ /// # fn foo() -> ByteIOResult<()> {
+ /// let memory: [u8; 4] = [ 0, 42, 42, 0 ];
+ /// let mut mr = MemoryReader::new_read(&memory);
+ /// let mut br = ByteReader::new(&mut mr);
+ /// # Ok(())
+ /// # }
+ /// ````
+ 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<usize> {
self.io.read_buf(buf)
}
+ /// Reads data into provided buffer. Partial read is treated as success.
pub fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
self.io.read_buf_some(buf)
}
+ /// Reads data into provided buffer but does not advance read position.
pub fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
self.io.peek_buf(buf)
}
+ /// Reads single byte from the stream.
pub fn read_byte(&mut self) -> ByteIOResult<u8> {
self.io.read_byte()
}
+ /// Returns the next byte value in the stream without advancing read position.
pub fn peek_byte(&mut self) -> ByteIOResult<u8> {
self.io.peek_byte()
}
+ /// Reads four-byte array from the stream.
+ pub fn read_tag(&mut self) -> ByteIOResult<[u8; 4]> {
+ let mut buf = [0u8; 4];
+ self.io.read_buf(&mut buf)?;
+ Ok(buf)
+ }
+
+ /// Reads four-byte array from the stream without advancing read position.
+ pub fn peek_tag(&mut self) -> ByteIOResult<[u8; 4]> {
+ let mut buf = [0u8; 4];
+ self.io.peek_buf(&mut buf)?;
+ Ok(buf)
+ }
+
+ /// Reads 16-bit big-endian integer from the stream.
pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
read_int!(self, u16, 2, to_be)
}
+ /// Reads 16-bit big-endian integer from the stream without advancing read position.
pub fn peek_u16be(&mut self) -> ByteIOResult<u16> {
peek_int!(self, u16, 2, to_be)
}
+ /// Reads 24-bit big-endian integer from the stream.
pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
let p16 = self.read_u16be()?;
let p8 = self.read_byte()?;
Ok((u32::from(p16) << 8) | u32::from(p8))
}
+ /// Reads 24-bit big-endian integer from the stream without advancing read position.
pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
let mut src: [u8; 3] = [0; 3];
self.peek_buf(&mut src)?;
Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
}
+ /// Reads 32-bit big-endian integer from the stream.
pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
read_int!(self, u32, 4, to_be)
}
+ /// Reads 32-bit big-endian integer from the stream without advancing read position.
pub fn peek_u32be(&mut self) -> ByteIOResult<u32> {
peek_int!(self, u32, 4, to_be)
}
+ /// Reads 64-bit big-endian integer from the stream.
pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
read_int!(self, u64, 8, to_be)
}
+ /// Reads 64-bit big-endian integer from the stream without advancing read position.
pub fn peek_u64be(&mut self) -> ByteIOResult<u64> {
peek_int!(self, u64, 8, to_be)
}
+ /// Reads 32-bit big-endian floating point number from the stream.
+ pub fn read_f32be(&mut self) -> ByteIOResult<f32> {
+ Ok(f32::from_bits(self.read_u32be()?))
+ }
+
+ /// Reads 32-bit big-endian floating point number from the stream without advancing read position.
+ pub fn peek_f32be(&mut self) -> ByteIOResult<f32> {
+ Ok(f32::from_bits(self.peek_u32be()?))
+ }
+
+ /// Reads 64-bit big-endian floating point number from the stream.
+ pub fn read_f64be(&mut self) -> ByteIOResult<f64> {
+ Ok(f64::from_bits(self.read_u64be()?))
+ }
+
+ /// Reads 64-bit big-endian floating point number from the stream without advancing read position.
+ pub fn peek_f64be(&mut self) -> ByteIOResult<f64> {
+ Ok(f64::from_bits(self.peek_u64be()?))
+ }
+
+ /// Reads 16-bit little-endian integer from the stream.
pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
read_int!(self, u16, 2, to_le)
}
+ /// Reads 16-bit little-endian integer from the stream without advancing read position.
pub fn peek_u16le(&mut self) -> ByteIOResult<u16> {
peek_int!(self, u16, 2, to_le)
}
+ /// Reads 24-bit little-endian integer from the stream.
pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
let p8 = self.read_byte()?;
let p16 = self.read_u16le()?;
Ok((u32::from(p16) << 8) | u32::from(p8))
}
+ /// Reads 24-bit little-endian integer from the stream without advancing read position.
pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
let mut src: [u8; 3] = [0; 3];
self.peek_buf(&mut src)?;
Ok(u32::from(src[0]) | (u32::from(src[1]) << 8) | (u32::from(src[2]) << 16))
}
+ /// Reads 32-bit little-endian integer from the stream.
pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
read_int!(self, u32, 4, to_le)
}
+ /// Reads 32-bit little-endian integer from the stream without advancing read position.
pub fn peek_u32le(&mut self) -> ByteIOResult<u32> {
peek_int!(self, u32, 4, to_le)
}
+ /// Reads 64-bit little-endian integer from the stream.
pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
read_int!(self, u64, 8, to_le)
}
+ /// Reads 64-bit little-endian integer from the stream without advancing read position.
pub fn peek_u64le(&mut self) -> ByteIOResult<u64> {
peek_int!(self, u64, 8, to_le)
}
+ /// Reads 32-bit little-endian floating point number from the stream.
+ pub fn read_f32le(&mut self) -> ByteIOResult<f32> {
+ Ok(f32::from_bits(self.read_u32le()?))
+ }
+
+ /// Reads 32-bit little-endian floating point number from the stream without advancing read position.
+ pub fn peek_f32le(&mut self) -> ByteIOResult<f32> {
+ Ok(f32::from_bits(self.peek_u32le()?))
+ }
+
+ /// Reads 64-bit little-endian floating point number from the stream.
+ pub fn read_f64le(&mut self) -> ByteIOResult<f64> {
+ Ok(f64::from_bits(self.read_u64le()?))
+ }
+
+ /// Reads 64-bit little-endian floating point number from the stream without advancing read position.
+ pub fn peek_f64le(&mut self) -> ByteIOResult<f64> {
+ Ok(f64::from_bits(self.peek_u64le()?))
+ }
+
+ /// Skips requested number of bytes.
pub fn read_skip(&mut self, len: usize) -> ByteIOResult<()> {
if self.io.is_seekable() {
self.io.seek(SeekFrom::Current(len as i64))?;
Ok(())
}
+ /// Returns current read position.
pub fn tell(&mut self) -> u64 {
self.io.tell()
}
+ /// Seeks to the provided position.
pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
self.io.seek(pos)
}
+ /// Tells whether this is end of stream.
pub fn is_eof(&self) -> bool {
self.io.is_eof()
}
+ /// Returns stream size or -1 if it is not known.
pub fn size(&mut self) -> i64 {
self.io.size()
}
+ /// Reports number of bytes left in the stream.
pub fn left(&mut self) -> i64 {
let size = self.io.size();
if size == -1 { return -1; }
}
impl<'a> MemoryReader<'a> {
-
+ /// Constructs a new instance of `MemoryReader`.
pub fn new_read(buf: &'a [u8]) -> Self {
- MemoryReader { buf, size: buf.len(), pos: 0 }
+ MemoryReader { buf, pos: 0 }
}
fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
- if pos < 0 || (pos as usize) > self.size {
+ if pos < 0 || (pos as usize) > self.buf.len() {
return Err(ByteIOError::WrongRange);
}
self.pos = pos as usize;
}
fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
- let copy_size = if self.size - self.pos < buf.len() { self.size } else { buf.len() };
+ let copy_size = if self.buf.len() - self.pos < buf.len() { self.buf.len() - self.pos } else { buf.len() };
if copy_size == 0 { return Err(ByteIOError::EOF); }
let dst = &mut buf[0..copy_size];
dst.copy_from_slice(&self.buf[self.pos..][..copy_size]);
}
fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
- let cur_pos = self.pos as i64;
- let cur_size = self.size as i64;
+ let cur_pos = self.pos as i64;
+ let cur_size = self.buf.len() as i64;
match pos {
SeekFrom::Start(x) => self.real_seek(x as i64),
SeekFrom::Current(x) => self.real_seek(cur_pos + x),
}
fn is_eof(&self) -> bool {
- self.pos >= self.size
+ self.pos >= self.buf.len()
}
fn is_seekable(&mut self) -> bool {
fn size(&mut self) -> i64 {
self.buf.len() as i64
}
+
+ fn flush(&mut self) -> ByteIOResult<()> { Ok(()) }
}
-impl<'a> FileReader<'a> {
+impl<T: Read+Seek> FileReader<T> {
- pub fn new_read(file: &'a mut File) -> Self {
+ /// Constructs a new instance of `FileReader`.
+ 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<'a> ByteIO for FileReader<'a> {
+impl<T: Read+Seek> ByteIO for FileReader<T> {
fn read_byte(&mut self) -> ByteIOResult<u8> {
let mut byte : [u8; 1] = [0];
let ret = self.file.read(&mut byte);
}
fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
- 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<usize> {
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)
}
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.
+///
+/// # Examples
+///
+/// ````
+/// use nihav_core::io::byteio::{MemoryWriter,ByteWriter};
+/// # use nihav_core::io::byteio::ByteIOResult;
+///
+/// # fn foo() -> ByteIOResult<()> {
+/// let mut memory = [0u8; 4];
+/// let mut mw = MemoryWriter::new_write(&mut memory);
+/// let mut bw = ByteWriter::new(&mut mw);
+/// let val = bw.write_u16be(42)?; // memory should be [ 0, 42, 0, 0 ]
+/// let val = bw.write_u16le(42)?; // memory should be [ 0, 42, 42, 0 ]
+/// # Ok(())
+/// # }
+/// ````
+///
+/// [`ByteIO`]: ./trait.ByteIO.html
+/// [`MemoryWriter`]: ./struct.MemoryWriter.html
#[allow(dead_code)]
pub struct ByteWriter<'a> {
- io: &'a mut ByteIO,
+ io: &'a mut dyn ByteIO,
}
+/// Bytestream writer to memory.
pub struct MemoryWriter<'a> {
buf: &'a mut [u8],
- size: usize,
pos: usize,
}
-pub struct FileWriter {
- file: File,
+/// Bytestream writer to anything implementing `std::io::Write` and `std::io::Seek`.
+pub struct FileWriter<T: Write+Seek> {
+ file: Box<T>,
+}
+
+/// Bytestream writer to memory.
+///
+/// Unlike [`MemoryWriter`] which writes to an array of fixed size, `GrowableMemoryWriter` grows output size when output size exceeds capacity.
+///
+/// [`MemoryWriter`]: ./struct.MemoryWriter.html
+pub struct GrowableMemoryWriter<'a> {
+ buf: &'a mut Vec<u8>,
+ pos: usize,
}
impl<'a> ByteWriter<'a> {
- pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io } }
+ /// Constructs a new instance of `ByteWriter`.
+ 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<()> {
self.io.write_buf(buf)
}
+ /// Writes single byte to the output.
pub fn write_byte(&mut self, val: u8) -> ByteIOResult<()> {
let buf: [u8; 1] = [val];
self.io.write_buf(&buf)
}
+ /// Writes 16-bit big-endian integer to the output.
pub fn write_u16be(&mut self, val: u16) -> ByteIOResult<()> {
let buf: [u8; 2] = [((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
self.io.write_buf(&buf)
}
+ /// Writes 16-bit little-endian integer to the output.
pub fn write_u16le(&mut self, val: u16) -> ByteIOResult<()> {
let buf: [u8; 2] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8];
self.io.write_buf(&buf)
}
+ /// Writes 24-bit big-endian integer to the output.
pub fn write_u24be(&mut self, val: u32) -> ByteIOResult<()> {
let buf: [u8; 3] = [((val >> 16) & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
self.write_buf(&buf)
}
+ /// Writes 24-bit little-endian integer to the output.
pub fn write_u24le(&mut self, val: u32) -> ByteIOResult<()> {
let buf: [u8; 3] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, ((val >> 16) & 0xFF) as u8];
self.write_buf(&buf)
}
+ /// Writes 32-bit big-endian integer to the output.
pub fn write_u32be(&mut self, val: u32) -> ByteIOResult<()> {
self.write_u16be(((val >> 16) & 0xFFFF) as u16)?;
self.write_u16be((val & 0xFFFF) as u16)
}
+ /// Writes 32-bit little-endian integer to the output.
pub fn write_u32le(&mut self, val: u32) -> ByteIOResult<()> {
self.write_u16le((val & 0xFFFF) as u16)?;
self.write_u16le(((val >> 16) & 0xFFFF) as u16)
}
+ /// Writes 64-bit big-endian integer to the output.
pub fn write_u64be(&mut self, val: u64) -> ByteIOResult<()> {
self.write_u32be((val >> 32) as u32)?;
self.write_u32be(val as u32)
}
+ /// Writes 64-bit little-endian integer to the output.
pub fn write_u64le(&mut self, val: u64) -> ByteIOResult<()> {
self.write_u32le(val as u32)?;
self.write_u32le((val >> 32) as u32)
}
+ /// Writes 32-bit big-endian floating point number to the output.
+ pub fn write_f32be(&mut self, val: f32) -> ByteIOResult<()> {
+ self.write_u32be(val.to_bits())
+ }
+
+ /// Writes 32-bit little-endian floating point number to the output.
+ pub fn write_f32le(&mut self, val: f32) -> ByteIOResult<()> {
+ self.write_u32le(val.to_bits())
+ }
+
+ /// Writes 64-bit big-endian floating point number to the output.
+ pub fn write_f64be(&mut self, val: f64) -> ByteIOResult<()> {
+ self.write_u64be(val.to_bits())
+ }
+
+ /// Writes 64-bit little-endian floating point number to the output.
+ pub fn write_f64le(&mut self, val: f64) -> ByteIOResult<()> {
+ self.write_u64le(val.to_bits())
+ }
+
+ /// Reports the current write position.
pub fn tell(&mut self) -> u64 {
self.io.tell()
}
+ /// Seeks to the requested position.
pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
self.io.seek(pos)
}
+ /// Reports the amount of bytes the writer can still write (-1 if unknown).
pub fn size_left(&mut self) -> i64 {
let sz = self.io.size();
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> {
+ /// Constructs a new instance of `MemoryWriter`.
pub fn new_write(buf: &'a mut [u8]) -> Self {
- let len = buf.len();
- MemoryWriter { buf, size: len, pos: 0 }
+ MemoryWriter { buf, pos: 0 }
}
fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
- if pos < 0 || (pos as usize) > self.size {
+ if pos < 0 || (pos as usize) > self.buf.len() {
return Err(ByteIOError::WrongRange)
}
self.pos = pos as usize;
}
fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
- if self.pos + buf.len() > self.size { return Err(ByteIOError::WriteError); }
- for i in 0..buf.len() {
- self.buf[self.pos + i] = buf[i];
+ if self.pos + buf.len() > self.buf.len() { return Err(ByteIOError::WriteError); }
+ self.buf[self.pos..][..buf.len()].copy_from_slice(buf);
+ self.pos += buf.len();
+ Ok(())
+ }
+
+ fn tell(&mut self) -> u64 {
+ self.pos as u64
+ }
+
+ fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
+ let cur_pos = self.pos as i64;
+ let cur_size = self.buf.len() as i64;
+ match pos {
+ SeekFrom::Start(x) => self.real_seek(x as i64),
+ SeekFrom::Current(x) => self.real_seek(cur_pos + x),
+ SeekFrom::End(x) => self.real_seek(cur_size + x),
+ }
+ }
+
+ fn is_eof(&self) -> bool {
+ self.pos >= self.buf.len()
+ }
+
+ fn is_seekable(&mut self) -> bool {
+ true
+ }
+
+ fn size(&mut self) -> i64 {
+ self.buf.len() as i64
+ }
+
+ fn flush(&mut self) -> ByteIOResult<()> { Ok(()) }
+}
+
+impl<'a> GrowableMemoryWriter<'a> {
+
+ /// Constructs a new instance of `GrowableMemoryWriter`.
+ pub fn new_write(buf: &'a mut Vec<u8>) -> Self {
+ GrowableMemoryWriter { buf, pos: 0 }
+ }
+
+ fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
+ if pos < 0 || (pos as usize) > self.buf.len() {
+ return Err(ByteIOError::WrongRange)
+ }
+ self.pos = pos as usize;
+ Ok(pos as u64)
+ }
+}
+
+impl<'a> ByteIO for GrowableMemoryWriter<'a> {
+ #[allow(unused_variables)]
+ fn read_byte(&mut self) -> ByteIOResult<u8> {
+ Err(ByteIOError::NotImplemented)
+ }
+
+ #[allow(unused_variables)]
+ fn peek_byte(&mut self) -> ByteIOResult<u8> {
+ Err(ByteIOError::NotImplemented)
+ }
+
+ #[allow(unused_variables)]
+ fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
+ Err(ByteIOError::NotImplemented)
+ }
+
+ #[allow(unused_variables)]
+ fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
+ Err(ByteIOError::NotImplemented)
+ }
+
+ #[allow(unused_variables)]
+ fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
+ Err(ByteIOError::NotImplemented)
+ }
+
+ fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
+ if self.pos + buf.len() > self.buf.len() {
+ self.buf.resize(self.pos + buf.len(), 0);
}
+ self.buf[self.pos..][..buf.len()].copy_from_slice(buf);
self.pos += buf.len();
Ok(())
}
}
fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
- let cur_pos = self.pos as i64;
- let cur_size = self.size as i64;
+ let cur_pos = self.pos as i64;
+ let cur_size = self.buf.len() as i64;
match pos {
SeekFrom::Start(x) => self.real_seek(x as i64),
SeekFrom::Current(x) => self.real_seek(cur_pos + x),
}
fn is_eof(&self) -> bool {
- self.pos >= self.size
+ self.pos >= self.buf.len()
}
fn is_seekable(&mut self) -> bool {
fn size(&mut self) -> i64 {
self.buf.len() as i64
}
+
+ fn flush(&mut self) -> ByteIOResult<()> { Ok(()) }
}
-impl FileWriter {
- pub fn new_write(file: File) -> Self {
- FileWriter { file }
+impl<T: Write+Seek> FileWriter<T> {
+ /// Constructs a new instance of `FileWriter`.
+ pub fn new_write(file: T) -> Self {
+ FileWriter { file: Box::new(file) }
}
}
-impl ByteIO for FileWriter {
+impl<T: Write+Seek> ByteIO for FileWriter<T> {
#[allow(unused_variables)]
fn read_byte(&mut self) -> ByteIOResult<u8> {
Err(ByteIOError::NotImplemented)
fn size(&mut self) -> i64 {
-1
}
+
+ fn flush(&mut self) -> ByteIOResult<()> {
+ match self.file.flush() {
+ Ok(()) => Ok(()),
+ Err(_) => Err(ByteIOError::WriteError),
+ }
+ }
}
#[cfg(test)]
projects / nihav.git / blobdiff