1use std::mem::size_of;
2
3use fusio::{Error, 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 async fn encode<W: Write>(&self, writer: &mut W) -> Result<(), Error> {
12 #[cfg(feature = "monoio")]
13 let (result, _) = writer.write_all(self.to_le_bytes().to_vec()).await;
14 #[cfg(not(feature = "monoio"))]
15 let (result, _) = writer.write_all(&self.to_le_bytes()[..]).await;
16 result?;
17
18 Ok(())
19 }
20
21 fn size(&self) -> usize {
22 size_of::<Self>()
23 }
24 }
25
26 impl Decode for $struct_name {
27 async fn decode<R: SeqRead>(reader: &mut R) -> Result<Self, Error> {
28 #[cfg(feature = "monoio")]
29 let data = {
30 let (result, buf) = reader.read_exact(vec![0u8; size_of::<Self>()]).await;
31 result?;
32 Self::from_le_bytes(buf.try_into().unwrap())
33 };
34 #[cfg(not(feature = "monoio"))]
35 let data = {
36 let mut bytes = [0u8; size_of::<Self>()];
37 let (result, _) = reader.read_exact(&mut bytes[..]).await;
38 result?;
39 Self::from_le_bytes(bytes)
40 };
41
42 Ok(data)
43 }
44 }
45 };
46}
47
48implement_encode_decode!(i8);
49implement_encode_decode!(i16);
50implement_encode_decode!(i32);
51implement_encode_decode!(i64);
52implement_encode_decode!(u8);
53implement_encode_decode!(u16);
54implement_encode_decode!(u32);
55implement_encode_decode!(u64);
56
57implement_encode_decode!(f32);
58implement_encode_decode!(f64);
59
60#[cfg(test)]
61mod tests {
62 use core::{f32, f64};
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 async fn encode_decode_float() {
110 {
111 let source_0 = 1.1_f32;
112 let source_1 = 1.1_f64;
113 let source_2 = 32.0_f32;
114 let source_3 = 64.6_f64;
115 let source_4 = -1.1_f32;
116 let source_5 = -1.1_f64;
117 let source_6 = -32.0_f32;
118 let source_7 = -64.6_f64;
119
120 let mut bytes = Vec::new();
121 let mut cursor = Cursor::new(&mut bytes);
122
123 source_0.encode(&mut cursor).await.unwrap();
124 source_1.encode(&mut cursor).await.unwrap();
125 source_2.encode(&mut cursor).await.unwrap();
126 source_3.encode(&mut cursor).await.unwrap();
127 source_4.encode(&mut cursor).await.unwrap();
128 source_5.encode(&mut cursor).await.unwrap();
129 source_6.encode(&mut cursor).await.unwrap();
130 source_7.encode(&mut cursor).await.unwrap();
131
132 cursor.seek(std::io::SeekFrom::Start(0)).unwrap();
133 let decoded_0 = f32::decode(&mut cursor).await.unwrap();
134 let decoded_1 = f64::decode(&mut cursor).await.unwrap();
135 let decoded_2 = f32::decode(&mut cursor).await.unwrap();
136 let decoded_3 = f64::decode(&mut cursor).await.unwrap();
137 let decoded_4 = f32::decode(&mut cursor).await.unwrap();
138 let decoded_5 = f64::decode(&mut cursor).await.unwrap();
139 let decoded_6 = f32::decode(&mut cursor).await.unwrap();
140 let decoded_7 = f64::decode(&mut cursor).await.unwrap();
141
142 assert_eq!(source_0, decoded_0);
143 assert_eq!(source_1, decoded_1);
144 assert_eq!(source_2, decoded_2);
145 assert_eq!(source_3, decoded_3);
146 assert_eq!(source_4, decoded_4);
147 assert_eq!(source_5, decoded_5);
148 assert_eq!(source_6, decoded_6);
149 assert_eq!(source_7, decoded_7);
150 }
151 {
152 let zero = 0.0_f32;
153 let neg_zero = -0.0_f32;
154 let neg_inf = f32::NEG_INFINITY;
155 let inf = f32::INFINITY;
156 let nan = f32::NAN;
157 let neg_nan = -f32::NAN;
158
159 let mut bytes = Vec::new();
160 let mut cursor = Cursor::new(&mut bytes);
161
162 zero.encode(&mut cursor).await.unwrap();
163 neg_zero.encode(&mut cursor).await.unwrap();
164 neg_inf.encode(&mut cursor).await.unwrap();
165 inf.encode(&mut cursor).await.unwrap();
166 nan.encode(&mut cursor).await.unwrap();
167 neg_nan.encode(&mut cursor).await.unwrap();
168
169 cursor.seek(std::io::SeekFrom::Start(0)).unwrap();
170 let decoded_zero = f32::decode(&mut cursor).await.unwrap();
171 let decoded_neg_zero = f32::decode(&mut cursor).await.unwrap();
172 let decoded_neg_inf = f32::decode(&mut cursor).await.unwrap();
173 let decoded_inf = f32::decode(&mut cursor).await.unwrap();
174 let decoded_nan = f32::decode(&mut cursor).await.unwrap();
175 let decoded_neg_nan = f32::decode(&mut cursor).await.unwrap();
176
177 assert_eq!(zero, decoded_zero);
178 assert!(decoded_zero.is_sign_positive());
179
180 assert_eq!(neg_zero, decoded_neg_zero);
181 assert!(decoded_neg_zero.is_sign_negative());
182
183 assert_eq!(neg_inf, decoded_neg_inf);
184 assert!(decoded_inf.is_infinite());
185 assert!(decoded_inf.is_sign_positive());
186
187 assert_eq!(inf, decoded_inf);
188 assert!(decoded_inf.is_infinite());
189 assert!(decoded_inf.is_sign_positive());
190
191 assert_eq!(nan.is_nan(), decoded_nan.is_nan());
192 assert!(decoded_nan.is_sign_positive());
193
194 assert_eq!(neg_nan.is_nan(), decoded_neg_nan.is_nan());
195 assert!(decoded_neg_nan.is_sign_negative());
196 }
197 {
198 let zero = 0.0_f64;
199 let neg_zero = -0.0_f64;
200 let neg_inf = f64::NEG_INFINITY;
201 let inf = f64::INFINITY;
202 let nan = f64::NAN;
203 let neg_nan = -f64::NAN;
204
205 let mut bytes = Vec::new();
206 let mut cursor = Cursor::new(&mut bytes);
207
208 zero.encode(&mut cursor).await.unwrap();
209 neg_zero.encode(&mut cursor).await.unwrap();
210 neg_inf.encode(&mut cursor).await.unwrap();
211 inf.encode(&mut cursor).await.unwrap();
212 nan.encode(&mut cursor).await.unwrap();
213 neg_nan.encode(&mut cursor).await.unwrap();
214
215 cursor.seek(std::io::SeekFrom::Start(0)).unwrap();
216 let decoded_zero = f64::decode(&mut cursor).await.unwrap();
217 let decoded_neg_zero = f64::decode(&mut cursor).await.unwrap();
218 let decoded_neg_inf = f64::decode(&mut cursor).await.unwrap();
219 let decoded_inf = f64::decode(&mut cursor).await.unwrap();
220 let decoded_nan = f64::decode(&mut cursor).await.unwrap();
221 let decoded_neg_nan = f64::decode(&mut cursor).await.unwrap();
222
223 assert_eq!(zero, decoded_zero);
224 assert!(decoded_zero.is_sign_positive());
225
226 assert_eq!(neg_zero, decoded_neg_zero);
227 assert!(decoded_neg_zero.is_sign_negative());
228
229 assert_eq!(neg_inf, decoded_neg_inf);
230 assert!(decoded_inf.is_infinite());
231 assert!(decoded_inf.is_sign_positive());
232
233 assert_eq!(inf, decoded_inf);
234 assert!(decoded_inf.is_infinite());
235 assert!(decoded_inf.is_sign_positive());
236
237 assert_eq!(nan.is_nan(), decoded_nan.is_nan());
238 assert!(decoded_nan.is_sign_positive());
239
240 assert_eq!(neg_nan.is_nan(), decoded_neg_nan.is_nan());
241 assert!(decoded_neg_nan.is_sign_negative());
242 }
243 }
244
245 #[cfg(feature = "tokio")]
246 #[tokio::test]
247 async fn test_tokio_encode_decode() {
248 encode_decode().await;
249 }
250
251 #[cfg(feature = "monoio")]
252 #[monoio::test]
253 async fn test_monoio_encode_decode() {
254 encode_decode().await;
255 }
256
257 #[cfg(feature = "tokio")]
258 #[tokio::test]
259 async fn test_tokio_encode_decode_float() {
260 encode_decode_float().await;
261 }
262
263 #[cfg(feature = "monoio")]
264 #[monoio::test]
265 async fn test_monoio_encode_decode_float() {
266 encode_decode_float().await;
267 }
268}