fusio_log/serdes/
num.rs

1use std::mem::size_of;
2
3use fusio::{SeqRead, Write};
4
5use super::{Decode, Encode};
6
7#[macro_export]
8macro_rules! implement_encode_decode {
9    ($struct_name:ident) => {
10        impl Encode for $struct_name {
11            type Error = fusio::Error;
12
13            async fn encode<W: Write>(&self, writer: &mut W) -> Result<(), Self::Error> {
14                #[cfg(feature = "monoio")]
15                let (result, _) = writer.write_all(self.to_le_bytes().to_vec()).await;
16                #[cfg(not(feature = "monoio"))]
17                let (result, _) = writer.write_all(&self.to_le_bytes()[..]).await;
18                result?;
19
20                Ok(())
21            }
22
23            fn size(&self) -> usize {
24                size_of::<Self>()
25            }
26        }
27
28        impl Decode for $struct_name {
29            type Error = fusio::Error;
30
31            async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Self::Error> {
32                #[cfg(feature = "monoio")]
33                let data = {
34                    let (result, buf) = reader.read_exact(vec![0u8; size_of::<Self>()]).await;
35                    result?;
36                    Self::from_le_bytes(buf.try_into().unwrap())
37                };
38                #[cfg(not(feature = "monoio"))]
39                let data = {
40                    let mut bytes = [0u8; size_of::<Self>()];
41                    let (result, _) = reader.read_exact(&mut bytes[..]).await;
42                    result?;
43                    Self::from_le_bytes(bytes)
44                };
45
46                Ok(data)
47            }
48        }
49    };
50}
51
52implement_encode_decode!(i8);
53implement_encode_decode!(i16);
54implement_encode_decode!(i32);
55implement_encode_decode!(i64);
56implement_encode_decode!(u8);
57implement_encode_decode!(u16);
58implement_encode_decode!(u32);
59implement_encode_decode!(u64);
60
61#[cfg(test)]
62mod tests {
63    use std::io::{Cursor, Seek};
64
65    use crate::serdes::{Decode, Encode};
66
67    async fn encode_decode() {
68        let source_0 = 8u8;
69        let source_1 = 16u16;
70        let source_2 = 32u32;
71        let source_3 = 64u64;
72        let source_4 = 8i8;
73        let source_5 = 16i16;
74        let source_6 = 32i32;
75        let source_7 = 64i64;
76
77        let mut bytes = Vec::new();
78        let mut cursor = Cursor::new(&mut bytes);
79
80        source_0.encode(&mut cursor).await.unwrap();
81        source_1.encode(&mut cursor).await.unwrap();
82        source_2.encode(&mut cursor).await.unwrap();
83        source_3.encode(&mut cursor).await.unwrap();
84        source_4.encode(&mut cursor).await.unwrap();
85        source_5.encode(&mut cursor).await.unwrap();
86        source_6.encode(&mut cursor).await.unwrap();
87        source_7.encode(&mut cursor).await.unwrap();
88
89        cursor.seek(std::io::SeekFrom::Start(0)).unwrap();
90        let decoded_0 = u8::decode(&mut cursor).await.unwrap();
91        let decoded_1 = u16::decode(&mut cursor).await.unwrap();
92        let decoded_2 = u32::decode(&mut cursor).await.unwrap();
93        let decoded_3 = u64::decode(&mut cursor).await.unwrap();
94        let decoded_4 = i8::decode(&mut cursor).await.unwrap();
95        let decoded_5 = i16::decode(&mut cursor).await.unwrap();
96        let decoded_6 = i32::decode(&mut cursor).await.unwrap();
97        let decoded_7 = i64::decode(&mut cursor).await.unwrap();
98
99        assert_eq!(source_0, decoded_0);
100        assert_eq!(source_1, decoded_1);
101        assert_eq!(source_2, decoded_2);
102        assert_eq!(source_3, decoded_3);
103        assert_eq!(source_4, decoded_4);
104        assert_eq!(source_5, decoded_5);
105        assert_eq!(source_6, decoded_6);
106        assert_eq!(source_7, decoded_7);
107    }
108
109    #[cfg(feature = "tokio")]
110    #[tokio::test]
111    async fn test_tokio_encode_decode() {
112        encode_decode().await;
113    }
114
115    #[cfg(feature = "monoio")]
116    #[monoio::test]
117    async fn test_monoio_encode_decode() {
118        encode_decode().await;
119    }
120}