98 lines
2.6 KiB
Rust
98 lines
2.6 KiB
Rust
use core::ops::DerefMut;
|
|
|
|
use crate::error::Error;
|
|
|
|
pub trait SerializeBuffer {
|
|
fn write_bytes(&mut self, data: &[u8]) -> Result<(), Error>;
|
|
}
|
|
|
|
pub trait DeserializeBuffer {
|
|
fn read_bytes(&mut self, data: &mut [u8]) -> Result<(), Error>;
|
|
}
|
|
|
|
pub unsafe trait Serialize {
|
|
fn serialize<B: SerializeBuffer>(&self, target: &mut B) -> Result<(), Error>;
|
|
}
|
|
|
|
pub trait Deserialize: Sized {
|
|
unsafe fn deserialize<B: DeserializeBuffer>(source: &mut B) -> Result<Self, Error>;
|
|
}
|
|
|
|
pub struct SliceSerializeBuffer<T: DerefMut<Target = [u8]>> {
|
|
data: T,
|
|
}
|
|
|
|
impl<T: DerefMut<Target = [u8]>> SliceSerializeBuffer<T> {
|
|
pub fn new(data: T) -> Self {
|
|
Self { data }
|
|
}
|
|
}
|
|
|
|
impl<T: DerefMut<Target = [u8]>> SerializeBuffer for SliceSerializeBuffer<T> {
|
|
fn write_bytes(&mut self, data: &[u8]) -> Result<(), Error> {
|
|
if data.len() > self.data.len() {
|
|
return Err(Error::InvalidArgument);
|
|
}
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
macro_rules! int_serde_impl {
|
|
($ty:ty) => {
|
|
unsafe impl Serialize for $ty {
|
|
fn serialize<B: SerializeBuffer>(&self, target: &mut B) -> Result<(), Error> {
|
|
target.write_bytes(&self.to_ne_bytes())
|
|
}
|
|
}
|
|
|
|
impl Deserialize for $ty {
|
|
unsafe fn deserialize<B: DeserializeBuffer>(source: &mut B) -> Result<Self, Error> {
|
|
let mut bytes = [0; core::mem::size_of::<Self>()];
|
|
source.read_bytes(&mut bytes)?;
|
|
Ok(Self::from_ne_bytes(bytes))
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
int_serde_impl!(usize);
|
|
int_serde_impl!(u64);
|
|
int_serde_impl!(u32);
|
|
int_serde_impl!(u16);
|
|
|
|
unsafe impl Serialize for u8 {
|
|
fn serialize<B: SerializeBuffer>(&self, target: &mut B) -> Result<(), Error> {
|
|
target.write_bytes(&[*self])
|
|
}
|
|
}
|
|
|
|
impl Deserialize for u8 {
|
|
unsafe fn deserialize<B: DeserializeBuffer>(source: &mut B) -> Result<Self, Error> {
|
|
let mut buffer = [0; 1];
|
|
source.read_bytes(&mut buffer)?;
|
|
Ok(buffer[0])
|
|
}
|
|
}
|
|
|
|
unsafe impl<T: Serialize> Serialize for [T] {
|
|
fn serialize<B: SerializeBuffer>(&self, target: &mut B) -> Result<(), Error> {
|
|
self.len().serialize(target)?;
|
|
for item in self.iter() {
|
|
item.serialize(target)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
unsafe impl Serialize for str {
|
|
fn serialize<B: SerializeBuffer>(&self, target: &mut B) -> Result<(), Error> {
|
|
self.as_bytes().serialize(target)
|
|
}
|
|
}
|
|
|
|
unsafe impl<T: Serialize + ?Sized> Serialize for &T {
|
|
fn serialize<B: SerializeBuffer>(&self, target: &mut B) -> Result<(), Error> {
|
|
(*self).serialize(target)
|
|
}
|
|
}
|