[Protocol] Implement generic response with dyn (#56)

* Implement generic response as enum

* First draft of implementing into_common()

* Make common response type generic

* Use macros and generics to reduce repetition

* [Games] Add dynamically dispatched CommonResponse trait

This adds two traits: "CommonResponse", and "CommonPlayer", when the
generic game query function returns a response it returns a pointer to
its original response type that implements "CommonResponse".

Both common traits require that "as_original()" be implemented, this
returns an enum containing a pointer to the original type.

Both traits have a concrete method "as_json()" that returns a struct
containing data fetched from all of its methods as. This struct
implements serde and can hence be serialized as required.

The traits require a few other methods be implemented, those being the
fields that are common across all types. All other methods have a
default None implementation so that each response type only needs to
implement methods for fields that it has.

* [Game] Implement common traits for JCMP2 response

* [Fmt] Run cargo fmt

* Fix doctest failing

* Run cargo fmt

src/games/ffow.rs

@@ -1,4 +1,4 @@
-use crate::protocols::types::{SpecificResponse, TimeoutSettings};
+use crate::protocols::types::{CommonResponse, TimeoutSettings};
 use crate::protocols::valve::{Engine, Environment, Server, ValveProtocol};
 use crate::protocols::GenericResponse;
 use crate::GDResult;
@@ -44,51 +44,17 @@ pub struct Response {
     pub time_left: u16,
 }
 
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct ExtraResponse {
-    /// Protocol used by the server.
-    pub protocol: u8,
-    /// Map name.
-    pub active_mod: String,
-    /// Dedicated, NonDedicated or SourceTV
-    pub server_type: Server,
-    /// The Operating System that the server is on.
-    pub environment_type: Environment,
-    /// Indicates whether the server uses VAC.
-    pub vac_secured: bool,
-    /// Current round index.
-    pub round: u8,
-    /// Maximum amount of rounds.
-    pub rounds_maximum: u8,
-    /// Time left for the current round in seconds.
-    pub time_left: u16,
-}
+impl CommonResponse for Response {
+    fn as_original(&self) -> GenericResponse { GenericResponse::FFOW(self) }
 
-impl From<Response> for GenericResponse {
-    fn from(r: Response) -> Self {
-        Self {
-            name: Some(r.name),
-            description: Some(r.description),
-            game: Some(r.game_mode),
-            game_version: Some(r.version),
-            map: Some(r.map),
-            players_maximum: r.players_maximum.into(),
-            players_online: r.players_online.into(),
-            players_bots: None,
-            has_password: Some(r.has_password),
-            inner: SpecificResponse::FFOW(ExtraResponse {
-                protocol: r.protocol,
-                active_mod: r.active_mod,
-                server_type: r.server_type,
-                environment_type: r.environment_type,
-                vac_secured: r.vac_secured,
-                round: r.round,
-                rounds_maximum: r.rounds_maximum,
-                time_left: r.time_left,
-            }),
-        }
-    }
+    fn name(&self) -> Option<&str> { Some(&self.name) }
+    fn game(&self) -> Option<&str> { Some(&self.game_mode) }
+    fn description(&self) -> Option<&str> { Some(&self.description) }
+    fn game_version(&self) -> Option<&str> { Some(&self.version) }
+    fn map(&self) -> Option<&str> { Some(&self.map) }
+    fn has_password(&self) -> Option<bool> { Some(self.has_password) }
+    fn players_maximum(&self) -> u64 { self.players_maximum.into() }
+    fn players_online(&self) -> u64 { self.players_online.into() }
 }
 
 pub fn query(address: &IpAddr, port: Option<u16>) -> GDResult<Response> {