add UserType implementation for required signalproxy objects

6 files changed, 131 insertions, 13 deletions

diff --git a/src/message/signalproxy/objects/identity.rs b/src/message/signalproxy/objects/identity.rs
index 0a2aaf8..6aa9830 100644
--- a/src/message/signalproxy/objects/identity.rs
+++ b/src/message/signalproxy/objects/identity.rs
@@ -13,6 +13,10 @@ use crate::message::Syncable;
 #[allow(unused_imports)]
 use crate::message::signalproxy::translation::NetworkMap;
 use crate::primitive::IdentityId;
+use crate::primitive::VariantMap;
+use crate::serialize::Deserialize;
+use crate::serialize::Serialize;
+use crate::serialize::UserType;
 
 #[derive(Default, Debug, Clone, PartialEq, NetworkMap, NetworkList, Setters)]
 pub struct Identity {
@@ -61,6 +65,26 @@ pub struct Identity {
     pub quit_reason: String,
 }
 
+impl UserType for Identity {
+    const NAME: &str = "Identity";
+}
+
+impl Serialize for Identity {
+    fn serialize(&self) -> Result<Vec<u8>, crate::ProtocolError> {
+        self.to_network_map().serialize()
+    }
+}
+
+impl Deserialize for Identity {
+    fn parse(b: &[u8]) -> Result<(usize, Self), crate::ProtocolError>
+    where
+        Self: std::marker::Sized,
+    {
+        let (vlen, mut value) = VariantMap::parse(b)?;
+        return Ok((vlen, Self::from_network_map(&mut value)));
+    }
+}
+
 impl Identity {
     pub fn copy_from(&mut self, other: Identity) {
         #[cfg(feature = "server")]
diff --git a/src/message/signalproxy/objects/ircchannel.rs b/src/message/signalproxy/objects/ircchannel.rs
index 857af51..9ca3474 100644
--- a/src/message/signalproxy/objects/ircchannel.rs
+++ b/src/message/signalproxy/objects/ircchannel.rs
@@ -5,8 +5,9 @@ use libquassel_derive::sync;
 use libquassel_derive::{NetworkList, NetworkMap, Setters};
 use log::{error, warn};
 
-use crate::message::{Class, Syncable};
-use crate::primitive::StringList;
+use crate::message::{signalproxy::translation::NetworkMap, Class, Syncable};
+use crate::primitive::{StringList, VariantMap};
+use crate::serialize::{Deserialize, Serialize, UserType};
 
 use super::{ChanModes, ChannelModeType};
 
@@ -30,6 +31,26 @@ pub struct IrcChannel {
     pub encrypted: bool,
 }
 
+impl UserType for IrcChannel {
+    const NAME: &str = "IrcChannel";
+}
+
+impl Serialize for IrcChannel {
+    fn serialize(&self) -> Result<Vec<u8>, crate::ProtocolError> {
+        self.to_network_map().serialize()
+    }
+}
+
+impl Deserialize for IrcChannel {
+    fn parse(b: &[u8]) -> Result<(usize, Self), crate::ProtocolError>
+    where
+        Self: std::marker::Sized,
+    {
+        let (vlen, mut value) = VariantMap::parse(b)?;
+        return Ok((vlen, Self::from_network_map(&mut value)));
+    }
+}
+
 // TODO keep user modes sorted
 impl IrcChannel {
     pub fn add_channel_mode(&mut self, mode_type: ChannelModeType, mode: char, value: String) {
diff --git a/src/message/signalproxy/objects/ircuser.rs b/src/message/signalproxy/objects/ircuser.rs
index c522c13..1969793 100644
--- a/src/message/signalproxy/objects/ircuser.rs
+++ b/src/message/signalproxy/objects/ircuser.rs
@@ -1,6 +1,7 @@
 use crate::{
-    message::{Class, Syncable},
-    primitive::{DateTime, StringList},
+    message::{Class, NetworkMap, Syncable},
+    primitive::{DateTime, StringList, VariantMap},
+    serialize::{Deserialize, Serialize, UserType},
 };
 
 use itertools::Itertools;
@@ -42,6 +43,26 @@ pub struct IrcUser {
     pub user_modes: String,
 }
 
+impl UserType for IrcUser {
+    const NAME: &str = "IrcUser";
+}
+
+impl Serialize for IrcUser {
+    fn serialize(&self) -> Result<Vec<u8>, crate::ProtocolError> {
+        self.to_network_map().serialize()
+    }
+}
+
+impl Deserialize for IrcUser {
+    fn parse(b: &[u8]) -> Result<(usize, Self), crate::ProtocolError>
+    where
+        Self: std::marker::Sized,
+    {
+        let (vlen, mut value) = VariantMap::parse(b)?;
+        return Ok((vlen, Self::from_network_map(&mut value)));
+    }
+}
+
 impl IrcUser {
     pub fn add_user_modes(&mut self, modes: String) {
         for mode in modes.chars() {
diff --git a/src/message/signalproxy/objects/network.rs b/src/message/signalproxy/objects/network.rs
index 9f0150f..693abfe 100644
--- a/src/message/signalproxy/objects/network.rs
+++ b/src/message/signalproxy/objects/network.rs
@@ -11,6 +11,7 @@ use crate::error::ProtocolError;
 use crate::message::signalproxy::translation::NetworkMap;
 use crate::message::{Class, Syncable};
 use crate::primitive::{Variant, VariantList, VariantMap};
+use crate::serialize::{Deserialize, Serialize, UserType};
 
 use super::{ircchannel::IrcChannel, ircuser::IrcUser, networkinfo::NetworkInfo};
 
@@ -616,6 +617,26 @@ pub struct NetworkServer {
     pub proxy_pass: String,
 }
 
+impl UserType for NetworkServer {
+    const NAME: &str = "Network::Server";
+}
+
+impl Serialize for NetworkServer {
+    fn serialize(&self) -> Result<Vec<u8>, crate::ProtocolError> {
+        self.to_network_map().serialize()
+    }
+}
+
+impl Deserialize for NetworkServer {
+    fn parse(b: &[u8]) -> Result<(usize, Self), crate::ProtocolError>
+    where
+        Self: std::marker::Sized,
+    {
+        let (vlen, mut value) = VariantMap::parse(b)?;
+        return Ok((vlen, Self::from_network_map(&mut value)));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/message/signalproxy/objects/networkinfo.rs b/src/message/signalproxy/objects/networkinfo.rs
index 4cdf8d7..f81a3e7 100644
--- a/src/message/signalproxy/objects/networkinfo.rs
+++ b/src/message/signalproxy/objects/networkinfo.rs
@@ -1,6 +1,7 @@
 use crate::{
-    message::{Class, Syncable},
-    primitive::{IdentityId, NetworkId, StringList},
+    message::{signalproxy::translation::NetworkMap, Class, Syncable},
+    primitive::{IdentityId, NetworkId, StringList, VariantMap},
+    serialize::{Deserialize, Serialize, UserType},
 };
 
 use libquassel_derive::{NetworkList, NetworkMap, Setters};
@@ -71,6 +72,26 @@ pub struct NetworkInfo {
     // pub auto_away_active: bool,
 }
 
+impl UserType for NetworkInfo {
+    const NAME: &str = "NetworkInfo";
+}
+
+impl Serialize for NetworkInfo {
+    fn serialize(&self) -> Result<Vec<u8>, crate::ProtocolError> {
+        self.to_network_map().serialize()
+    }
+}
+
+impl Deserialize for NetworkInfo {
+    fn parse(b: &[u8]) -> Result<(usize, Self), crate::ProtocolError>
+    where
+        Self: std::marker::Sized,
+    {
+        let (vlen, mut value) = VariantMap::parse(b)?;
+        return Ok((vlen, Self::from_network_map(&mut value)));
+    }
+}
+
 impl NetworkInfo {
     pub fn set_server_list(&mut self, servers: Vec<NetworkServer>) {
         #[cfg(feature = "server")]
diff --git a/src/primitive/variant.rs b/src/primitive/variant.rs
index 903f77c..8a1c777 100644
--- a/src/primitive/variant.rs
+++ b/src/primitive/variant.rs
@@ -1,9 +1,10 @@
 use std::{collections::HashMap, vec::Vec};
 
 use itertools::Itertools;
-use log::{debug, error, trace};
+use log::{error, trace};
 
 use crate::error::ProtocolError;
+use crate::message::objects::{Identity, IrcChannel, IrcUser, NetworkInfo, NetworkServer};
 use crate::primitive::{self, NetworkId, PeerPtr};
 use crate::primitive::{IdentityId, StringList};
 use crate::serialize::*;
@@ -29,9 +30,14 @@ pub enum Variant {
     BufferId(BufferId),
     BufferInfo(BufferInfo),
     IdentityId(IdentityId),
+    IrcUser(IrcUser),
+    IrcChannel(IrcChannel),
+    Identity(Identity),
     Message(Message),
     MsgId(MsgId),
     NetworkId(NetworkId),
+    NetworkInfo(NetworkInfo),
+    NetworkServer(NetworkServer),
     Time(Time),
     Date(Date),
     DateTime(DateTime),
@@ -200,6 +206,11 @@ impl Serialize for Variant {
             Variant::DateTime(v) => v.serialize_variant(),
             Variant::Time(v) => v.serialize_variant(),
             Variant::Date(v) => v.serialize_variant(),
+            Variant::IrcUser(v) => v.serialize_variant(),
+            Variant::IrcChannel(v) => v.serialize_variant(),
+            Variant::Identity(v) => v.serialize_variant(),
+            Variant::NetworkInfo(v) => v.serialize_variant(),
+            Variant::NetworkServer(v) => v.serialize_variant(),
         }
     }
 }
@@ -246,12 +257,11 @@ impl Deserialize for Variant {
                 // Match Possible User Types to basic structures
                 match user_type.as_str() {
                     BufferId::NAME => BufferId::parse_variant(b, len + user_type_len),
-                    // As VariantMap
-                    "IrcUser" | "IrcChannel" | "Identity" | "NetworkInfo" | "Network::Server" => {
-                        let (vlen, value) = VariantMap::parse(&b[(len + user_type_len)..])?;
-                        debug!(target: "primitive::Variant", "UserType is VariantMap {:?}", value);
-                        return Ok((len + user_type_len + vlen, Variant::VariantMap(value)));
-                    }
+                    IrcUser::NAME => IrcUser::parse_variant(b, len + user_type_len),
+                    IrcChannel::NAME => IrcChannel::parse_variant(b, len + user_type_len),
+                    Identity::NAME => Identity::parse_variant(b, len + user_type_len),
+                    NetworkInfo::NAME => NetworkInfo::parse_variant(b, len + user_type_len),
+                    NetworkServer::NAME => NetworkServer::parse_variant(b, len + user_type_len),
                     NetworkId::NAME => NetworkId::parse_variant(b, len + user_type_len),
                     IdentityId::NAME => IdentityId::parse_variant(b, len + user_type_len),
                     PeerPtr::NAME => PeerPtr::parse_variant(b, len + user_type_len),