optimize

rnex-core/src/rmc/structures/any.rs

@@ -9,7 +9,7 @@ pub struct Any{
 }
 
 impl RmcSerialize for Any{
-    fn serialize(&self, writer: &mut dyn Write) -> Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> Result<()> {
         self.name.serialize(writer)?;
 
         let u32_len = self.data.len() as u32;
@@ -21,7 +21,7 @@ impl RmcSerialize for Any{
 
         Ok(())
     }
-    fn deserialize(mut reader: &mut dyn Read) -> Result<Self> {
+    fn deserialize(mut reader: &mut impl Read) -> Result<Self> {
         let name = String::deserialize(reader)?;
 
         // also length ?

rnex-core/src/rmc/structures/buffer.rs

@@ -4,7 +4,7 @@ use crate::rmc::structures::RmcSerialize;
 
 
 impl<'a> RmcSerialize for &'a [u8]{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         let u32_size = self.len() as u32;
         writer.write(bytemuck::bytes_of(&u32_size))?;
         writer.write(self)?;
@@ -13,17 +13,25 @@ impl<'a> RmcSerialize for &'a [u8]{
     }
 
     /// DO NOT USE (also maybe split off the serialize and deserialize functions at some point)
-    fn deserialize(_reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(_reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         panic!("cannot deserialize to a u8 slice reference (use this ONLY for writing)")
     }
+
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(4 + self.len() as u32)
+    }
 }
 
 impl RmcSerialize for Box<[u8]>{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         (&self[..]).serialize(writer)
     }
 
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Vec::deserialize(reader).map(|v| v.into_boxed_slice())
     }
+
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        (&self[..]).serialize_write_size()
+    }
 }

rnex-core/src/rmc/structures/helpers.rs

@@ -0,0 +1,48 @@
+use std::{fmt, io};
+
+pub struct DummyFormatWriter(u32);
+
+impl fmt::Write for DummyFormatWriter{
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.0 += s.as_bytes().len() as u32;
+        Ok(())
+    }
+}
+
+impl DummyFormatWriter{
+    pub const fn new() -> Self{ Self(0) }
+    pub const fn serialize_str_len(&self) -> u32 {
+        2 + self.0 + 1
+    }
+}
+
+pub struct DummyWriter(u32);
+
+impl io::Write for DummyWriter{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0 += buf.len() as u32;
+        Ok(buf.len())
+    }
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        self.0 += buf.len() as u32;
+        Ok(())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl DummyWriter{
+    pub const fn new() -> Self{ Self(0) }
+    pub const fn get_total_len(&self) -> u32{
+        self.0
+    }
+}
+
+
+pub fn len_of_write(f: impl FnOnce(&mut DummyWriter) -> anyhow::Result<()>) -> u32{
+    let mut dummy = DummyWriter::new();
+    f(&mut dummy).ok();
+    dummy.get_total_len()
+}

rnex-core/src/rmc/structures/list.rs

@@ -9,7 +9,7 @@ use crate::rmc::structures::RmcSerialize;
 // this is also for implementing `Buffer` this is tecnically not the same as its handled internaly 
 // probably but as it has the same mapping it doesn't matter and simplifies things
 impl<T: RmcSerialize> RmcSerialize for Vec<T>{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         let u32_len = self.len() as u32;
 
         writer.write_all(bytes_of(&u32_len))?;
@@ -20,21 +20,27 @@ impl<T: RmcSerialize> RmcSerialize for Vec<T>{
         Ok(())
     }
 
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(mut reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         let len: u32 = reader.read_struct(IS_BIG_ENDIAN)?;
 
-        let mut vec = Vec::with_capacity(len as usize);
+        //let mut vec = Vec::with_capacity(len as usize);
 
-        for _ in 0..len{
-            vec.push(T::deserialize(reader)?);
-        }
+        let vec = (0..len).map(|_| T::deserialize(reader)).collect::<Result<Vec<_>, _>>()?;
 
         Ok(vec)
     }
+    
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        let mut val = 0u32;
+        for i in self{
+            val += i.serialize_write_size()?;
+        }
+        Ok(4 + val)
+    }
 }
 
 impl<const LEN: usize, T: RmcSerialize> RmcSerialize for [T; LEN]{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         for i in 0..LEN{
             self[i].serialize(writer)?;
         }
@@ -42,7 +48,7 @@ impl<const LEN: usize, T: RmcSerialize> RmcSerialize for [T; LEN]{
         Ok(())
     }
 
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         let mut arr = [const { MaybeUninit::<T>::uninit() }; LEN];
 
         for i in 0..LEN{
@@ -55,4 +61,12 @@ impl<const LEN: usize, T: RmcSerialize> RmcSerialize for [T; LEN]{
 
         Ok(arr)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        let mut val = 0u32;
+        for i in self{
+            val += i.serialize_write_size()?;
+        }
+        Ok(val)
+    }
 }

rnex-core/src/rmc/structures/mod.rs

@@ -1,8 +1,8 @@
-use std::io;
+use std::{fmt, io};
 use std::io::{Read, Write};
 use std::string::FromUtf8Error;
 use thiserror::Error;
-
+use crate::rmc::structures::helpers::DummyWriter;
 //ideas for the future: make a proc macro library which allows generation of struct reads
 
 #[derive(Error, Debug)]
@@ -16,7 +16,9 @@ pub enum Error{
     #[error("version mismatch: {0}")]
     VersionMismatch(u8),
     #[error("an error occurred reading the station url")]
-    StationUrlInvalid
+    StationUrlInvalid,
+    #[error("error formatting text: {0}")]
+    FormatError(#[from] fmt::Error)
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -33,28 +35,43 @@ pub mod primitives;
 pub mod matchmake;
 pub mod variant;
 pub mod ranking;
-mod networking;
+pub mod networking;
+pub mod helpers;
 
 pub trait RmcSerialize{
-    fn serialize(&self, writer: &mut dyn Write) -> Result<()>;
-    fn deserialize(reader: &mut dyn Read) -> Result<Self> where Self: Sized;
+    fn serialize(&self, writer: &mut impl Write) -> Result<()>;
+    fn serialize_write_size(&self) -> Result<u32>{
+        let mut dummy = DummyWriter::new();
 
-    fn to_data(&self) -> Vec<u8>{
-        let mut data = Vec::new();
+        self.serialize(&mut dummy)?;
 
-        self.serialize(&mut data).expect("out of memory or something");
+        Ok(dummy.get_total_len())
+    }
+    fn deserialize(reader: &mut impl Read) -> Result<Self> where Self: Sized;
 
-        data
+    fn to_data(&self) -> Result<Vec<u8>>{
+        let mut data = Vec::with_capacity(
+            self.serialize_write_size()? as usize
+        );
+
+        self.serialize(&mut data)?;
+
+        debug_assert_eq!(self.serialize_write_size().unwrap(), data.len() as u32);
+
+        Ok(data)
     }
 }
 
 impl RmcSerialize for (){
-    fn serialize(&self, _writer: &mut dyn Write) -> Result<()> {
+    fn serialize(&self, _writer: &mut impl Write) -> Result<()> {
         Ok(())
     }
-    fn deserialize(_reader: &mut dyn Read) -> Result<Self> {
+    fn deserialize(_reader: &mut impl Read) -> Result<Self> {
         Ok(())
     }
+    fn serialize_write_size(&self) -> Result<u32> {
+        Ok(0)
+    }
 
     
 }

rnex-core/src/rmc/structures/networking.rs

@@ -4,30 +4,36 @@ use rnex_core::prudp::virtual_port::VirtualPort;
 use crate::rmc::structures::RmcSerialize;
 
 impl RmcSerialize for SocketAddrV4{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         self.ip().to_bits().serialize(writer)?;
         self.port().serialize(writer)?;
 
         Ok(())
     }
 
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         let ip = u32::deserialize(reader)?;
         let port = u16::deserialize(reader)?;
 
         Ok(SocketAddrV4::new(Ipv4Addr::from_bits(ip), port))
     }
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(6)
+    }
 }
 
 
 impl RmcSerialize for VirtualPort{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         self.0.serialize(writer)?;
 
         Ok(())
     }
 
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Ok(Self(u8::deserialize(reader)?))
     }
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(1)
+    }
 }

rnex-core/src/rmc/structures/primitives.rs

@@ -4,97 +4,146 @@ use v_byte_helpers::{IS_BIG_ENDIAN, ReadExtensions};
 use crate::rmc::structures::RmcSerialize;
 
 impl RmcSerialize for u8{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         Ok(writer.write_all(bytes_of(self))?)
     }
 
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(mut reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Ok(reader.read_struct(IS_BIG_ENDIAN)?)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(1)
+    }
 }
 
 impl RmcSerialize for i8{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         Ok(writer.write_all(bytes_of(self))?)
     }
 
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(mut reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Ok(reader.read_struct(IS_BIG_ENDIAN)?)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(1)
+    }
 }
 
 impl RmcSerialize for u16{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         Ok(writer.write_all(bytes_of(self))?)
     }
-
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(mut reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Ok(reader.read_struct(IS_BIG_ENDIAN)?)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(2)
+    }
 }
 
 impl RmcSerialize for i16{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         Ok(writer.write_all(bytes_of(self))?)
     }
-
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(mut reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Ok(reader.read_struct(IS_BIG_ENDIAN)?)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(2)
+    }
 }
 
 impl RmcSerialize for u32{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         Ok(writer.write_all(bytes_of(self))?)
     }
-
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(mut reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Ok(reader.read_struct(IS_BIG_ENDIAN)?)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(4)
+    }
 }
 
 impl RmcSerialize for i32{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         Ok(writer.write_all(bytes_of(self))?)
     }
-
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(mut reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Ok(reader.read_struct(IS_BIG_ENDIAN)?)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(4)
+    }
 }
 
 impl RmcSerialize for u64{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         Ok(writer.write_all(bytes_of(self))?)
     }
-
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(mut reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Ok(reader.read_struct(IS_BIG_ENDIAN)?)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(8)
+    }
 }
 
 impl RmcSerialize for i64{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         Ok(writer.write_all(bytes_of(self))?)
     }
-
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(mut reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Ok(reader.read_struct(IS_BIG_ENDIAN)?)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(8)
+    }
 }
 
 impl RmcSerialize for f64{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         Ok(writer.write_all(bytes_of(self))?)
     }
 
-    fn deserialize(mut reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(mut reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Ok(reader.read_struct(IS_BIG_ENDIAN)?)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(8)
+    }
 }
 
 impl RmcSerialize for bool{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         match self{
             true => writer.write_all(&[1])?,
             false => writer.write_all(&[0])?,
@@ -102,54 +151,77 @@ impl RmcSerialize for bool{
         Ok(())
     }
 
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         Ok(u8::deserialize(reader)? != 0)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(1)
+    }
 }
 
 
 impl<T: RmcSerialize, U: RmcSerialize> RmcSerialize for (T, U){
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         self.0.serialize(writer)?;
         self.1.serialize(writer)?;
         Ok(())
     }
-
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         let first = T::deserialize(reader)?;
         let second = U::deserialize(reader)?;
 
         Ok((first, second))
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(
+            self.0.serialize_write_size()? +
+            self.1.serialize_write_size()?
+        )
+    }
 }
 
 impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize> RmcSerialize for (T, U, V){
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         self.0.serialize(writer)?;
         self.1.serialize(writer)?;
         self.2.serialize(writer)?;
         Ok(())
     }
-
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         let first = T::deserialize(reader)?;
         let second = U::deserialize(reader)?;
         let third = V::deserialize(reader)?;
 
         Ok((first, second, third))
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(
+            self.0.serialize_write_size()? +
+            self.1.serialize_write_size()? +
+            self.2.serialize_write_size()?
+        )
+    }
 }
 
 impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize> RmcSerialize for (T, U, V, W){
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         self.0.serialize(writer)?;
         self.1.serialize(writer)?;
         self.2.serialize(writer)?;
         self.3.serialize(writer)?;
         Ok(())
     }
-
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         let first = T::deserialize(reader)?;
         let second = U::deserialize(reader)?;
         let third = V::deserialize(reader)?;
@@ -157,10 +229,20 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize> RmcSeri
 
         Ok((first, second, third, fourth))
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(
+            self.0.serialize_write_size()? +
+            self.1.serialize_write_size()? +
+            self.2.serialize_write_size()? +
+            self.3.serialize_write_size()?
+        )
+    }
 }
 
 impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcSerialize> RmcSerialize for (T, U, V, W, X){
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         self.0.serialize(writer)?;
         self.1.serialize(writer)?;
         self.2.serialize(writer)?;
@@ -170,7 +252,8 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcS
         Ok(())
     }
 
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         let first = T::deserialize(reader)?;
         let second = U::deserialize(reader)?;
         let third = V::deserialize(reader)?;
@@ -179,10 +262,21 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcS
 
         Ok((first, second, third, fourth, fifth))
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(
+            self.0.serialize_write_size()? +
+            self.1.serialize_write_size()? +
+            self.2.serialize_write_size()? +
+            self.2.serialize_write_size()? +
+            self.3.serialize_write_size()?
+        )
+    }
 }
 
 impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcSerialize, Y: RmcSerialize> RmcSerialize for (T, U, V, W, X, Y){
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         self.0.serialize(writer)?;
         self.1.serialize(writer)?;
         self.2.serialize(writer)?;
@@ -193,7 +287,8 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcS
         Ok(())
     }
 
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         let first = T::deserialize(reader)?;
         let second = U::deserialize(reader)?;
         let third = V::deserialize(reader)?;
@@ -203,10 +298,22 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcS
 
         Ok((first, second, third, fourth, fifth, sixth))
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(
+            self.0.serialize_write_size()? +
+                self.1.serialize_write_size()? +
+                self.2.serialize_write_size()? +
+                self.3.serialize_write_size()? +
+                self.4.serialize_write_size()? +
+                self.5.serialize_write_size()?
+        )
+    }
 }
 
 impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcSerialize, Y: RmcSerialize, Z: RmcSerialize> RmcSerialize for (T, U, V, W, X, Y, Z){
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         self.0.serialize(writer)?;
         self.1.serialize(writer)?;
         self.2.serialize(writer)?;
@@ -217,8 +324,8 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcS
 
         Ok(())
     }
-
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         let first = T::deserialize(reader)?;
         let second = U::deserialize(reader)?;
         let third = V::deserialize(reader)?;
@@ -229,13 +336,31 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcS
 
         Ok((first, second, third, fourth, fifth, sixth, seventh))
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        Ok(
+            self.0.serialize_write_size()? +
+                self.1.serialize_write_size()? +
+                self.2.serialize_write_size()? +
+                self.3.serialize_write_size()? +
+                self.4.serialize_write_size()? +
+                self.5.serialize_write_size()? +
+                self.6.serialize_write_size()?
+        )
+    }
 }
 
 impl<T: RmcSerialize> RmcSerialize for Box<T>{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    #[inline(always)]
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         self.as_ref().serialize(writer)
     }
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    #[inline(always)]
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         T::deserialize(reader).map(Box::new)
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+        T::serialize_write_size(self.as_ref())
+    }
 }

rnex-core/src/rmc/structures/qbuffer.rs

@@ -8,7 +8,7 @@ use crate::rmc::structures::{Result, RmcSerialize};
 pub struct QBuffer(pub Vec<u8>);
 
 impl RmcSerialize for QBuffer{
-    fn serialize(&self, writer: &mut dyn Write) -> Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> Result<()> {
         let len_u16 = self.0.len() as u16;
 
         writer.write(bytes_of(&len_u16))?;
@@ -17,7 +17,7 @@ impl RmcSerialize for QBuffer{
         Ok(())
     }
 
-    fn deserialize(mut reader: &mut dyn Read) -> Result<Self> {
+    fn deserialize(mut reader: &mut impl Read) -> Result<Self> {
         let size: u16 = reader.read_struct(IS_BIG_ENDIAN)?;
 
         let mut vec = vec![0; size as usize];

rnex-core/src/rmc/structures/qresult.rs

@@ -26,12 +26,12 @@ impl QResult{
 }
 
 impl RmcSerialize for QResult{
-    fn serialize(&self, writer: &mut dyn Write) -> Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> Result<()> {
         writer.write(bytes_of(self))?;
         Ok(())
     }
 
-    fn deserialize(mut reader: &mut dyn Read) -> Result<Self> {
+    fn deserialize(mut reader: &mut impl Read) -> Result<Self> {
         Ok(reader.read_struct(IS_BIG_ENDIAN)?)
     }
 }

rnex-core/src/rmc/structures/rmc_struct.rs

@@ -1,6 +1,12 @@
-use std::io::{Cursor, Read, Write};
+use std::any::Any;
+use std::cmp::max;
+use std::fmt::Arguments;
+use std::io;
+use std::io::{Cursor, ErrorKind, IoSlice, Read, Write};
+use std::ops::Sub;
 use bytemuck::bytes_of;
 use v_byte_helpers::{IS_BIG_ENDIAN, ReadExtensions};
+use crate::rmc::structures;
 use crate::rmc::structures::Error::VersionMismatch;
 use crate::rmc::structures::Result;
 
@@ -10,35 +16,97 @@ struct StructureHeader{
     length: u32
 }
 
-pub fn write_struct(writer: &mut dyn Write, version: u8, pred: impl FnOnce(&mut Vec<u8>) -> Result<()> ) -> Result<()> {
+#[cfg(feature = "rmc_struct_header")]
+pub const HEADER_SIZE: u32 = 0;
+#[cfg(not(feature = "rmc_struct_header"))]
+pub const HEADER_SIZE: u32 = 5;
+
+pub struct OnlyWriteVec<'a>(&'a mut Vec<u8>);
+
+impl Write for OnlyWriteVec<'_> {
+    fn flush(&mut self) -> io::Result<()> {
+        self.0.flush()
+    }
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.write(buf)
+    }
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        self.0.write_all(buf)
+    }
+    fn write_fmt(&mut self, args: Arguments<'_>) -> io::Result<()> {
+        self.0.write_fmt(args)
+    }
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        self.0.write_vectored(bufs)
+    }
+}
+
+#[cfg(feature = "rmc_struct_header")]
+pub fn write_struct<T: Write>(writer: &mut T, version: u8, inner_size: u32, pred: impl FnOnce(&mut T) -> Result<()> ) -> Result<()> {
     writer.write_all(&[version])?;
 
-    let mut scratch_space: Vec<u8> = Vec::new();
+    writer.write_all(bytes_of(&inner_size))?;
 
-    (pred)(&mut scratch_space)?;
-
-    let u32_size = scratch_space.len() as u32;
-
-    writer.write_all(bytes_of(&u32_size))?;
-    writer.write_all(&scratch_space)?;
+    (pred)(writer)?;
 
     Ok(())
 }
 
-pub fn read_struct<T: Sized>(mut reader: &mut dyn Read, version: u8, pred: impl FnOnce(&mut Cursor<Vec<u8>>) -> Result<T>) -> Result<T> {
+
+
+#[cfg(not(feature = "rmc_struct_header"))]
+pub fn write_struct<T: Write>(writer: &mut T, version: u8, _inner_size: u32, pred: impl FnOnce(&mut T) -> Result<()> ) -> Result<()> {
+    pred(writer)
+}
+
+
+pub struct SubRead<'a, T: Read>{
+    left_to_read: usize,
+    origin: &'a mut T
+}
+
+impl<'a, T: Read> SubRead<'a, T>{
+    pub const fn new(origin: &'a mut T, left_to_read: usize) -> Self{
+        Self{
+            left_to_read,
+            origin
+        }
+    }
+}
+
+impl<T: Read> Read for SubRead<'_, T>{
+    #[inline(always)]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let max_read = max(self.left_to_read, buf.len());
+        let read = self.origin.read(&mut buf[..max_read])?;
+        self.left_to_read -= read;
+        Ok(read)
+    }
+
+    #[inline(always)]
+    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+        if buf.len() > self.left_to_read{
+            return Err(io::Error::new(ErrorKind::UnexpectedEof, "Would run over end of SubRead"));
+        }
+        self.left_to_read -= buf.len();
+        self.origin.read_exact(buf)
+    }
+}
+
+#[cfg(feature = "rmc_struct_header")]
+pub fn read_struct<T: Sized, R: Read>(mut reader: &mut R, version: u8, pred: impl FnOnce(&mut SubRead<R>) -> Result<T>) -> Result<T> {
     let ver: u8 = reader.read_struct(IS_BIG_ENDIAN)?;
 
-    if ver != version{
+    if ver != version {
         return Err(VersionMismatch(ver));
     }
 
     let size: u32 = reader.read_struct(IS_BIG_ENDIAN)?;
 
-    let mut vec = vec![0u8; size as usize];
+    Ok(pred(&mut SubRead::new(reader, size as usize))?)
+}
 
-    reader.read_exact(&mut vec)?;
-
-    let mut cursor = Cursor::new(vec);
-
-    Ok(pred(&mut cursor)?)
-}
+#[cfg(not(feature = "rmc_struct_header"))]
+pub fn read_struct<T: Sized, R: Read>(mut reader: &mut R, version: u8, pred: impl FnOnce(&mut R) -> Result<T>) -> Result<T> {
+    Ok(pred(&mut reader)?)
+}

rnex-core/src/rmc/structures/string.rs

@@ -1,39 +1,49 @@
 use std::io::{Read, Write};
 use bytemuck::bytes_of;
 use log::error;
+use rocket::form::validate::Len;
 use v_byte_helpers::{IS_BIG_ENDIAN, ReadExtensions};
 use super::{Result, RmcSerialize};
 
 impl RmcSerialize for String{
-    fn deserialize(mut reader: &mut dyn Read) -> Result<Self> {
+    fn deserialize(mut reader: &mut impl Read) -> Result<Self> {
         let len: u16 = reader.read_struct(IS_BIG_ENDIAN)?;
-        let mut data = vec![0; len as usize - 1];
+        if len == 0{
+            return Ok("".to_string());
+        }
+        let mut data = vec![0; len as usize];
         reader.read_exact(&mut data)?;
-
-        let null: u8 = reader.read_struct(IS_BIG_ENDIAN)?;
-        if null != 0{
+        if *data.last().unwrap() != 0{
             error!("unable to find null terminator... continuing anyways");
         }
+        data.pop();
 
         Ok(String::from_utf8(data)?)
     }
-    fn serialize(&self, writer: &mut dyn Write) -> Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> Result<()> {
         (&self[..]).serialize(writer)
     }
+    fn serialize_write_size(&self) -> Result<u32> {
+        (&self[..]).serialize_write_size()
+    }
 }
 
 impl RmcSerialize for &str{
-    fn deserialize(_reader: &mut dyn Read) -> Result<Self> {
+    fn deserialize(_reader: &mut impl Read) -> Result<Self> {
         panic!("cannot serialize to &str")
     }
-    fn serialize(&self, writer: &mut dyn Write) -> Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> Result<()> {
         let u16_len: u16 = (self.len() + 1) as u16;
-        writer.write(bytes_of(&u16_len))?;
+        writer.write_all(bytes_of(&u16_len))?;
 
-        writer.write(self.as_bytes())?;
-        writer.write(&[0])?;
+        writer.write_all(self.as_bytes())?;
+        writer.write_all(&[0])?;
 
         Ok(())
     }
+    #[inline(always)]
+    fn serialize_write_size(&self) -> Result<u32> {
+        Ok(2 + self.as_bytes().len() as u32 + 1)
+    }
 }
 

rnex-core/src/rmc/structures/variant.rs

@@ -16,7 +16,7 @@ pub enum Variant{
 }
 
 impl RmcSerialize for Variant{
-    fn serialize(&self, writer: &mut dyn Write) -> crate::rmc::structures::Result<()> {
+    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
         match self{
             Variant::None => {
                 writer.write_all(&[0])?;
@@ -50,7 +50,7 @@ impl RmcSerialize for Variant{
         Ok(())
     }
 
-    fn deserialize(reader: &mut dyn Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
         match u8::deserialize(reader)?{
             0 => Ok(Variant::None),
             1 => Ok(Variant::SInt64(i64::deserialize(reader)?)),