optimize

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())
+    }
 }