implement NetworkId UserType

3 files changed, 71 insertions, 11 deletions

diff --git a/src/primitive/mod.rs b/src/primitive/mod.rs
index dbc82d0..79ff6c4 100644
--- a/src/primitive/mod.rs
+++ b/src/primitive/mod.rs
@@ -4,6 +4,7 @@ mod datetime;
 mod identityid;
 mod message;
 mod msgid;
+mod networkid;
 mod peerptr;
 mod signedint;
 mod string;
@@ -19,6 +20,7 @@ pub use datetime::*;
 pub use identityid::*;
 pub use message::*;
 pub use msgid::*;
+pub use networkid::*;
 pub use peerptr::*;
 #[allow(unused_imports)]
 pub use signedint::*;
diff --git a/src/primitive/networkid.rs b/src/primitive/networkid.rs
new file mode 100644
index 0000000..1cfff61
--- /dev/null
+++ b/src/primitive/networkid.rs
@@ -0,0 +1,63 @@
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct NetworkId(pub i32);
+
+use crate::{error::ProtocolError, serialize::*};
+
+use crate::serialize::UserType;
+
+impl Serialize for NetworkId {
+    fn serialize(&self) -> Result<Vec<u8>, ProtocolError> {
+        let mut res = Vec::new();
+
+        res.append(&mut Self::NAME.serialize_utf8()?);
+        res.extend(self.0.serialize()?);
+
+        Ok(res)
+    }
+}
+
+impl Deserialize for NetworkId {
+    fn parse(b: &[u8]) -> Result<(usize, Self), ProtocolError> {
+        let (size, value) = i32::parse(b)?;
+        return Ok((size, NetworkId(value)));
+    }
+}
+
+impl From<i32> for NetworkId {
+    fn from(value: i32) -> Self {
+        NetworkId(value)
+    }
+}
+
+impl std::ops::Deref for NetworkId {
+    type Target = i32;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl UserType for NetworkId {
+    const NAME: &str = "NetworkId";
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    pub fn networkid_parse_test() {
+        let test_bytes: &[u8] = &[0, 0, 0, 1];
+        let (len, res) = NetworkId::parse(test_bytes).unwrap();
+        assert_eq!(len, test_bytes.len());
+        assert_eq!(res, NetworkId(1));
+    }
+
+    #[test]
+    pub fn networkid_serialize_test() {
+        let res = NetworkId(1).serialize().unwrap();
+        let expected_bytes: &[u8] = &[0, 0, 0, 9, 78, 101, 116, 119, 111, 114, 107, 73, 100, 0, 0, 0, 1];
+        assert_eq!(res, expected_bytes);
+    }
+}
diff --git a/src/primitive/variant.rs b/src/primitive/variant.rs
index e8eea86..d39e0bf 100644
--- a/src/primitive/variant.rs
+++ b/src/primitive/variant.rs
@@ -1,10 +1,10 @@
 use std::{collections::HashMap, vec::Vec};
 
 use itertools::Itertools;
-use log::{error, trace};
+use log::{debug, error, trace};
 
 use crate::error::ProtocolError;
-use crate::primitive::{self, PeerPtr};
+use crate::primitive::{self, NetworkId, PeerPtr};
 use crate::primitive::{IdentityId, StringList};
 use crate::serialize::*;
 
@@ -31,6 +31,7 @@ pub enum Variant {
     IdentityId(IdentityId),
     Message(Message),
     MsgId(MsgId),
+    NetworkId(NetworkId),
     Time(Time),
     Date(Date),
     DateTime(DateTime),
@@ -194,6 +195,7 @@ impl Serialize for Variant {
             Variant::IdentityId(v) => v.serialize_variant(),
             Variant::Message(v) => v.serialize_variant(),
             Variant::MsgId(v) => v.serialize_variant(),
+            Variant::NetworkId(v) => v.serialize_variant(),
             Variant::PeerPtr(v) => v.serialize_variant(),
             Variant::DateTime(v) => v.serialize_variant(),
             Variant::Time(v) => v.serialize_variant(),
@@ -241,23 +243,16 @@ impl Deserialize for Variant {
 
                 trace!(target: "primitive::Variant", "Parsing UserType: {:?}", user_type);
 
-                // TODO implement all these types
                 // 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" => {
-                        trace!(target: "primitive::Variant", "UserType is VariantMap");
                         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)));
                     }
-                    // As i32
-                    "NetworkId" => {
-                        trace!(target: "primitive::Variant", "UserType is i32");
-
-                        let (vlen, value) = i32::parse(&b[(len + user_type_len)..])?;
-                        return Ok((len + user_type_len + vlen, Variant::i32(value)));
-                    }
+                    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),
                     BufferInfo::NAME => BufferInfo::parse_variant(b, len + user_type_len),