lots of changes

2026-02-01 20:59:23 +01:00 · 2026-02-01 20:59:23 +01:00 · 3b6de6968d
commit 3b6de6968d
parent 8af4ca525a
24 changed files with 879 additions and 258 deletions
--- a/rnex-core/src/rmc/structures/any.rs
+++ b/rnex-core/src/rmc/structures/any.rs
@ -1,14 +1,14 @@
+use rnex_core::rmc::structures::{Result, RmcSerialize};
 use std::io::{Read, Write};
 use v_byte_helpers::{IS_BIG_ENDIAN, ReadExtensions};
-use super::{Result, RmcSerialize};

 #[derive(Debug, Default)]
-pub struct Any{
+pub struct Any {
    pub name: String,
-    pub data: Vec<u8>
+    pub data: Vec<u8>,
 }

-impl RmcSerialize for Any{
+impl RmcSerialize for Any {
    fn serialize(&self, writer: &mut impl Write) -> Result<()> {
        self.name.serialize(writer)?;

@ -32,11 +32,6 @@ impl RmcSerialize for Any{

        reader.read_exact(&mut data)?;

-        Ok(
-            Any{
-                name,
-                data
-            }
-        )
+        Ok(Any { name, data })
    }
-}
+}
--- a/rnex-core/src/rmc/structures/buffer.rs
+++ b/rnex-core/src/rmc/structures/buffer.rs
@ -1,10 +1,9 @@
-use std::io::{Read, Write};
+use crate::rmc::structures::Result;
 use crate::rmc::structures::RmcSerialize;
+use std::io::{Read, Write};

-
-
-impl<'a> RmcSerialize for &'a [u8]{
-    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
+impl<'a> RmcSerialize for &'a [u8] {
+    fn serialize(&self, writer: &mut impl Write) -> Result<()> {
        let u32_size = self.len() as u32;
        writer.write(bytemuck::bytes_of(&u32_size))?;
        writer.write(self)?;
@ -13,25 +12,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 impl Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(_reader: &mut impl Read) -> 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> {
+    fn serialize_write_size(&self) -> Result<u32> {
        Ok(4 + self.len() as u32)
    }
 }

-impl RmcSerialize for Box<[u8]>{
-    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
+impl RmcSerialize for Box<[u8]> {
+    fn serialize(&self, writer: &mut impl Write) -> Result<()> {
        (&self[..]).serialize(writer)
    }

-    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
+    fn deserialize(reader: &mut impl Read) -> Result<Self> {
        Vec::deserialize(reader).map(|v| v.into_boxed_slice())
    }

-    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
+    fn serialize_write_size(&self) -> Result<u32> {
        (&self[..]).serialize_write_size()
    }
-}
+}
--- a/rnex-core/src/rmc/structures/connection_data.rs
+++ b/rnex-core/src/rmc/structures/connection_data.rs
@ -1,13 +1,19 @@
-
 use macros::RmcSerialize;
 use rnex_core::kerberos::KerberosDateTime;

 #[derive(Debug, RmcSerialize)]
 #[rmc_struct(1)]
-pub struct ConnectionData{
+pub struct ConnectionData {
    pub station_url: String,
    pub special_protocols: Vec<u8>,
    pub special_station_url: String,
-    pub date_time: KerberosDateTime
+    pub date_time: KerberosDateTime,
 }

+#[derive(Debug, RmcSerialize)]
+#[rmc_struct(1)]
+pub struct ConnectionDataOld {
+    pub station_url: String,
+    pub special_protocols: Vec<u8>,
+    pub special_station_url: String,
+}
--- a/rnex-core/src/rmc/structures/primitives.rs
+++ b/rnex-core/src/rmc/structures/primitives.rs
@ -1,9 +1,9 @@
-use std::io::{Read, Write};
-use bytemuck::bytes_of;
-use v_byte_helpers::{IS_BIG_ENDIAN, ReadExtensions};
 use crate::rmc::structures::RmcSerialize;
+use bytemuck::bytes_of;
+use std::io::{Read, Write};
+use v_byte_helpers::{IS_BIG_ENDIAN, ReadExtensions};

-impl RmcSerialize for u8{
+impl RmcSerialize for u8 {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        Ok(writer.write_all(bytes_of(self))?)
@ -19,7 +19,7 @@ impl RmcSerialize for u8{
    }
 }

-impl RmcSerialize for i8{
+impl RmcSerialize for i8 {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        Ok(writer.write_all(bytes_of(self))?)
@ -35,7 +35,7 @@ impl RmcSerialize for i8{
    }
 }

-impl RmcSerialize for u16{
+impl RmcSerialize for u16 {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        Ok(writer.write_all(bytes_of(self))?)
@ -50,7 +50,7 @@ impl RmcSerialize for u16{
    }
 }

-impl RmcSerialize for i16{
+impl RmcSerialize for i16 {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        Ok(writer.write_all(bytes_of(self))?)
@ -65,7 +65,7 @@ impl RmcSerialize for i16{
    }
 }

-impl RmcSerialize for u32{
+impl RmcSerialize for u32 {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        Ok(writer.write_all(bytes_of(self))?)
@ -80,7 +80,7 @@ impl RmcSerialize for u32{
    }
 }

-impl RmcSerialize for i32{
+impl RmcSerialize for i32 {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        Ok(writer.write_all(bytes_of(self))?)
@ -95,7 +95,7 @@ impl RmcSerialize for i32{
    }
 }

-impl RmcSerialize for u64{
+impl RmcSerialize for u64 {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        Ok(writer.write_all(bytes_of(self))?)
@ -110,7 +110,7 @@ impl RmcSerialize for u64{
    }
 }

-impl RmcSerialize for i64{
+impl RmcSerialize for i64 {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        Ok(writer.write_all(bytes_of(self))?)
@ -125,7 +125,7 @@ impl RmcSerialize for i64{
    }
 }

-impl RmcSerialize for f64{
+impl RmcSerialize for f64 {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        Ok(writer.write_all(bytes_of(self))?)
@ -141,10 +141,10 @@ impl RmcSerialize for f64{
    }
 }

-impl RmcSerialize for bool{
+impl RmcSerialize for bool {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
-        match self{
+        match self {
            true => writer.write_all(&[1])?,
            false => writer.write_all(&[0])?,
        }
@ -161,8 +161,7 @@ impl RmcSerialize for bool{
    }
 }

-
-impl<T: RmcSerialize, U: RmcSerialize> RmcSerialize for (T, U){
+impl<T: RmcSerialize, U: RmcSerialize> RmcSerialize for (T, U) {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        self.0.serialize(writer)?;
@ -178,14 +177,11 @@ impl<T: RmcSerialize, U: RmcSerialize> RmcSerialize for (T, U){
    }
    #[inline(always)]
    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
-        Ok(
-            self.0.serialize_write_size()? +
-            self.1.serialize_write_size()?
-        )
+        Ok(self.0.serialize_write_size()? + self.1.serialize_write_size()?)
    }
 }

-impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize> RmcSerialize for (T, U, V){
+impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize> RmcSerialize for (T, U, V) {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        self.0.serialize(writer)?;
@ -203,15 +199,15 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize> RmcSerialize for (T, U,
    }
    #[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()?
-        )
+        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){
+impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize> RmcSerialize
+    for (T, U, V, W)
+{
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        self.0.serialize(writer)?;
@ -231,16 +227,16 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize> RmcSeri
    }
    #[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()?
-        )
+        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){
+impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcSerialize>
+    RmcSerialize for (T, U, V, W, X)
+{
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        self.0.serialize(writer)?;
@ -264,17 +260,23 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcS
    }
    #[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()?
-        )
+        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){
+impl<
+    T: RmcSerialize,
+    U: RmcSerialize,
+    V: RmcSerialize,
+    W: RmcSerialize,
+    X: RmcSerialize,
+    Y: RmcSerialize,
+> RmcSerialize for (T, U, V, W, X, Y)
+{
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        self.0.serialize(writer)?;
@ -300,18 +302,25 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcS
    }
    #[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()?
-        )
+        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){
+impl<
+    T: RmcSerialize,
+    U: RmcSerialize,
+    V: RmcSerialize,
+    W: RmcSerialize,
+    X: RmcSerialize,
+    Y: RmcSerialize,
+    Z: RmcSerialize,
+> RmcSerialize for (T, U, V, W, X, Y, Z)
+{
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        self.0.serialize(writer)?;
@ -338,19 +347,123 @@ impl<T: RmcSerialize, U: RmcSerialize, V: RmcSerialize, W: RmcSerialize, X: RmcS
    }
    #[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()?
-        )
+        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>{
+impl<
+    T: RmcSerialize,
+    U: RmcSerialize,
+    V: RmcSerialize,
+    W: RmcSerialize,
+    X: RmcSerialize,
+    Y: RmcSerialize,
+    Z: RmcSerialize,
+    A: RmcSerialize,
+> RmcSerialize for (T, U, V, W, X, Y, Z, A)
+{
+    #[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)?;
+        self.4.serialize(writer)?;
+        self.5.serialize(writer)?;
+        self.6.serialize(writer)?;
+        self.7.serialize(writer)?;
+
+        Ok(())
+    }
+    #[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)?;
+        let fourth = W::deserialize(reader)?;
+        let fifth = X::deserialize(reader)?;
+        let sixth = Y::deserialize(reader)?;
+        let seventh = Z::deserialize(reader)?;
+        let eighth = A::deserialize(reader)?;
+
+        Ok((first, second, third, fourth, fifth, sixth, seventh, eighth))
+    }
+    #[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()?
+            + self.7.serialize_write_size()?)
+    }
+}
+
+impl<
+    T: RmcSerialize,
+    U: RmcSerialize,
+    V: RmcSerialize,
+    W: RmcSerialize,
+    X: RmcSerialize,
+    Y: RmcSerialize,
+    Z: RmcSerialize,
+    A: RmcSerialize,
+    B: RmcSerialize,
+> RmcSerialize for (T, U, V, W, X, Y, Z, A, B)
+{
+    #[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)?;
+        self.4.serialize(writer)?;
+        self.5.serialize(writer)?;
+        self.6.serialize(writer)?;
+        self.7.serialize(writer)?;
+        self.8.serialize(writer)?;
+
+        Ok(())
+    }
+    #[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)?;
+        let fourth = W::deserialize(reader)?;
+        let fifth = X::deserialize(reader)?;
+        let sixth = Y::deserialize(reader)?;
+        let seventh = Z::deserialize(reader)?;
+        let eighth = A::deserialize(reader)?;
+        let nineth = B::deserialize(reader)?;
+
+        Ok((
+            first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
+        ))
+    }
+    #[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()?
+            + self.7.serialize_write_size()?
+            + self.8.serialize_write_size()?)
+    }
+}
+
+impl<T: RmcSerialize> RmcSerialize for Box<T> {
    #[inline(always)]
    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
        self.as_ref().serialize(writer)
@ -363,4 +476,4 @@ impl<T: RmcSerialize> RmcSerialize for Box<T>{
    fn serialize_write_size(&self) -> crate::rmc::structures::Result<u32> {
        T::serialize_write_size(self.as_ref())
    }
-}
+}
--- a/rnex-core/src/rmc/structures/variant.rs
+++ b/rnex-core/src/rmc/structures/variant.rs
@ -1,10 +1,10 @@
+use rnex_core::kerberos::KerberosDateTime;
+use rnex_core::rmc::structures;
+use rnex_core::rmc::structures::{Result, RmcSerialize};
 use std::io::{Read, Write};
-use crate::kerberos::KerberosDateTime;
-use crate::rmc::structures;
-use crate::rmc::structures::RmcSerialize;

 #[derive(Debug, Clone, Default)]
-pub enum Variant{
+pub enum Variant {
    #[default]
    None,
    SInt64(i64),
@ -15,9 +15,9 @@ pub enum Variant{
    UInt64(u64),
 }

-impl RmcSerialize for Variant{
-    fn serialize(&self, writer: &mut impl Write) -> crate::rmc::structures::Result<()> {
-        match self{
+impl RmcSerialize for Variant {
+    fn serialize(&self, writer: &mut impl Write) -> Result<()> {
+        match self {
            Variant::None => {
                writer.write_all(&[0])?;
            }
@ -50,8 +50,8 @@ impl RmcSerialize for Variant{
        Ok(())
    }

-    fn deserialize(reader: &mut impl Read) -> crate::rmc::structures::Result<Self> {
-        match u8::deserialize(reader)?{
+    fn deserialize(reader: &mut impl Read) -> Result<Self> {
+        match u8::deserialize(reader)? {
            0 => Ok(Variant::None),
            1 => Ok(Variant::SInt64(i64::deserialize(reader)?)),
            2 => Ok(Variant::Double(f64::deserialize(reader)?)),
@ -59,7 +59,7 @@ impl RmcSerialize for Variant{
            4 => Ok(Variant::String(String::deserialize(reader)?)),
            5 => Ok(Variant::DateTime(KerberosDateTime::deserialize(reader)?)),
            6 => Ok(Variant::UInt64(u64::deserialize(reader)?)),
-            v => Err(structures::Error::UnexpectedValue(v as u64))
+            v => Err(structures::Error::UnexpectedValue(v as u64)),
        }
    }
-}
+}