lots of changes

rnex-core/src/rmc/protocols/auth.rs

@@ -1,4 +1,4 @@
-use crate::rmc::structures::connection_data::ConnectionData;
+use crate::rmc::structures::connection_data::{ConnectionData, ConnectionDataOld};
 use macros::{method_id, rmc_proto};
 use rnex_core::rmc::response::ErrorCode;
 use rnex_core::rmc::structures::any::Any;
@@ -14,7 +14,7 @@ pub trait Auth {
     async fn login(
         &self,
         name: String,
-    ) -> Result<(QResult, u32, Vec<u8>, ConnectionData, String), ErrorCode>;
+    ) -> Result<(QResult, u32, Vec<u8>, ConnectionDataOld, String), ErrorCode>;
 
     /// representation of the `LoginEx` method(for details see the
     /// [kinnay wiki entry](https://github.com/kinnay/NintendoClients/wiki/Authentication-Protocol))

rnex-core/src/rmc/protocols/friends.rs

@@ -0,0 +1,146 @@
+use macros::{RmcSerialize, method_id, rmc_proto};
+
+use rnex_core::{kerberos::KerberosDateTime, rmc::response::ErrorCode};
+
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct MiiV2 {
+    pub name: String,
+    pub unk: u8,
+    pub unk2: u8,
+    pub mii_data: Vec<u8>,
+    pub date_time: KerberosDateTime,
+}
+
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct PrincipalBasicInfo {
+    pub pid: u32,
+    pub nnid: String,
+    pub mii: MiiV2,
+    pub unk: u8,
+}
+
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct NNAInfo {
+    pub principal_basic_info: PrincipalBasicInfo,
+    pub unk: u8,
+    pub unk2: u8,
+}
+
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct GameKey {
+    pub tid: u64,
+    pub version: u16,
+}
+
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct NintendoPresenceV2 {
+    pub changed_flags: u32,
+    pub is_online: bool,
+    pub game_key: GameKey,
+    pub unk: u8,
+    pub message: String,
+    pub unk2: u32,
+    pub unk3: u8,
+    pub game_server_id: u32,
+    pub unk4: u32,
+    pub pid: u32,
+    pub gid: u32,
+    pub app_data: Vec<u8>,
+    pub unk5: u8,
+    pub unk6: u8,
+    pub unk7: u8,
+}
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct PrincipalPreference {
+    pub show_online: bool,
+    pub show_playing_title: bool,
+    pub block_friend_request: bool,
+}
+
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct Comment {
+    pub unk: u8,
+    pub message: String,
+    pub last_changed: KerberosDateTime,
+}
+
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct FriendInfo {
+    pub nna_info: NNAInfo,
+    pub presence: NintendoPresenceV2,
+    pub comment: Comment,
+    pub became_friends: KerberosDateTime,
+    pub last_online: KerberosDateTime,
+    pub unk: u64,
+}
+
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct FriendRequestMessage {
+    pub friend_request_id: u64,
+    pub is_recieved: u8,
+    pub unk: u8,
+    pub message: String,
+    pub unk2: u8,
+    pub unk3: String,
+    pub game_key: GameKey,
+    pub unk4: KerberosDateTime,
+    pub expires_on: KerberosDateTime,
+}
+
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct FriendRequest {
+    pub basic_info: PrincipalBasicInfo,
+    pub request_message: FriendRequestMessage,
+    pub sent_on: KerberosDateTime,
+}
+
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct BlacklistedPrincipal {
+    pub basic_info: PrincipalBasicInfo,
+    pub game_key: GameKey,
+    pub since: KerberosDateTime,
+}
+#[derive(RmcSerialize)]
+#[rmc_struct(0)]
+pub struct PersistentNotification {
+    pub unk1: u64,
+    pub unk2: u32,
+    pub unk3: u32,
+    pub unk4: u32,
+    pub unk5: String,
+}
+
+#[rmc_proto(102)]
+pub trait Friends {
+    #[method_id(1)]
+    async fn update_and_get_all_information(
+        &self,
+        info: NNAInfo,
+        presence: NintendoPresenceV2,
+        date_time: KerberosDateTime,
+    ) -> Result<
+        (
+            PrincipalPreference,
+            Comment,
+            Vec<FriendInfo>,
+            Vec<FriendRequest>,
+            Vec<FriendRequest>,
+            Vec<BlacklistedPrincipal>,
+            bool,
+            Vec<PersistentNotification>,
+            bool,
+        ),
+        ErrorCode,
+    >;
+}

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

@@ -1,6 +1,7 @@
 #![allow(async_fn_in_trait)]
 
 pub mod auth;
+pub mod friends;
 pub mod matchmake;
 pub mod matchmake_ext;
 pub mod matchmake_extension;
@@ -294,8 +295,8 @@ async fn handle_incoming<T: RmcCallable + Send + Sync + 'static>(
             } = message;
 
             info!(
-                "RMC REQUEST: Proto: {}; Method: {};",
-                protocol_id, method_id
+                "RMC REQUEST: Proto: {}; Method: {}; cid: {}",
+                protocol_id, method_id, call_id
             );
 
             remote

rnex-core/src/rmc/protocols/secure.rs

@@ -3,10 +3,21 @@ use rnex_core::prudp::station_url::StationUrl;
 use rnex_core::rmc::response::ErrorCode;
 use rnex_core::rmc::structures::qresult::QResult;
 
+use crate::rmc::structures::any::Any;
+
 #[rmc_proto(11)]
 pub trait Secure {
     #[method_id(1)]
-    async fn register(&self, station_urls: Vec<StationUrl>) -> Result<(QResult, u32, StationUrl), ErrorCode>;
+    async fn register(
+        &self,
+        station_urls: Vec<StationUrl>,
+    ) -> Result<(QResult, u32, StationUrl), ErrorCode>;
+    #[method_id(4)]
+    async fn register_ex(
+        &self,
+        station_urls: Vec<StationUrl>,
+        data: Any,
+    ) -> Result<(QResult, u32, StationUrl), ErrorCode>;
     #[method_id(7)]
     async fn replace_url(&self, target: StationUrl, dest: StationUrl) -> Result<(), ErrorCode>;
 }

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

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

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,
+}

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

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