Expand MatchmakeSessionSearchCriteria and Add Deserializing Logs

rnex-protocols/mm-protos/src/matchmake.rs

@@ -9,6 +9,7 @@ use rnex_rmc::{
     util::{PID, station_url::StationUrl},
     variant::Variant,
 };
+use tracing::info;
 
 #[derive(RmcSerialize, Debug, Clone, Default, PartialEq)]
 #[rmc_struct(0)]
@@ -77,24 +78,406 @@ cfg_if! {
     }
 }
 
-#[derive(RmcSerialize, Debug, Clone)]
-#[rmc_struct(3)]
 pub struct MatchmakeSessionSearchCriteria {
-    pub attribs: Vec<StringSet<u32>>,
+        pub attribs: Vec<StringSet<u32>>,
-    pub game_mode: String,
+        pub game_mode: String,
-    pub minimum_participants: String,
+        pub minimum_participants: String,
-    pub maximum_participants: String,
+        pub maximum_participants: String,
-    pub matchmake_system_type: String,
+        pub matchmake_system_type: String,
-    pub vacant_only: bool,
+        pub vacant_only: bool,
-    pub exclude_locked: bool,
+        pub exclude_locked: bool,
-    pub exclude_non_host_pid: bool,
+        pub exclude_non_host_pid: bool,
-    pub selection_method: u32,
+        pub selection_method: u32,
-    pub vacant_participants: u16,
+        pub vacant_participants: u16,
-    pub matchmake_param: MatchmakeParam,
+        pub matchmake_param: MatchmakeParam,
-    pub exclude_user_password_set: bool,
+        pub exclude_user_password_set: bool,
-    pub exclude_system_password_set: bool,
+        pub exclude_system_password_set: bool,
-    pub refer_gid: u32,
+        pub refer_gid: u32,
-}
+    }
+    #[automatically_derived]
+    impl ::rnex_rmc::serialization::RmcSerialize for MatchmakeSessionSearchCriteria {
+        #[inline(always)]
+        fn serialize(
+            &self,
+            writer: &mut (impl ::std::io::Write + ?::std::marker::Sized),
+        ) -> ::rnex_rmc::serialization::Result<()> {
+            ::rnex_rmc::rmc_struct::write_struct(
+                writer,
+                Self::version().unwrap(),
+                ::rnex_rmc::helpers::len_of_write(|writer| {
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.attribs,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.game_mode,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.minimum_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.maximum_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.matchmake_system_type,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.vacant_only,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_locked,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_non_host_pid,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.selection_method,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.vacant_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.matchmake_param,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_user_password_set,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_system_password_set,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.refer_gid,
+                        writer,
+                    )?;
+                    Ok(())
+                }),
+                |writer| {
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.attribs,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.game_mode,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.minimum_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.maximum_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.matchmake_system_type,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.vacant_only,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_locked,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_non_host_pid,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.selection_method,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.vacant_participants,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.matchmake_param,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_user_password_set,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.exclude_system_password_set,
+                        writer,
+                    )?;
+                    ::rnex_rmc::serialization::RmcSerialize::serialize(
+                        &self.refer_gid,
+                        writer,
+                    )?;
+                    Ok(())
+                },
+            )?;
+            Ok(())
+        }
+        #[inline(always)]
+        fn deserialize(
+            reader: &mut (impl ::std::io::Read + ?::std::marker::Sized),
+        ) -> ::rnex_rmc::serialization::Result<Self> {
+            ::rnex_rmc::rmc_struct::read_struct(
+                reader,
+                Self::version().unwrap(),
+                move |mut reader| {
+                    info!("Deserializing attribs in MatchmakeSessionSearchCriteria");
+                    let attribs: Vec<StringSet<u32>> = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("attribs: {:?}", attribs);
+                    info!("Deserializing game_mode in MatchmakeSessionSearchCriteria");
+                    let game_mode: String = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("game_mode: {}", game_mode);
+                    info!("Deserializing minimum_participants in MatchmakeSessionSearchCriteria");
+                    let minimum_participants: String = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("minimum_participants: {}", minimum_participants);
+                    info!("Deserializing maximum_participants in MatchmakeSessionSearchCriteria");
+                    let maximum_participants: String = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("maximum_participants: {}", maximum_participants);
+                    info!("Deserializing matchmake_system_type in MatchmakeSessionSearchCriteria");
+                    let matchmake_system_type: String = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("matchmake_system_type: {}", matchmake_system_type);
+                    info!("Deserializing vacant_only in MatchmakeSessionSearchCriteria");
+                    let vacant_only: bool = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("vacant_only: {}", vacant_only);
+                    info!("Deserializing exclude_locked in MatchmakeSessionSearchCriteria");
+                    let exclude_locked: bool = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("exclude_locked: {}", exclude_locked);
+                    info!("Deserializing exclude_non_host_pid in MatchmakeSessionSearchCriteria");
+                    let exclude_non_host_pid: bool = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("exclude_non_host_pid: {}", exclude_non_host_pid);
+                    info!("Deserializing selection_method in MatchmakeSessionSearchCriteria");
+                    let selection_method: u32 = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("selection_method: {}", selection_method);
+                    info!("Deserializing vacant_participants in MatchmakeSessionSearchCriteria");
+                    let vacant_participants: u16 = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("vacant_participants: {}", vacant_participants);
+                    info!("Deserializing matchmake_param in MatchmakeSessionSearchCriteria");
+                    let matchmake_param: MatchmakeParam = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("matchmake_param: {:?}", matchmake_param);
+                    info!("Deserializing exclude_user_password_set in MatchmakeSessionSearchCriteria");
+                    let exclude_user_password_set: bool = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("exclude_user_password_set: {}", exclude_user_password_set);
+                    info!("Deserializing exclude_system_password_set in MatchmakeSessionSearchCriteria");
+                    let exclude_system_password_set: bool = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("exclude_system_password_set: {}", exclude_system_password_set);
+                    info!("Deserializing refer_gid in MatchmakeSessionSearchCriteria");
+                    let refer_gid: u32 = ::rnex_rmc::serialization::RmcSerialize::deserialize(
+                        reader,
+                    )?;
+                    info!("refer_gid: {}", refer_gid);
+                    info!("MatchmakeSessionSearchCriteria deserialized, returning data");
+                    Ok(Self {
+                        attribs,
+                        game_mode,
+                        minimum_participants,
+                        maximum_participants,
+                        matchmake_system_type,
+                        vacant_only,
+                        exclude_locked,
+                        exclude_non_host_pid,
+                        selection_method,
+                        vacant_participants,
+                        matchmake_param,
+                        exclude_user_password_set,
+                        exclude_system_password_set,
+                        refer_gid,
+                    })
+                },
+            )
+        }
+        fn serialize_write_size(&self) -> ::rnex_rmc::serialization::Result<u32> {
+            let mut sum = 0;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.attribs,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.game_mode,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.minimum_participants,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.maximum_participants,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.matchmake_system_type,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.vacant_only,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.exclude_locked,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.exclude_non_host_pid,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.selection_method,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.vacant_participants,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.matchmake_param,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.exclude_user_password_set,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.exclude_system_password_set,
+                )?;
+            let sum = sum
+                + ::rnex_rmc::serialization::RmcSerialize::serialize_write_size(
+                    &self.refer_gid,
+                )?;
+            let sum = sum
+                + (if ::rnex_rmc::config::FEATURE_HAS_STRUCT_HEADER { 5 } else { 0 });
+            Ok(sum)
+        }
+        fn version() -> Option<u8> {
+            Some({ 3 })
+        }
+    }
+    impl ::rnex_rmc::serialization::RmcStruct for MatchmakeSessionSearchCriteria {
+        fn get_struct_info() -> &'static ::rnex_rmc::serialization::RmcStructInfo {
+            static STRUCT_DATA: ::rnex_rmc::serialization::RmcStructInfo = ::rnex_rmc::serialization::RmcStructInfo {
+                inheritors: ::std::sync::RwLock::new(::std::vec::Vec::new()),
+                name: "MatchmakeSessionSearchCriteria",
+            };
+            &STRUCT_DATA
+        }
+    }
+    #[automatically_derived]
+    impl ::core::fmt::Debug for MatchmakeSessionSearchCriteria {
+        #[inline]
+        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+            let names: &'static _ = &[
+                "attribs",
+                "game_mode",
+                "minimum_participants",
+                "maximum_participants",
+                "matchmake_system_type",
+                "vacant_only",
+                "exclude_locked",
+                "exclude_non_host_pid",
+                "selection_method",
+                "vacant_participants",
+                "matchmake_param",
+                "exclude_user_password_set",
+                "exclude_system_password_set",
+                "refer_gid",
+            ];
+            let values: &[&dyn ::core::fmt::Debug] = &[
+                &self.attribs,
+                &self.game_mode,
+                &self.minimum_participants,
+                &self.maximum_participants,
+                &self.matchmake_system_type,
+                &self.vacant_only,
+                &self.exclude_locked,
+                &self.exclude_non_host_pid,
+                &self.selection_method,
+                &self.vacant_participants,
+                &self.matchmake_param,
+                &self.exclude_user_password_set,
+                &self.exclude_system_password_set,
+                &&self.refer_gid,
+            ];
+            ::core::fmt::Formatter::debug_struct_fields_finish(
+                f,
+                "MatchmakeSessionSearchCriteria",
+                names,
+                values,
+            )
+        }
+    }
+    #[automatically_derived]
+    impl ::core::clone::Clone for MatchmakeSessionSearchCriteria {
+        #[inline]
+        fn clone(&self) -> MatchmakeSessionSearchCriteria {
+            MatchmakeSessionSearchCriteria {
+                attribs: ::core::clone::Clone::clone(&self.attribs),
+                game_mode: ::core::clone::Clone::clone(&self.game_mode),
+                minimum_participants: ::core::clone::Clone::clone(
+                    &self.minimum_participants,
+                ),
+                maximum_participants: ::core::clone::Clone::clone(
+                    &self.maximum_participants,
+                ),
+                matchmake_system_type: ::core::clone::Clone::clone(
+                    &self.matchmake_system_type,
+                ),
+                vacant_only: ::core::clone::Clone::clone(&self.vacant_only),
+                exclude_locked: ::core::clone::Clone::clone(&self.exclude_locked),
+                exclude_non_host_pid: ::core::clone::Clone::clone(
+                    &self.exclude_non_host_pid,
+                ),
+                selection_method: ::core::clone::Clone::clone(&self.selection_method),
+                vacant_participants: ::core::clone::Clone::clone(
+                    &self.vacant_participants,
+                ),
+                matchmake_param: ::core::clone::Clone::clone(&self.matchmake_param),
+                exclude_user_password_set: ::core::clone::Clone::clone(
+                    &self.exclude_user_password_set,
+                ),
+                exclude_system_password_set: ::core::clone::Clone::clone(
+                    &self.exclude_system_password_set,
+                ),
+                refer_gid: ::core::clone::Clone::clone(&self.refer_gid),
+            }
+        }
+    }
 
 #[derive(RmcSerialize, Debug, Clone)]
 #[rmc_struct(0)]