use alloc::vec::Vec;
use crate::operation::OperationError;
#[derive(Debug, Clone, Default)]
pub struct PayloadWriter {
bytes: Vec<u8>,
}
impl PayloadWriter {
pub const fn new() -> Self {
Self { bytes: Vec::new() }
}
pub fn u8(&mut self, value: u8) {
self.bytes.push(value);
}
pub fn u16(&mut self, value: u16) {
self.bytes.extend_from_slice(&value.to_be_bytes());
}
pub fn u24(&mut self, value: u32) -> Result<(), OperationError> {
if value > 0x00ff_ffff {
return Err(OperationError::InvalidValue("24-bit integer"));
}
self.bytes.extend_from_slice(&value.to_be_bytes()[1..]);
Ok(())
}
pub fn u32(&mut self, value: u32) {
self.bytes.extend_from_slice(&value.to_be_bytes());
}
pub fn f32(&mut self, value: f32) {
self.bytes.extend_from_slice(&value.to_be_bytes());
}
pub fn bytes(&mut self, value: &[u8]) {
self.bytes.extend_from_slice(value);
}
pub fn finish(self) -> Vec<u8> {
self.bytes
}
}
#[derive(Debug, Clone, Copy)]
pub struct PayloadReader<'a> {
bytes: &'a [u8],
offset: usize,
}
impl<'a> PayloadReader<'a> {
pub const fn new(bytes: &'a [u8]) -> Self {
Self { bytes, offset: 0 }
}
pub const fn position(&self) -> usize {
self.offset
}
pub const fn remaining(&self) -> usize {
self.bytes.len().saturating_sub(self.offset)
}
pub fn u8(&mut self, field: &'static str) -> Result<u8, OperationError> {
let value = *self
.bytes
.get(self.offset)
.ok_or(OperationError::Truncated {
field,
offset: self.offset,
})?;
self.offset += 1;
Ok(value)
}
pub fn u16(&mut self, field: &'static str) -> Result<u16, OperationError> {
let bytes = self.take_array::<2>(field)?;
Ok(u16::from_be_bytes(bytes))
}
pub fn u24(&mut self, field: &'static str) -> Result<u32, OperationError> {
let bytes = self.take_array::<3>(field)?;
Ok((u32::from(bytes[0]) << 16) | (u32::from(bytes[1]) << 8) | u32::from(bytes[2]))
}
pub fn u32(&mut self, field: &'static str) -> Result<u32, OperationError> {
Ok(u32::from_be_bytes(self.take_array::<4>(field)?))
}
pub fn f32(&mut self, field: &'static str) -> Result<f32, OperationError> {
Ok(f32::from_be_bytes(self.take_array::<4>(field)?))
}
pub fn bytes(
&mut self,
length: usize,
field: &'static str,
) -> Result<&'a [u8], OperationError> {
let end = self.offset.saturating_add(length);
let value = self
.bytes
.get(self.offset..end)
.ok_or(OperationError::Truncated {
field,
offset: self.offset,
})?;
self.offset = end;
Ok(value)
}
pub fn rest(&mut self) -> &'a [u8] {
let rest = &self.bytes[self.offset..];
self.offset = self.bytes.len();
rest
}
pub fn finish(self) -> Result<(), OperationError> {
if self.remaining() == 0 {
Ok(())
} else {
Err(OperationError::TrailingBytes(self.remaining()))
}
}
fn take_array<const N: usize>(
&mut self,
field: &'static str,
) -> Result<[u8; N], OperationError> {
let value = self.bytes(N, field)?;
let mut output = [0; N];
output.copy_from_slice(value);
Ok(output)
}
}