naia_serde/impls/
scalars.rs

1use crate::{
2    bit_reader::BitReader,
3    bit_writer::BitWrite,
4    error::SerdeErr,
5    serde::{ConstBitLength, Serde},
6};
7
8// Unit //
9
10impl Serde for () {
11    fn ser(&self, _: &mut dyn BitWrite) {}
12
13    fn de(_: &mut BitReader) -> Result<Self, SerdeErr> {
14        Ok(())
15    }
16
17    fn bit_length(&self) -> u32 {
18        <Self as ConstBitLength>::const_bit_length()
19    }
20}
21
22impl ConstBitLength for () {
23    fn const_bit_length() -> u32 {
24        0
25    }
26}
27
28// tests
29
30#[cfg(test)]
31mod unit_tests {
32    use crate::{bit_reader::BitReader, bit_writer::BitWriter, serde::Serde};
33
34    #[test]
35    fn read_write() {
36        // Write
37        let mut writer = BitWriter::new();
38
39        let in_unit = ();
40
41        in_unit.ser(&mut writer);
42
43        let buffer = writer.to_bytes();
44
45        //Read
46        let mut reader = BitReader::new(&buffer);
47
48        let out_unit = Serde::de(&mut reader).unwrap();
49
50        assert_eq!(in_unit, out_unit);
51    }
52}
53
54// Boolean //
55
56impl Serde for bool {
57    fn ser(&self, writer: &mut dyn BitWrite) {
58        writer.write_bit(*self);
59    }
60
61    fn de(reader: &mut BitReader) -> Result<Self, SerdeErr> {
62        reader.read_bit()
63    }
64
65    fn bit_length(&self) -> u32 {
66        <Self as ConstBitLength>::const_bit_length()
67    }
68}
69
70impl ConstBitLength for bool {
71    fn const_bit_length() -> u32 {
72        1
73    }
74}
75
76// tests
77
78#[cfg(test)]
79mod bool_tests {
80    use crate::{bit_reader::BitReader, bit_writer::BitWriter, serde::Serde};
81
82    #[test]
83    fn read_write() {
84        // Write
85        let mut writer = BitWriter::new();
86
87        let in_1 = true;
88        let in_2 = false;
89
90        in_1.ser(&mut writer);
91        in_2.ser(&mut writer);
92
93        let buffer = writer.to_bytes();
94
95        //Read
96        let mut reader = BitReader::new(&buffer);
97
98        let out_1 = Serde::de(&mut reader).unwrap();
99        let out_2 = Serde::de(&mut reader).unwrap();
100
101        assert_eq!(in_1, out_1);
102        assert_eq!(in_2, out_2);
103    }
104}
105
106// Characters //
107
108impl Serde for char {
109    fn ser(&self, writer: &mut dyn BitWrite) {
110        let u32char = *self as u32;
111        let bytes = unsafe { std::mem::transmute::<&u32, &[u8; 4]>(&u32char) };
112        for byte in bytes {
113            writer.write_byte(*byte);
114        }
115    }
116
117    fn de(reader: &mut BitReader) -> Result<Self, SerdeErr> {
118        let mut bytes = [0_u8; 4];
119        for byte in &mut bytes {
120            *byte = reader.read_byte()?;
121        }
122        let mut container = [0_u32];
123        unsafe {
124            std::ptr::copy_nonoverlapping(
125                bytes.as_ptr().offset(0_isize) as *const u32,
126                container.as_mut_ptr() as *mut u32,
127                1,
128            )
129        }
130
131        if let Some(inner_char) = char::from_u32(container[0]) {
132            Ok(inner_char)
133        } else {
134            Err(SerdeErr {})
135        }
136    }
137
138    fn bit_length(&self) -> u32 {
139        <Self as ConstBitLength>::const_bit_length()
140    }
141}
142
143impl ConstBitLength for char {
144    fn const_bit_length() -> u32 {
145        <[u8; 4] as ConstBitLength>::const_bit_length()
146    }
147}
148
149// tests
150
151#[cfg(test)]
152mod char_tests {
153    use crate::{bit_reader::BitReader, bit_writer::BitWriter, serde::Serde};
154
155    #[test]
156    fn read_write() {
157        // Write
158        let mut writer = BitWriter::new();
159
160        let in_1 = 'O';
161        let in_2 = '!';
162
163        in_1.ser(&mut writer);
164        in_2.ser(&mut writer);
165
166        let buffer = writer.to_bytes();
167
168        //Read
169        let mut reader = BitReader::new(&buffer);
170
171        let out_1 = Serde::de(&mut reader).unwrap();
172        let out_2 = Serde::de(&mut reader).unwrap();
173
174        assert_eq!(in_1, out_1);
175        assert_eq!(in_2, out_2);
176    }
177}
178
179// Integers & Floating-point Numbers //
180
181macro_rules! impl_serde_for {
182    ($impl_type:ident) => {
183        impl Serde for $impl_type {
184            fn ser(&self, writer: &mut dyn BitWrite) {
185                let du8 = unsafe {
186                    std::mem::transmute::<&$impl_type, &[u8; std::mem::size_of::<$impl_type>()]>(
187                        &self,
188                    )
189                };
190                for byte in du8 {
191                    writer.write_byte(*byte);
192                }
193            }
194
195            fn de(reader: &mut BitReader) -> Result<$impl_type, SerdeErr> {
196                const BYTES_LENGTH: usize = std::mem::size_of::<$impl_type>();
197                let mut byte_array = [0_u8; BYTES_LENGTH];
198                for index in 0..BYTES_LENGTH {
199                    byte_array[index] = reader.read_byte()?;
200                }
201                let mut container = [0 as $impl_type];
202                unsafe {
203                    std::ptr::copy_nonoverlapping(
204                        byte_array.as_ptr() as *const $impl_type,
205                        container.as_mut_ptr() as *mut $impl_type,
206                        1,
207                    )
208                }
209                Ok(container[0])
210            }
211
212            fn bit_length(&self) -> u32 {
213                <Self as ConstBitLength>::const_bit_length()
214            }
215        }
216        impl ConstBitLength for $impl_type {
217            fn const_bit_length() -> u32 {
218                const BYTES_LENGTH: u32 = std::mem::size_of::<$impl_type>() as u32;
219                return BYTES_LENGTH * 8;
220            }
221        }
222    };
223}
224
225// number primitives
226impl_serde_for!(u16);
227impl_serde_for!(u32);
228impl_serde_for!(u64);
229impl_serde_for!(i16);
230impl_serde_for!(i32);
231impl_serde_for!(i64);
232impl_serde_for!(f32);
233impl_serde_for!(f64);
234
235// u8
236impl Serde for u8 {
237    fn ser(&self, writer: &mut dyn BitWrite) {
238        writer.write_byte(*self);
239    }
240
241    fn de(reader: &mut BitReader) -> Result<u8, SerdeErr> {
242        reader.read_byte()
243    }
244
245    fn bit_length(&self) -> u32 {
246        <Self as ConstBitLength>::const_bit_length()
247    }
248}
249
250impl ConstBitLength for u8 {
251    fn const_bit_length() -> u32 {
252        8
253    }
254}
255
256// i8
257impl Serde for i8 {
258    fn ser(&self, writer: &mut dyn BitWrite) {
259        let du8 = unsafe { std::mem::transmute::<&i8, &u8>(self) };
260        writer.write_byte(*du8);
261    }
262
263    fn de(reader: &mut BitReader) -> Result<i8, SerdeErr> {
264        let byte = [reader.read_byte()?];
265        let mut container = [0_i8];
266        unsafe {
267            std::ptr::copy_nonoverlapping(
268                byte.as_ptr() as *const i8,
269                container.as_mut_ptr() as *mut i8,
270                1,
271            )
272        }
273        Ok(container[0])
274    }
275
276    fn bit_length(&self) -> u32 {
277        <Self as ConstBitLength>::const_bit_length()
278    }
279}
280
281impl ConstBitLength for i8 {
282    fn const_bit_length() -> u32 {
283        8
284    }
285}
286
287// usize
288impl Serde for usize {
289    fn ser(&self, writer: &mut dyn BitWrite) {
290        let u64usize = *self as u64;
291        let du8 = unsafe { std::mem::transmute::<&u64, &[u8; 8]>(&u64usize) };
292        for byte in du8 {
293            writer.write_byte(*byte);
294        }
295    }
296
297    fn de(reader: &mut BitReader) -> Result<usize, SerdeErr> {
298        let mut byte_array = [0_u8; 8];
299        for byte in &mut byte_array {
300            *byte = reader.read_byte()?;
301        }
302        let mut container = [0_u64];
303        unsafe {
304            std::ptr::copy_nonoverlapping(
305                byte_array.as_ptr().offset(0_isize) as *const u64,
306                container.as_mut_ptr() as *mut u64,
307                1,
308            )
309        }
310        Ok(container[0] as usize)
311    }
312
313    fn bit_length(&self) -> u32 {
314        <Self as ConstBitLength>::const_bit_length()
315    }
316}
317
318impl ConstBitLength for usize {
319    fn const_bit_length() -> u32 {
320        <u64 as ConstBitLength>::const_bit_length()
321    }
322}
323
324// isize
325impl Serde for isize {
326    fn ser(&self, writer: &mut dyn BitWrite) {
327        let u64usize = *self as u64;
328        let du8 = unsafe { std::mem::transmute::<&u64, &[u8; 8]>(&u64usize) };
329        for byte in du8 {
330            writer.write_byte(*byte);
331        }
332    }
333
334    fn de(reader: &mut BitReader) -> Result<isize, SerdeErr> {
335        let mut byte_array = [0_u8; 8];
336        for byte in &mut byte_array {
337            *byte = reader.read_byte()?;
338        }
339        let mut container = [0_u64];
340        unsafe {
341            std::ptr::copy_nonoverlapping(
342                byte_array.as_ptr().offset(0_isize) as *const u64,
343                container.as_mut_ptr() as *mut u64,
344                1,
345            )
346        }
347        Ok(container[0] as isize)
348    }
349
350    fn bit_length(&self) -> u32 {
351        <Self as ConstBitLength>::const_bit_length()
352    }
353}
354
355impl ConstBitLength for isize {
356    fn const_bit_length() -> u32 {
357        <u64 as ConstBitLength>::const_bit_length()
358    }
359}
360
361// tests
362
363macro_rules! test_serde_for {
364    ($impl_type:ident, $test_name:ident) => {
365        #[test]
366        fn $test_name() {
367            use crate::{bit_reader::BitReader, bit_writer::BitWriter, serde::Serde};
368
369            // Write
370            let mut writer = BitWriter::new();
371
372            let in_1: $impl_type = 123 as $impl_type;
373
374            in_1.ser(&mut writer);
375
376            let buffer = writer.to_bytes();
377
378            //Read
379            let mut reader = BitReader::new(&buffer);
380
381            let out_1 = Serde::de(&mut reader).unwrap();
382
383            assert_eq!(in_1, out_1);
384        }
385    };
386}
387
388mod number_tests {
389    test_serde_for!(u8, test_u8);
390    test_serde_for!(u16, test_u16);
391    test_serde_for!(u32, test_u32);
392    test_serde_for!(u64, test_u64);
393    test_serde_for!(usize, test_usize);
394    test_serde_for!(i8, test_i8);
395    test_serde_for!(i16, test_i16);
396    test_serde_for!(i32, test_i32);
397    test_serde_for!(i64, test_i64);
398    test_serde_for!(isize, test_isize);
399    test_serde_for!(f32, test_f32);
400    test_serde_for!(f64, test_f64);
401}
naia_serde/impls/scalars.rs

naia_serde/impls/
scalars.rs
