use oxicode::config::Configuration;
use oxicode::enc::Writer;
use crate::error::{WireError, WireResult};
pub type WireConfig = Configuration;
pub const WIRE_CONFIG: WireConfig = oxicode::config::standard();
struct VecAppendWriter<'a> {
out: &'a mut Vec<u8>,
}
impl Writer for VecAppendWriter<'_> {
fn write(&mut self, bytes: &[u8]) -> Result<(), oxicode::error::Error> {
self.out.extend_from_slice(bytes);
Ok(())
}
}
pub trait WireEncode {
fn encode_size_hint(&self) -> WireResult<usize>;
fn encode_presized(&self, out: &mut Vec<u8>) -> WireResult<usize>;
fn encode_to_vec(&self) -> WireResult<Vec<u8>> {
let hint = self.encode_size_hint()?;
let mut out = Vec::with_capacity(hint);
self.encode_presized(&mut out)?;
Ok(out)
}
}
impl<T: oxicode::Encode> WireEncode for T {
fn encode_size_hint(&self) -> WireResult<usize> {
Ok(oxicode::encoded_size_with_config(self, WIRE_CONFIG)?)
}
fn encode_presized(&self, out: &mut Vec<u8>) -> WireResult<usize> {
let hint = self.encode_size_hint()?;
let start = out.len();
out.reserve(hint);
let result = {
let writer = VecAppendWriter { out };
oxicode::encode_into_writer(self, writer, WIRE_CONFIG)
};
if let Err(err) = result {
out.truncate(start);
return Err(WireError::Codec(err));
}
let written = out.len() - start;
if written != hint {
out.truncate(start);
return Err(WireError::SizeHintMismatch { hint, written });
}
Ok(written)
}
}
pub trait WireDecode: Sized {
fn decode_exact(bytes: &[u8]) -> WireResult<Self>;
fn decode_prefix(bytes: &[u8]) -> WireResult<(Self, usize)>;
}
impl<T: oxicode::Decode> WireDecode for T {
fn decode_exact(bytes: &[u8]) -> WireResult<Self> {
let (value, consumed) = Self::decode_prefix(bytes)?;
if consumed != bytes.len() {
return Err(WireError::TrailingBytes {
consumed,
trailing: bytes.len() - consumed,
});
}
Ok(value)
}
fn decode_prefix(bytes: &[u8]) -> WireResult<(Self, usize)> {
Ok(oxicode::decode_from_slice_with_config(bytes, WIRE_CONFIG)?)
}
}
pub fn round_trip<T>(value: &T) -> WireResult<T>
where
T: oxicode::Encode + oxicode::Decode,
{
let bytes = value.encode_to_vec()?;
T::decode_exact(&bytes)
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::collections::BTreeMap;
use super::*;
#[test]
fn config_is_little_endian_varint() {
let one = oxicode::encode_to_vec_with_config(&1u32, WIRE_CONFIG).unwrap();
assert_eq!(one, vec![1]);
let large = oxicode::encode_to_vec_with_config(&0x0102_0304u32, WIRE_CONFIG).unwrap();
assert!(large.len() > 1);
assert_eq!(&large[1..], &[0x04, 0x03, 0x02, 0x01]);
}
#[test]
fn size_hint_is_exact_for_a_range_of_shapes() {
macro_rules! check {
($value:expr) => {{
let value = $value;
let hint = value.encode_size_hint().unwrap();
let bytes = value.encode_to_vec().unwrap();
assert_eq!(hint, bytes.len(), "hint mismatch for {:?}", value);
}};
}
check!(0u8);
check!(u64::MAX);
check!(-1i64);
check!(1.5f64);
check!(String::from("astrs"));
check!(vec![0u8; 1000]);
check!(Some(7u32));
check!(Option::<u32>::None);
check!(BTreeMap::from([(1u8, "a".to_owned()), (2, "b".to_owned())]));
check!((1u8, 2u16, 3u32));
}
#[test]
fn encode_presized_appends_without_disturbing_the_prefix() {
let mut buffer = b"header".to_vec();
let written = vec![1u8, 2, 3].encode_presized(&mut buffer).unwrap();
assert_eq!(&buffer[..6], b"header");
assert_eq!(buffer.len(), 6 + written);
}
#[test]
fn encode_presized_reserves_exactly_the_hint() {
let value = vec![7u8; 4096];
let hint = value.encode_size_hint().unwrap();
let mut buffer = Vec::new();
let written = value.encode_presized(&mut buffer).unwrap();
assert_eq!(written, hint);
assert_eq!(buffer.len(), hint);
}
#[test]
fn decode_exact_rejects_trailing_bytes() {
let mut bytes = 1234u32.encode_to_vec().unwrap();
let good = bytes.len();
bytes.extend_from_slice(&[0, 0, 0]);
match u32::decode_exact(&bytes) {
Err(WireError::TrailingBytes { consumed, trailing }) => {
assert_eq!(consumed, good);
assert_eq!(trailing, 3);
}
other => panic!("expected TrailingBytes, got {other:?}"),
}
}
#[test]
fn decode_exact_rejects_truncated_input() {
let bytes = String::from("hello").encode_to_vec().unwrap();
let err = String::decode_exact(&bytes[..bytes.len() - 1]).unwrap_err();
assert!(matches!(err, WireError::Codec(_)));
}
#[test]
fn decode_prefix_tolerates_a_remainder() {
let mut bytes = 9u16.encode_to_vec().unwrap();
bytes.extend_from_slice(b"rest");
let (value, consumed) = u16::decode_prefix(&bytes).unwrap();
assert_eq!(value, 9);
assert_eq!(&bytes[consumed..], b"rest");
}
#[test]
fn round_trip_preserves_nested_collections() {
let value: BTreeMap<String, Vec<u32>> =
BTreeMap::from([("a".to_owned(), vec![1, 2, 3]), ("b".to_owned(), vec![])]);
assert_eq!(round_trip(&value).unwrap(), value);
}
#[test]
fn empty_input_decodes_only_zero_sized_shapes() {
assert_eq!(<()>::decode_exact(&[]).unwrap(), ());
assert!(u8::decode_exact(&[]).is_err());
}
#[test]
fn encoding_is_deterministic() {
let value = BTreeMap::from([(3u8, "c"), (1, "a"), (2, "b")]);
let first = value.encode_to_vec().unwrap();
let second = value.encode_to_vec().unwrap();
assert_eq!(first, second);
}
}