use crate::Error;
use minicbor::Decode;
use std::io;
#[derive(Debug)]
pub struct Reader<R> {
reader: R,
buffer: Vec<u8>,
max_len: usize
}
impl<R> Reader<R> {
pub fn new(reader: R) -> Self {
Self::with_buffer(reader, Vec::new())
}
pub fn with_buffer(reader: R, buffer: Vec<u8>) -> Self {
Self { reader, buffer, max_len: 512 * 1024 }
}
pub fn set_max_len(&mut self, val: u32) {
self.max_len = val as usize
}
pub fn reader(&self) -> &R {
&self.reader
}
pub fn reader_mut(&mut self) -> &mut R {
&mut self.reader
}
pub fn into_parts(self) -> (R, Vec<u8>) {
(self.reader, self.buffer)
}
}
impl<R: io::Read> Reader<R> {
pub fn read<'a, T: Decode<'a, ()>>(&'a mut self) -> Result<Option<T>, Error> {
self.read_with(&mut ())
}
pub fn read_with<'a, C, T: Decode<'a, C>>(&'a mut self, ctx: &mut C) -> Result<Option<T>, Error> {
let mut buf = [0; 4];
let mut len = 0;
while len < 4 {
match self.reader.read(&mut buf[len ..]) {
Ok(0) if len == 0 =>
return Ok(None),
Ok(0) =>
return Err(Error::Io(io::ErrorKind::UnexpectedEof.into())),
Ok(n) =>
len += n,
Err(e) if e.kind() == io::ErrorKind::Interrupted =>
continue,
Err(e) =>
return Err(Error::Io(e))
}
}
let len = u32::from_be_bytes(buf) as usize;
if len > self.max_len {
return Err(Error::InvalidLen)
}
self.buffer.clear();
self.buffer.resize(len, 0u8);
self.reader.read_exact(&mut self.buffer)?;
minicbor::decode_with(&self.buffer, ctx).map_err(Error::Decode).map(Some)
}
}