customize serialization

Author: vikpe

Cargo.toml

@@ -24,6 +24,7 @@ serde = { optional = true, version = "1.0.219", features = ["derive"] }
 
 [dev-dependencies]
 pretty_assertions = "1.4.1"
+serde_json = "1.0.140"
 
 [features]
 ci = []

src/game_server/server.rs

@@ -1,16 +1,19 @@
 use super::team;
-use crate::{GenericClient, GenericServer};
-
-use crate::{ClientSlots, GeoInfo, Player, QtvStream, ServerType, SoftwareType, Spectator, Team};
+use crate::{
+    ClientSlots, GenericClient, GenericServer, GeoInfo, Player, QtvStream, ServerType,
+    SoftwareType, Spectator, Team,
+};
 use quake_serverinfo::Settings;
 use quake_text::unicode;
 
+#[cfg(feature = "serde")]
+use serde::ser::SerializeStruct;
+
 /// Represents a server where clients connect as [`Player`] or [`Spectator`].
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
 pub struct GameServer {
     pub(crate) software_type: SoftwareType,
-    pub(crate) address: String,
     pub(crate) ip: String,
     pub(crate) port: u16,
     pub(crate) settings: Settings,
@@ -31,8 +34,8 @@ impl GameServer {
         self.software_type.clone()
     }
 
-    pub fn address(&self) -> &str {
-        &self.address
+    pub fn address(&self) -> String {
+        format!("{}:{}", self.ip(), self.port())
     }
 
     pub fn ip(&self) -> &str {
@@ -46,16 +49,16 @@ impl GameServer {
         &self.settings
     }
 
-    pub fn teams(&self) -> impl Iterator<Item = &Team> {
-        self.teams.iter()
+    pub fn teams(&self) -> &[Team] {
+        &self.teams
     }
 
-    pub fn players(&self) -> impl Iterator<Item = &Player> {
-        self.players.iter()
+    pub fn players(&self) -> &[Player] {
+        &self.players
     }
 
-    pub fn spectators(&self) -> impl Iterator<Item = &Spectator> {
-        self.spectators.iter()
+    pub fn spectators(&self) -> &[Spectator] {
+        &self.spectators
     }
 
     pub fn qtv_stream(&self) -> Option<&QtvStream> {
@@ -89,7 +92,7 @@ impl GameServer {
 
 impl From<&GenericServer> for GameServer {
     fn from(server: &GenericServer) -> Self {
-        let mut clients: Vec<GenericClient> = server.clients().cloned().collect();
+        let mut clients: Vec<GenericClient> = server.clients().into();
         clients.sort();
 
         let is_teamplay = server.settings().teamplay.is_some_and(|tp| tp > 0);
@@ -108,7 +111,6 @@ impl From<&GenericServer> for GameServer {
 
         Self {
             software_type: server.software_type(),
-            address: server.address().to_string(),
             ip: server.ip().to_string(),
             port: server.port(),
             settings: server.settings().to_owned(),
@@ -121,6 +123,29 @@ impl From<&GenericServer> for GameServer {
     }
 }
 
+#[cfg(feature = "serde")]
+impl serde::Serialize for GameServer {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("GameServer", 12)?;
+        state.serialize_field("server_type", &self.server_type())?;
+        state.serialize_field("software_type", &self.software_type())?;
+        state.serialize_field("address", &self.address())?;
+        state.serialize_field("ip", self.ip())?;
+        state.serialize_field("port", &self.port())?;
+        state.serialize_field("settings", self.settings())?;
+        state.serialize_field("player_slots", &self.player_slots())?;
+        state.serialize_field("spectator_slots", &self.spectator_slots())?;
+        state.serialize_field("teams", self.teams())?;
+        state.serialize_field("players", self.players())?;
+        state.serialize_field("spectators", self.spectators())?;
+        state.serialize_field("geo", self.geo())?;
+        state.end()
+    }
+}
+
 #[cfg(test)]
 #[cfg_attr(coverage_nightly, coverage(off))]
 mod tests {
@@ -134,7 +159,6 @@ mod tests {
         let generic = GenericServer {
             server_type: ServerType::GameServer,
             software_type: SoftwareType::Mvdsv,
-            address: "10.10.10.10".to_string(),
             ip: "10.10.10.10".to_string(),
             port: 28501,
             settings: Settings {
@@ -175,9 +199,9 @@ mod tests {
         assert_eq!(server.port(), generic.port());
         assert_eq!(server.player_slots(), ClientSlots::new(2, 4));
         assert_eq!(server.spectator_slots(), ClientSlots::new(1, 8));
-        assert_eq!(server.teams().count(), 1);
-        assert_eq!(server.players().count(), 2);
-        assert_eq!(server.spectators().count(), 1);
+        assert_eq!(server.teams().len(), 1);
+        assert_eq!(server.players().len(), 2);
+        assert_eq!(server.spectators().len(), 1);
         assert_eq!(server.qtv_stream(), None);
         assert_eq!(server.geo(), generic.geo());
         assert!(!server.is_empty());
@@ -201,6 +225,36 @@ mod tests {
             ..Default::default()
         };
         let server = GameServer::from(&generic);
-        assert_eq!(server.teams().count(), 0);
+        assert_eq!(server.teams().len(), 0);
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_serialization() -> anyhow::Result<()> {
+        let server = GameServer {
+            software_type: SoftwareType::Mvdsv,
+            ip: "10.10.10.10".to_string(),
+            port: 28000,
+            settings: Settings::default(),
+            teams: vec![],
+            players: vec![],
+            spectators: vec![],
+            qtv_stream: None,
+            geo: GeoInfo {
+                country_code: Some("US".to_string()),
+                country_name: Some("United States".to_string()),
+                city: Some("New York".to_string()),
+                region: Some("North America".to_string()),
+                coords: Some(Coords::new(40.7128, -74.0060)),
+            },
+        };
+
+        let server_json = r#"{"server_type":"game_server","software_type":"mvdsv","address":"10.10.10.10:28000","ip":"10.10.10.10","port":28000,"settings":{"admin":null,"broadcast":null,"city":null,"coords":null,"countrycode":null,"deathmatch":null,"epoch":null,"fpd":null,"fraglimit":null,"gamedir":null,"hostname":null,"hostport":null,"ktxmode":null,"ktxver":null,"map":null,"matchtag":null,"maxclients":null,"maxfps":null,"maxspectators":null,"mode":null,"needpass":null,"pm_ktjump":null,"progs":null,"qvm":null,"serverdemo":null,"status":null,"sv_antilag":null,"teamplay":null,"timelimit":null,"version":null,"z_ext":null},"player_slots":{"total":0,"used":0,"free":0},"spectator_slots":{"total":0,"used":0,"free":0},"teams":[],"players":[],"spectators":[],"geo":{"country_code":"US","country_name":"United States","city":"New York","region":"North America","coords":{"lat":40.7128,"lng":-74.006}}}"#;
+
+        // ensure round-trip serialization
+        assert_eq!(serde_json::to_string(&server)?, server_json);
+        assert_eq!(serde_json::from_str::<GameServer>(server_json)?, server);
+
+        Ok(())
     }
 }

src/game_server/spectator.rs

@@ -4,10 +4,10 @@ use crate::GenericClient;
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Spectator {
-    id: u32,
-    name: String,
-    auth_cc: String,
-    is_bot: bool,
+    pub(super) id: u32,
+    pub(super) name: String,
+    pub(super) auth_cc: String,
+    pub(super) is_bot: bool,
 }
 
 impl From<&GenericClient> for Spectator {

src/generic_server/server.rs

@@ -7,7 +7,6 @@ pub use quake_serverinfo::Settings;
 pub struct GenericServer {
     pub(crate) server_type: ServerType,
     pub(crate) software_type: SoftwareType,
-    pub(crate) address: String,
     pub(crate) ip: String,
     pub(crate) port: u16,
     pub(crate) settings: Settings,
@@ -26,8 +25,8 @@ impl GenericServer {
         self.software_type.clone()
     }
 
-    pub fn address(&self) -> &str {
-        &self.address
+    pub fn address(&self) -> String {
+        format!("{}:{}", self.ip(), self.port())
     }
 
     pub fn ip(&self) -> &str {
@@ -42,16 +41,16 @@ impl GenericServer {
         &self.settings
     }
 
-    pub fn clients(&self) -> impl Iterator<Item = &GenericClient> {
-        self.clients.iter()
+    pub fn clients(&self) -> &[GenericClient] {
+        &self.clients
     }
 
     pub fn players(&self) -> impl Iterator<Item = &GenericClient> {
-        self.clients().filter(|client| !client.is_spectator())
+        self.clients().iter().filter(|client| !client.is_spectator())
     }
 
     pub fn spectators(&self) -> impl Iterator<Item = &GenericClient> {
-        self.clients().filter(|client| client.is_spectator())
+        self.clients().iter().filter(|client| client.is_spectator())
     }
 
     pub fn qtv_stream(&self) -> Option<&QtvStream> {

src/net/query.rs

@@ -79,11 +79,10 @@ fn compose_server(
     let server = GenericServer {
         server_type: ServerType::from_version(&version),
         software_type: SoftwareType::from_version(&version),
-        address: format!("{}:{}", ip, hostport.port()),
         ip,
         port: hostport.port(),
         settings: status_res.settings().clone(),
-        clients: status_res.clients().cloned().collect(),
+        clients: status_res.clients().into(),
         qtv_stream,
         geo: GeoInfo::from(status_res.settings()),
     };

src/net/svc_status/mod.rs

@@ -33,8 +33,8 @@ impl StatusResponse {
         &self.settings
     }
 
-    pub fn clients(&self) -> impl Iterator<Item = &GenericClient> {
-        self.clients.iter()
+    pub fn clients(&self) -> &[GenericClient] {
+        &self.clients
     }
 
     pub fn qtv_stream(&self) -> &Option<QtvStream> {

src/proxy_server/client.rs

@@ -4,9 +4,9 @@ use crate::GenericClient;
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ProxyClient {
-    id: u32,
-    time: u32,
-    name: String,
+    pub(super) id: u32,
+    pub(super) time: u32,
+    pub(super) name: String,
 }
 
 impl From<&GenericClient> for ProxyClient {