extern crate alloc;
use alloc::borrow::Cow;
use core::str;
pub(super) struct EncDecErr;
pub(super) trait EncodeBufferFallible {
type Err;
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) -> Result<(), Self::Err>;
}
pub(super) trait EncodeBuffer {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>);
}
impl EncodeBuffer for u8 {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.push(*self);
}
}
impl EncodeBuffer for u16 {
#[expect(
clippy::little_endian_bytes,
reason = "we must standardize the endianness to remove ambiguity"
)]
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.extend_from_slice(self.to_le_bytes().as_slice());
}
}
impl EncodeBuffer for u32 {
#[expect(
clippy::little_endian_bytes,
reason = "we must standardize the endianness to remove ambiguity"
)]
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.extend_from_slice(self.to_le_bytes().as_slice());
}
}
impl EncodeBuffer for u64 {
#[expect(
clippy::little_endian_bytes,
reason = "we must standardize the endianness to remove ambiguity"
)]
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.extend_from_slice(self.to_le_bytes().as_slice());
}
}
impl EncodeBuffer for u128 {
#[expect(
clippy::little_endian_bytes,
reason = "we must standardize the endianness to remove ambiguity"
)]
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.extend_from_slice(self.to_le_bytes().as_slice());
}
}
#[expect(clippy::as_conversions, reason = "this is safe, and we want a const")]
const FALSE: u8 = false as u8;
#[expect(clippy::as_conversions, reason = "this is safe, and we want a const")]
const TRUE: u8 = true as u8;
impl EncodeBuffer for bool {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.push(if *self { TRUE } else { FALSE });
}
}
impl EncodeBufferFallible for [u8] {
type Err = EncDecErr;
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) -> Result<(), Self::Err> {
u16::try_from(self.len())
.map_err(|_e| EncDecErr)
.map(|len| {
len.encode_into_buffer(buffer);
buffer.extend_from_slice(self);
})
}
}
impl EncodeBufferFallible for Box<[u8]> {
type Err = EncDecErr;
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) -> Result<(), Self::Err> {
(&self).encode_into_buffer(buffer)
}
}
impl EncodeBufferFallible for Vec<u8> {
type Err = EncDecErr;
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) -> Result<(), Self::Err> {
self.as_slice().encode_into_buffer(buffer)
}
}
impl<const LEN: usize> EncodeBuffer for [u8; LEN]
where
[u8; LEN]: Default,
{
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
buffer.extend_from_slice(self.as_slice());
}
}
const NONE: u8 = 0;
const SOME: u8 = 1;
impl<T: EncodeBuffer> EncodeBuffer for Option<T> {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
match *self {
None => {
buffer.push(NONE);
}
Some(ref val) => {
buffer.push(SOME);
val.encode_into_buffer(buffer);
}
}
}
}
impl<T: EncodeBuffer, T2: EncodeBuffer> EncodeBuffer for (T, T2) {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
self.0.encode_into_buffer(buffer);
self.1.encode_into_buffer(buffer);
}
}
impl EncodeBufferFallible for str {
type Err = EncDecErr;
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) -> Result<(), Self::Err> {
self.as_bytes().encode_into_buffer(buffer)
}
}
impl EncodeBufferFallible for String {
type Err = EncDecErr;
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) -> Result<(), Self::Err> {
self.as_str().encode_into_buffer(buffer)
}
}
impl EncodeBufferFallible for Cow<'_, str> {
type Err = EncDecErr;
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) -> Result<(), Self::Err> {
self.as_ref().encode_into_buffer(buffer)
}
}
impl<T: EncodeBuffer + ?Sized> EncodeBuffer for &T {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
(**self).encode_into_buffer(buffer);
}
}
impl<T: EncodeBuffer + ?Sized> EncodeBuffer for &mut T {
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) {
(**self).encode_into_buffer(buffer);
}
}
impl<T: EncodeBufferFallible + ?Sized> EncodeBufferFallible for &T {
type Err = T::Err;
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) -> Result<(), Self::Err> {
(**self).encode_into_buffer(buffer)
}
}
impl<T: EncodeBufferFallible + ?Sized> EncodeBufferFallible for &mut T {
type Err = T::Err;
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) -> Result<(), Self::Err> {
(**self).encode_into_buffer(buffer)
}
}
impl<T: EncodeBufferFallible> EncodeBufferFallible for Option<T> {
type Err = T::Err;
fn encode_into_buffer(&self, buffer: &mut Vec<u8>) -> Result<(), Self::Err> {
match *self {
None => {
buffer.push(NONE);
Ok(())
}
Some(ref val) => {
buffer.push(SOME);
val.encode_into_buffer(buffer)
}
}
}
}
pub(super) trait DecodeBuffer<'a>: Sized {
type Err;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err>;
}
impl<'a> DecodeBuffer<'a> for u8 {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
data.split_first().ok_or(EncDecErr).map(|(&val, rem)| {
*data = rem;
val
})
}
}
impl<'a> DecodeBuffer<'a> for u16 {
type Err = EncDecErr;
#[expect(
clippy::little_endian_bytes,
reason = "we must standardize the endianness to remove ambiguity"
)]
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
const SIZE: usize = 2;
data.split_at_checked(SIZE)
.ok_or(EncDecErr)
.map(|(le_bytes, rem)| {
*data = rem;
let mut val = [0; SIZE];
val.copy_from_slice(le_bytes);
Self::from_le_bytes(val)
})
}
}
impl<'a> DecodeBuffer<'a> for u32 {
type Err = EncDecErr;
#[expect(
clippy::little_endian_bytes,
reason = "we must standardize the endianness to remove ambiguity"
)]
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
const SIZE: usize = 4;
data.split_at_checked(SIZE)
.ok_or(EncDecErr)
.map(|(le_bytes, rem)| {
*data = rem;
let mut val = [0; SIZE];
val.copy_from_slice(le_bytes);
Self::from_le_bytes(val)
})
}
}
impl<'a> DecodeBuffer<'a> for u64 {
type Err = EncDecErr;
#[expect(
clippy::little_endian_bytes,
reason = "we must standardize the endianness to remove ambiguity"
)]
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
const SIZE: usize = 8;
data.split_at_checked(SIZE)
.ok_or(EncDecErr)
.map(|(le_bytes, rem)| {
*data = rem;
let mut val = [0; SIZE];
val.copy_from_slice(le_bytes);
Self::from_le_bytes(val)
})
}
}
impl<'a> DecodeBuffer<'a> for u128 {
type Err = EncDecErr;
#[expect(
clippy::little_endian_bytes,
reason = "we must standardize the endianness to remove ambiguity"
)]
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
const SIZE: usize = 16;
data.split_at_checked(SIZE)
.ok_or(EncDecErr)
.map(|(le_bytes, rem)| {
*data = rem;
let mut val = [0; SIZE];
val.copy_from_slice(le_bytes);
Self::from_le_bytes(val)
})
}
}
impl<'a> DecodeBuffer<'a> for bool {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
u8::decode_from_buffer(data).and_then(|val| match val {
FALSE => Ok(false),
TRUE => Ok(true),
_ => Err(EncDecErr),
})
}
}
impl<'a> DecodeBuffer<'a> for &'a [u8] {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
u16::decode_from_buffer(data).and_then(|len| {
data.split_at_checked(usize::from(len))
.ok_or(EncDecErr)
.map(|(val, rem)| {
*data = rem;
val
})
})
}
}
impl<'a> DecodeBuffer<'a> for Box<[u8]> {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
<&[u8]>::decode_from_buffer(data).map(Self::from)
}
}
impl<'a> DecodeBuffer<'a> for Vec<u8> {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
<&[u8]>::decode_from_buffer(data).map(ToOwned::to_owned)
}
}
impl<'a, const LEN: usize> DecodeBuffer<'a> for [u8; LEN]
where
[u8; LEN]: Default,
{
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
data.split_at_checked(LEN)
.ok_or(EncDecErr)
.map(|(val_slice, rem)| {
*data = rem;
let mut val = Self::default();
val.copy_from_slice(val_slice);
val
})
}
}
impl<'a, T> DecodeBuffer<'a> for Option<T>
where
T: DecodeBuffer<'a, Err = EncDecErr>,
{
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
u8::decode_from_buffer(data).and_then(|tag| match tag {
NONE => Ok(None),
SOME => T::decode_from_buffer(data).map(Some),
_ => Err(EncDecErr),
})
}
}
impl<'a, T, T2> DecodeBuffer<'a> for (T, T2)
where
T: DecodeBuffer<'a, Err = EncDecErr>,
T2: DecodeBuffer<'a, Err = EncDecErr>,
{
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
T::decode_from_buffer(data)
.and_then(|val| T2::decode_from_buffer(data).map(|val2| (val, val2)))
}
}
impl<'a> DecodeBuffer<'a> for &'a str {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
<&[u8]>::decode_from_buffer(data)
.and_then(|utf8| str::from_utf8(utf8).map_err(|_e| EncDecErr))
}
}
impl<'a> DecodeBuffer<'a> for String {
type Err = EncDecErr;
fn decode_from_buffer(data: &mut &'a [u8]) -> Result<Self, Self::Err> {
<&str>::decode_from_buffer(data).map(ToOwned::to_owned)
}
}
pub trait Encode {
type Output<'a>
where
Self: 'a;
type Err;
fn encode(&self) -> Result<Self::Output<'_>, Self::Err>;
}
pub trait Decode: Sized {
type Input<'a>;
type Err;
fn decode(input: Self::Input<'_>) -> Result<Self, Self::Err>;
}