Add little endian serde functions

common/src/serde/deserializer.rs

@@ -1,3 +1,5 @@
+use std::mem;
+
 use super::SizedString;
 
 pub struct Deserializer<'a> {
@@ -18,6 +20,18 @@ impl<'a> Deserializer<'a> {
         self.offset
     }
 
+    pub fn advance_by(&mut self, amount: usize) {
+        self.offset += amount;
+    }
+
+    pub fn advance<T>(&mut self) {
+        self.advance_by(mem::size_of::<T>());
+    }
+
+    pub fn jump_to(&mut self, pos: usize) {
+        self.offset = pos;
+    }
+
     pub fn read_bool(&mut self) -> bool {
         self.read_u8() != 0
     }
@@ -28,13 +42,19 @@ impl<'a> Deserializer<'a> {
         value
     }
 
-    pub fn read_u16(&mut self) -> u16 {
+    pub fn read_u16_be(&mut self) -> u16 {
         let value = u16::from_be_bytes([self.buffer[self.offset], self.buffer[self.offset + 1]]);
         self.offset += 2;
         value
     }
 
-    pub fn read_u32(&mut self) -> u32 {
+    pub fn read_u16_le(&mut self) -> u16 {
+        let value = u16::from_le_bytes([self.buffer[self.offset], self.buffer[self.offset + 1]]);
+        self.offset += 2;
+        value
+    }
+
+    pub fn read_u32_be(&mut self) -> u32 {
         let value = u32::from_be_bytes([
             self.buffer[self.offset],
             self.buffer[self.offset + 1],
@@ -45,7 +65,18 @@ impl<'a> Deserializer<'a> {
         value
     }
 
-    pub fn read_u64(&mut self) -> u64 {
+    pub fn read_u32_le(&mut self) -> u32 {
+        let value = u32::from_le_bytes([
+            self.buffer[self.offset],
+            self.buffer[self.offset + 1],
+            self.buffer[self.offset + 2],
+            self.buffer[self.offset + 3],
+        ]);
+        self.offset += 4;
+        value
+    }
+
+    pub fn read_u64_be(&mut self) -> u64 {
         let value = u64::from_be_bytes([
             self.buffer[self.offset],
             self.buffer[self.offset + 1],
@@ -60,7 +91,22 @@ impl<'a> Deserializer<'a> {
         value
     }
 
-    pub fn read_f32(&mut self) -> f32 {
+    pub fn read_u64_le(&mut self) -> u64 {
+        let value = u64::from_le_bytes([
+            self.buffer[self.offset],
+            self.buffer[self.offset + 1],
+            self.buffer[self.offset + 2],
+            self.buffer[self.offset + 3],
+            self.buffer[self.offset + 4],
+            self.buffer[self.offset + 5],
+            self.buffer[self.offset + 6],
+            self.buffer[self.offset + 7],
+        ]);
+        self.offset += 8;
+        value
+    }
+
+    pub fn read_f32_be(&mut self) -> f32 {
         let value = f32::from_be_bytes([
             self.buffer[self.offset],
             self.buffer[self.offset + 1],
@@ -71,6 +117,17 @@ impl<'a> Deserializer<'a> {
         value
     }
 
+    pub fn read_f32_le(&mut self) -> f32 {
+        let value = f32::from_le_bytes([
+            self.buffer[self.offset],
+            self.buffer[self.offset + 1],
+            self.buffer[self.offset + 2],
+            self.buffer[self.offset + 3],
+        ]);
+        self.offset += 4;
+        value
+    }
+
     pub fn read_bytes(&mut self, length: usize) -> &'a [u8] {
         let value = &self.buffer[self.offset..self.offset + length];
         self.offset += length;

common/src/serde/serializer.rs

@@ -3,10 +3,10 @@ use super::SizedString;
 pub trait Serializer {
     fn write_bool(&mut self, data: bool);
     fn write_u8(&mut self, data: u8);
-    fn write_u16(&mut self, data: u16);
-    fn write_u32(&mut self, data: u32);
-    fn write_u64(&mut self, data: u64);
-    fn write_f32(&mut self, data: f32);
+    fn write_u16_be(&mut self, data: u16);
+    fn write_u32_be(&mut self, data: u32);
+    fn write_u64_be(&mut self, data: u64);
+    fn write_f32_be(&mut self, data: f32);
     fn write_bytes(&mut self, data: &[u8]);
     fn write_sized_string<const SIZE: usize>(&mut self, data: &SizedString<SIZE>);
 }
@@ -46,22 +46,22 @@ impl Serializer for SizedSerializer<'_> {
         self.offset += 1;
     }
 
-    fn write_u16(&mut self, data: u16) {
+    fn write_u16_be(&mut self, data: u16) {
         self.buffer[self.offset..self.offset + 2].copy_from_slice(&data.to_be_bytes());
         self.offset += 2;
     }
 
-    fn write_u32(&mut self, data: u32) {
+    fn write_u32_be(&mut self, data: u32) {
         self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes());
         self.offset += 4;
     }
 
-    fn write_u64(&mut self, data: u64) {
+    fn write_u64_be(&mut self, data: u64) {
         self.buffer[self.offset..self.offset + 8].copy_from_slice(&data.to_be_bytes());
         self.offset += 8;
     }
 
-    fn write_f32(&mut self, data: f32) {
+    fn write_f32_be(&mut self, data: f32) {
         self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes());
         self.offset += 4;
     }
@@ -87,19 +87,19 @@ impl Serializer for DynamicSerializer {
         self.buffer.push(data);
     }
 
-    fn write_u16(&mut self, data: u16) {
+    fn write_u16_be(&mut self, data: u16) {
         self.buffer.extend_from_slice(&data.to_be_bytes());
     }
 
-    fn write_u32(&mut self, data: u32) {
+    fn write_u32_be(&mut self, data: u32) {
         self.buffer.extend_from_slice(&data.to_be_bytes());
     }
 
-    fn write_u64(&mut self, data: u64) {
+    fn write_u64_be(&mut self, data: u64) {
         self.buffer.extend_from_slice(&data.to_be_bytes());
     }
 
-    fn write_f32(&mut self, data: f32) {
+    fn write_f32_be(&mut self, data: f32) {
         self.buffer.extend_from_slice(&data.to_be_bytes());
     }