fusio_log/serdes/
mod.rs

1mod arc;
2mod boolean;
3#[cfg(feature = "bytes")]
4mod bytes;
5mod list;
6mod num;
7pub(crate) mod option;
8mod string;
9
10use std::future::Future;
11
12use crate::fs::{MaybeSend, SeqRead, Write};
13
14pub trait Encode {
15    fn encode<W>(
16        &self,
17        writer: &mut W,
18    ) -> impl Future<Output = Result<(), fusio::Error>> + MaybeSend
19    where
20        W: Write;
21
22    fn size(&self) -> usize;
23}
24
25impl<T: Encode + Sync> Encode for &T {
26    async fn encode<W>(&self, writer: &mut W) -> Result<(), fusio::Error>
27    where
28        W: Write,
29    {
30        Encode::encode(*self, writer).await
31    }
32
33    fn size(&self) -> usize {
34        Encode::size(*self)
35    }
36}
37
38pub trait Decode: Sized {
39    fn decode<R>(reader: &mut R) -> impl Future<Output = Result<Self, fusio::Error>> + MaybeSend
40    where
41        R: SeqRead;
42}
43
44#[cfg(test)]
45mod tests {
46    use std::io;
47
48    use tokio::io::AsyncSeekExt;
49
50    use super::*;
51
52    #[tokio::test]
53    async fn test_encode_decode() {
54        // Implement a simple struct that implements Encode and Decode
55        struct TestStruct(u32);
56
57        impl Encode for TestStruct {
58            async fn encode<W>(&self, writer: &mut W) -> Result<(), fusio::Error>
59            where
60                W: Write,
61            {
62                self.0.encode(writer).await?;
63
64                Ok(())
65            }
66
67            fn size(&self) -> usize {
68                std::mem::size_of::<u32>()
69            }
70        }
71
72        impl Decode for TestStruct {
73            async fn decode<R>(reader: &mut R) -> Result<Self, fusio::Error>
74            where
75                R: SeqRead,
76            {
77                Ok(TestStruct(u32::decode(reader).await?))
78            }
79        }
80
81        // Test encoding and decoding
82        let original = TestStruct(42);
83        let mut buf = Vec::new();
84        let mut cursor = io::Cursor::new(&mut buf);
85        original.encode(&mut cursor).await.unwrap();
86
87        cursor.seek(std::io::SeekFrom::Start(0)).await.unwrap();
88        let decoded = TestStruct::decode(&mut cursor).await.unwrap();
89
90        assert_eq!(original.0, decoded.0);
91    }
92}