mod admitted;
use crate::{Direction, Encoding, Error, Limits, meter::Budget};
use alloc::vec::Vec;
use postcard::ser_flavors::Flavor;
use serde::Serialize;
fn preflight<T: Serialize + ?Sized>(
value: &T,
encoding: Encoding,
limits: Limits,
) -> Result<(Option<[u8; 11]>, usize), Error> {
let header = match encoding {
Encoding::Payload => None,
Encoding::Frame { method, direction } => {
let mut header = [0; 11];
header[..2].copy_from_slice(b"IW");
header[2..10].copy_from_slice(&method.to_le_bytes());
header[10] = match direction {
Direction::Request => 0,
Direction::Response => 1,
};
Some(header)
}
};
let prefix = if header.is_some() { 11 } else { 0 };
let payload_limits = limits.without_prefix(prefix)?;
let budget = Budget::new(payload_limits);
let size = postcard::experimental::serialized_size(&admitted::Bounded {
value,
budget: &budget,
depth: 1,
})
.map_err(|_| budget.error())?;
if size > payload_limits.bytes {
return Err(Error::Limit);
}
Ok((header, size + prefix))
}
pub fn encoded_len<T: Serialize + ?Sized>(
value: &T,
encoding: Encoding,
limits: Limits,
) -> Result<usize, Error> {
preflight(value, encoding, limits).map(|(_, size)| size)
}
pub fn encode<T: Serialize + ?Sized>(
value: &T,
encoding: Encoding,
limits: Limits,
) -> Result<Vec<u8>, Error> {
let mut output = Vec::new();
encode_into(value, encoding, limits, &mut output)?;
Ok(output)
}
pub fn encode_into<'out, T: Serialize + ?Sized>(
value: &T,
encoding: Encoding,
limits: Limits,
output: &'out mut Vec<u8>,
) -> Result<&'out [u8], Error> {
output.clear();
let (header, size) = preflight(value, encoding, limits)?;
output
.try_reserve_exact(size)
.map_err(|_| Error::Allocation)?;
if let Some(header) = header {
output.extend_from_slice(&header);
}
let budget = Budget::new(limits);
*output = postcard::serialize_with_flavor(
&admitted::Bounded {
value,
budget: &budget,
depth: 1,
},
Output {
bytes: core::mem::take(output),
limit: size,
},
)
.map_err(|_| budget.error())?;
Ok(output)
}
pub fn encode_to_slice<'out, T: Serialize + ?Sized>(
value: &T,
encoding: Encoding,
limits: Limits,
output: &'out mut [u8],
) -> Result<&'out [u8], Error> {
let (header, size) = preflight(value, encoding, limits)?;
let output = output.get_mut(..size).ok_or(Error::Limit)?;
let prefix = if let Some(header) = header {
output[..11].copy_from_slice(&header);
11
} else {
0
};
let budget = Budget::new(limits);
let payload = postcard::to_slice(
&admitted::Bounded {
value,
budget: &budget,
depth: 1,
},
&mut output[prefix..],
)
.map_err(|_| budget.error())?;
let written = prefix + payload.len();
Ok(&output[..written])
}
struct Output {
bytes: Vec<u8>,
limit: usize,
}
impl Flavor for Output {
type Output = Vec<u8>;
fn try_push(&mut self, byte: u8) -> postcard::Result<()> {
if self.bytes.len() == self.limit {
return Err(postcard::Error::SerializeBufferFull);
}
self.bytes.push(byte);
Ok(())
}
fn try_extend(&mut self, bytes: &[u8]) -> postcard::Result<()> {
if bytes.len() > self.limit - self.bytes.len() {
return Err(postcard::Error::SerializeBufferFull);
}
self.bytes.extend_from_slice(bytes);
Ok(())
}
fn finalize(self) -> postcard::Result<Self::Output> {
Ok(self.bytes)
}
}