use crate::error::{Error, ErrorCode, Result, bail};
pub(crate) struct Cursor<'a> {
write: Option<&'a mut [u8]>,
read: &'a [u8],
pos: usize,
truncated: ErrorCode,
}
impl<'a> Cursor<'a> {
pub(crate) fn writer(out: &'a mut [u8]) -> Self {
Self {
write: Some(out),
read: &[],
pos: 0,
truncated: ErrorCode::BufferTooSmall,
}
}
pub(crate) fn reader(buf: &'a [u8], truncated: ErrorCode) -> Self {
Self {
write: None,
read: buf,
pos: 0,
truncated,
}
}
pub(crate) const fn position(&self) -> usize {
self.pos
}
pub(crate) fn rest(&self) -> &'a [u8] {
self.read.get(self.pos..).unwrap_or(&[])
}
fn advance(&mut self, n: usize) -> Result<usize> {
let start = self.pos;
self.pos = self.pos.checked_add(n).ok_or(Error::new(self.truncated))?;
Ok(start)
}
pub(crate) fn skip(&mut self, n: usize) -> Result<()> {
let start = self.advance(n)?;
if self.read.get(start..self.pos).is_none() {
return Err(Error::new(self.truncated));
}
Ok(())
}
pub(crate) fn put(&mut self, bytes: &[u8]) -> Result<()> {
let start = self.advance(bytes.len())?;
let Some(buf) = self.write.as_mut() else {
bail!(InvalidState)
};
let Some(dst) = buf.get_mut(start..self.pos) else {
bail!(BufferTooSmall)
};
dst.copy_from_slice(bytes);
Ok(())
}
pub(crate) fn take(&mut self, n: usize) -> Result<&'a [u8]> {
let start = self.advance(n)?;
self.read
.get(start..self.pos)
.ok_or(Error::new(self.truncated))
}
pub(crate) fn u8(&mut self, v: u8) -> Result<()> {
self.put(&[v])
}
pub(crate) fn u16(&mut self, v: u16) -> Result<()> {
self.put(&v.to_le_bytes())
}
pub(crate) fn u32(&mut self, v: u32) -> Result<()> {
self.put(&v.to_le_bytes())
}
pub(crate) fn u64(&mut self, v: u64) -> Result<()> {
self.put(&v.to_le_bytes())
}
}
impl Cursor<'_> {
pub(crate) fn read_u8(&mut self) -> Result<u8> {
let b = self.take(1)?;
b.first().copied().ok_or(Error::new(self.truncated))
}
pub(crate) fn read_u16(&mut self) -> Result<u16> {
let arr: [u8; 2] = self
.take(2)?
.try_into()
.map_err(|_| Error::new(self.truncated))?;
Ok(u16::from_le_bytes(arr))
}
pub(crate) fn read_u32(&mut self) -> Result<u32> {
let arr: [u8; 4] = self
.take(4)?
.try_into()
.map_err(|_| Error::new(self.truncated))?;
Ok(u32::from_le_bytes(arr))
}
pub(crate) fn read_u64(&mut self) -> Result<u64> {
let arr: [u8; 8] = self
.take(8)?
.try_into()
.map_err(|_| Error::new(self.truncated))?;
Ok(u64::from_le_bytes(arr))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_write_that_runs_off_the_end_is_refused_rather_than_truncated() {
let mut buf = [0u8; 3];
let mut w = Cursor::writer(&mut buf);
w.u16(0xBEEF).expect("fits");
assert_eq!(
w.u16(0).map_err(|e| e.code()),
Err(ErrorCode::BufferTooSmall)
);
assert_eq!(w.position(), 4, "the position still advanced past the end");
}
#[test]
fn a_read_reports_the_caller_s_own_error_code() {
let mut r = Cursor::reader(&[1, 2], ErrorCode::BtpMalformed);
assert_eq!(r.read_u16().expect("fits"), 0x0201, "little-endian");
assert_eq!(
r.read_u8().map_err(|e| e.code()),
Err(ErrorCode::BtpMalformed)
);
let mut r = Cursor::reader(&[1], ErrorCode::MessageTruncated);
assert_eq!(
r.read_u32().map_err(|e| e.code()),
Err(ErrorCode::MessageTruncated)
);
}
#[test]
fn rest_is_everything_not_yet_read() {
let mut r = Cursor::reader(&[1, 2, 3, 4], ErrorCode::MessageTruncated);
r.skip(1).expect("skip");
assert_eq!(r.rest(), &[2, 3, 4]);
assert_eq!(r.take(3).expect("take"), &[2, 3, 4]);
assert!(r.rest().is_empty());
}
}