Refactor goo format

common/src/serde.rs

@@ -1,70 +0,0 @@
-pub struct Serializer<'a> {
-    buffer: &'a mut [u8],
-    offset: usize,
-}
-
-pub struct SizedString<const SIZE: usize> {
-    data: [u8; SIZE],
-}
-
-impl<'a> Serializer<'a> {
-    pub fn new(buffer: &'a mut [u8]) -> Self {
-        Self { buffer, offset: 0 }
-    }
-
-    pub fn write_bool(&mut self, data: bool) {
-        self.write_u8(data as u8);
-    }
-
-    pub fn write_u8(&mut self, data: u8) {
-        self.buffer[self.offset] = data;
-        self.offset += 1;
-    }
-
-    pub fn write_u16(&mut self, data: u16) {
-        self.buffer[self.offset..self.offset + 2].copy_from_slice(&data.to_be_bytes());
-        self.offset += 2;
-    }
-
-    pub fn write_u32(&mut self, data: u32) {
-        self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes());
-        self.offset += 4;
-    }
-
-    pub fn write_u64(&mut self, data: u64) {
-        self.buffer[self.offset..self.offset + 8].copy_from_slice(&data.to_be_bytes());
-        self.offset += 8;
-    }
-
-    pub fn write_f32(&mut self, data: f32) {
-        self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes());
-        self.offset += 4;
-    }
-
-    pub fn write_bytes(&mut self, data: &[u8]) {
-        self.buffer[self.offset..self.offset + data.len()].copy_from_slice(data);
-        self.offset += data.len();
-    }
-
-    pub fn write_sized_string<const SIZE: usize>(&mut self, data: &SizedString<SIZE>) {
-        let len = data.data.len();
-        self.buffer[self.offset..self.offset + len].copy_from_slice(&data.data);
-        self.offset += len;
-    }
-}
-
-impl<const SIZE: usize> SizedString<SIZE> {
-    pub const fn new(data: &[u8]) -> Self {
-        debug_assert!(data.len() <= SIZE);
-
-        // kinda crazy this works in a const fn
-        let mut arr = [0; SIZE];
-        let mut i = 0;
-        while i < SIZE && i < data.len() {
-            arr[i] = data[i];
-            i += 1;
-        }
-
-        Self { data: arr }
-    }
-}

common/src/serde/deserializer.rs

@@ -0,0 +1,79 @@
+use super::SizedString;
+
+pub struct Deserializer<'a> {
+    buffer: &'a [u8],
+    offset: usize,
+}
+
+#[allow(dead_code)]
+impl<'a> Deserializer<'a> {
+    pub fn new(data: &'a [u8]) -> Self {
+        Self {
+            buffer: data,
+            offset: 0,
+        }
+    }
+
+    pub fn read_bool(&mut self) -> bool {
+        self.read_u8() != 0
+    }
+
+    pub fn read_u8(&mut self) -> u8 {
+        let value = self.buffer[self.offset];
+        self.offset += 1;
+        value
+    }
+
+    pub fn read_u16(&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 {
+        let value = u32::from_be_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(&mut self) -> u64 {
+        let value = u64::from_be_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(&mut self) -> f32 {
+        let value = f32::from_be_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;
+        value
+    }
+
+    pub fn read_sized_string<const SIZE: usize>(&mut self) -> SizedString<SIZE> {
+        SizedString::new(self.read_bytes(SIZE))
+    }
+}

common/src/serde/mod.rs

@@ -0,0 +1,7 @@
+mod deserializer;
+mod serializer;
+mod types;
+
+pub use deserializer::Deserializer;
+pub use serializer::Serializer;
+pub use types::SizedString;

common/src/serde/serializer.rs

@@ -0,0 +1,113 @@
+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_bytes(&mut self, data: &[u8]);
+    fn write_sized_string<const SIZE: usize>(&mut self, data: &SizedString<SIZE>);
+}
+
+pub struct SizedSerializer<'a> {
+    buffer: &'a mut [u8],
+    offset: usize,
+}
+
+pub struct DynamicSerializer {
+    buffer: Vec<u8>,
+}
+
+impl<'a> SizedSerializer<'a> {
+    pub fn new(buffer: &'a mut [u8]) -> Self {
+        Self { buffer, offset: 0 }
+    }
+}
+
+impl DynamicSerializer {
+    pub fn new() -> Self {
+        Self { buffer: Vec::new() }
+    }
+
+    pub fn into_inner(self) -> Vec<u8> {
+        self.buffer
+    }
+}
+
+impl Serializer for SizedSerializer<'_> {
+    fn write_bool(&mut self, data: bool) {
+        self.write_u8(data as u8);
+    }
+
+    fn write_u8(&mut self, data: u8) {
+        self.buffer[self.offset] = data;
+        self.offset += 1;
+    }
+
+    fn write_u16(&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) {
+        self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes());
+        self.offset += 4;
+    }
+
+    fn write_u64(&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) {
+        self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes());
+        self.offset += 4;
+    }
+
+    fn write_bytes(&mut self, data: &[u8]) {
+        self.buffer[self.offset..self.offset + data.len()].copy_from_slice(data);
+        self.offset += data.len();
+    }
+
+    fn write_sized_string<const SIZE: usize>(&mut self, data: &SizedString<SIZE>) {
+        let len = data.data.len();
+        self.buffer[self.offset..self.offset + len].copy_from_slice(&data.data);
+        self.offset += len;
+    }
+}
+
+impl Serializer for DynamicSerializer {
+    fn write_bool(&mut self, data: bool) {
+        self.write_u8(data as u8);
+    }
+
+    fn write_u8(&mut self, data: u8) {
+        self.buffer.push(data);
+    }
+
+    fn write_u16(&mut self, data: u16) {
+        self.buffer.extend_from_slice(&data.to_be_bytes());
+    }
+
+    fn write_u32(&mut self, data: u32) {
+        self.buffer.extend_from_slice(&data.to_be_bytes());
+    }
+
+    fn write_u64(&mut self, data: u64) {
+        self.buffer.extend_from_slice(&data.to_be_bytes());
+    }
+
+    fn write_f32(&mut self, data: f32) {
+        self.buffer.extend_from_slice(&data.to_be_bytes());
+    }
+
+    fn write_bytes(&mut self, data: &[u8]) {
+        self.buffer.extend_from_slice(data);
+    }
+
+    fn write_sized_string<const SIZE: usize>(&mut self, data: &SizedString<SIZE>) {
+        self.buffer.extend_from_slice(&data.data);
+    }
+}

common/src/serde/types.rs

@@ -0,0 +1,42 @@
+use std::fmt::{self, Debug, Display};
+
+pub struct SizedString<const SIZE: usize> {
+    pub(crate) data: [u8; SIZE],
+}
+
+impl<const SIZE: usize> SizedString<SIZE> {
+    pub const fn new_full(data: [u8; SIZE]) -> Self {
+        Self { data }
+    }
+
+    pub const fn new(data: &[u8]) -> Self {
+        debug_assert!(data.len() <= SIZE);
+
+        // kinda crazy this works in a const fn
+        let mut arr = [0; SIZE];
+        let mut i = 0;
+        while i < SIZE && i < data.len() {
+            arr[i] = data[i];
+            i += 1;
+        }
+
+        Self { data: arr }
+    }
+}
+
+impl Display for SizedString<32> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let null = self.data.iter().position(|&x| x == 0).unwrap_or(32);
+        f.write_str(&String::from_utf8_lossy(&self.data[..null]))
+    }
+}
+
+impl<const SIZE: usize> Debug for SizedString<SIZE> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let null = self.data.iter().position(|&x| x == 0).unwrap_or(SIZE);
+        f.write_fmt(format_args!(
+            "\"{}\"",
+            String::from_utf8_lossy(&self.data[..null])
+        ))
+    }
+}