use alloc::{format, string::String, vec::Vec};
use core::{convert::TryFrom, ops::Deref};
use crate::cid::Cid;
use crate::error::{Result, UnsupportedCodec};
use crate::io::{Cursor, Read, Seek, Write};
use crate::ipld::Ipld;
pub trait Codec:
Copy + Unpin + Send + Sync + 'static + Sized + TryFrom<u64, Error = UnsupportedCodec> + Into<u64>
{
fn encode<T: Encode<Self> + ?Sized>(&self, obj: &T) -> Result<Vec<u8>> {
let mut buf = Vec::with_capacity(u16::MAX as usize);
obj.encode(*self, &mut buf)?;
Ok(buf)
}
fn decode<T: Decode<Self>>(&self, bytes: &[u8]) -> Result<T> {
T::decode(*self, &mut Cursor::new(bytes))
}
fn references<T: References<Self>, E: Extend<Cid>>(
&self,
bytes: &[u8],
set: &mut E,
) -> Result<()> {
T::references(*self, &mut Cursor::new(bytes), set)
}
}
pub trait Encode<C: Codec> {
fn encode<W: Write>(&self, c: C, w: &mut W) -> Result<()>;
}
impl<C: Codec, T: Encode<C>> Encode<C> for &T {
fn encode<W: Write>(&self, c: C, w: &mut W) -> Result<()> {
self.deref().encode(c, w)
}
}
pub trait Decode<C: Codec>: Sized {
fn decode<R: Read + Seek>(c: C, r: &mut R) -> Result<Self>;
}
pub trait References<C: Codec>: Sized {
fn references<R: Read + Seek, E: Extend<Cid>>(c: C, r: &mut R, set: &mut E) -> Result<()>;
}
pub fn assert_roundtrip<C, T>(c: C, data: &T, ipld: &Ipld)
where
C: Codec,
T: Decode<C> + Encode<C> + core::fmt::Debug + PartialEq,
Ipld: Decode<C> + Encode<C>,
{
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|byte| format!("{:02x}", byte)).collect()
}
let mut bytes = Vec::new();
data.encode(c, &mut bytes).unwrap();
let mut bytes2 = Vec::new();
ipld.encode(c, &mut bytes2).unwrap();
if bytes != bytes2 {
panic!(
r#"assertion failed: `(left == right)`
left: `{}`,
right: `{}`"#,
hex(&bytes),
hex(&bytes2)
);
}
let ipld2: Ipld = Decode::decode(c, &mut Cursor::new(bytes.as_slice())).unwrap();
assert_eq!(&ipld2, ipld);
let data2: T = Decode::decode(c, &mut Cursor::new(bytes.as_slice())).unwrap();
assert_eq!(&data2, data);
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ipld::Ipld;
use anyhow::anyhow;
#[derive(Clone, Copy, Debug)]
struct CodecImpl;
impl Codec for CodecImpl {}
impl From<CodecImpl> for u64 {
fn from(_: CodecImpl) -> Self {
0
}
}
impl TryFrom<u64> for CodecImpl {
type Error = UnsupportedCodec;
fn try_from(_: u64) -> core::result::Result<Self, Self::Error> {
Ok(Self)
}
}
impl Encode<CodecImpl> for Ipld {
fn encode<W: Write>(&self, _: CodecImpl, w: &mut W) -> Result<()> {
match self {
Self::Null => Ok(w.write_all(&[0]).map_err(anyhow::Error::msg)?),
_ => Err(anyhow!("not null")),
}
}
}
impl Decode<CodecImpl> for Ipld {
fn decode<R: Read>(_: CodecImpl, r: &mut R) -> Result<Self> {
let mut buf = [0; 1];
r.read_exact(&mut buf).map_err(anyhow::Error::msg)?;
if buf[0] == 0 {
Ok(Ipld::Null)
} else {
Err(anyhow!("not null"))
}
}
}
#[test]
fn test_codec() {
let bytes = CodecImpl.encode(&Ipld::Null).unwrap();
let ipld: Ipld = CodecImpl.decode(&bytes).unwrap();
assert_eq!(ipld, Ipld::Null);
}
}