implement IdentityId

6 files changed, 79 insertions, 8 deletions

diff --git a/src/message/signalproxy/objects/identity.rs b/src/message/signalproxy/objects/identity.rs
index a34125f..8831b6c 100644
--- a/src/message/signalproxy/objects/identity.rs
+++ b/src/message/signalproxy/objects/identity.rs
@@ -12,11 +12,12 @@ use crate::message::Syncable;
 
 #[allow(unused_imports)]
 use crate::message::signalproxy::translation::NetworkMap;
+use crate::primitive::IdentityId;
 
 #[derive(Default, Debug, Clone, PartialEq, NetworkMap, NetworkList, Setters)]
 pub struct Identity {
     #[quassel(name = "identityId")]
-    pub identity_id: i32,
+    pub identity_id: IdentityId,
     #[quassel(name = "identityName")]
     pub identity_name: String,
     #[quassel(name = "realName")]
diff --git a/src/message/signalproxy/objects/networkinfo.rs b/src/message/signalproxy/objects/networkinfo.rs
index 11a4d0f..b3b2a4d 100644
--- a/src/message/signalproxy/objects/networkinfo.rs
+++ b/src/message/signalproxy/objects/networkinfo.rs
@@ -1,6 +1,6 @@
 use crate::{
     message::{Class, Syncable},
-    primitive::StringList,
+    primitive::{IdentityId, StringList},
 };
 
 use libquassel_derive::{NetworkList, NetworkMap, Setters};
@@ -39,7 +39,7 @@ pub struct NetworkInfo {
     // TODO add these type aliases or usertypes in variants
     // pub network_id: NetworkId,
     #[network(rename = "identityId")]
-    pub identity_id: i32,
+    pub identity_id: IdentityId,
     #[network(rename = "msgRateBurstSize")]
     pub msg_rate_burst_size: u32,
     #[network(rename = "msgRateMessageDelay")]
@@ -120,7 +120,7 @@ mod tests {
             Variant::ByteArray(s!("codecForDecoding")),
             Variant::ByteArray(s!("")),
             Variant::ByteArray(s!("identityId")),
-            Variant::i32(0),
+            Variant::IdentityId(IdentityId(0)),
             Variant::ByteArray(s!("msgRateBurstSize")),
             Variant::u32(5),
             Variant::ByteArray(s!("msgRateMessageDelay")),
@@ -150,7 +150,7 @@ mod tests {
 
     fn get_runtime() -> NetworkInfo {
         NetworkInfo {
-            identity_id: 0,
+            identity_id: IdentityId(0),
             network_name: s!("snoonet"),
             server_list: vec![],
             perform: vec![s!("")],
diff --git a/src/primitive/bufferid.rs b/src/primitive/bufferid.rs
index 844dd37..e987d85 100644
--- a/src/primitive/bufferid.rs
+++ b/src/primitive/bufferid.rs
@@ -1,4 +1,4 @@
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(transparent)]
 pub struct BufferId(pub i32);
 
diff --git a/src/primitive/identityid.rs b/src/primitive/identityid.rs
new file mode 100644
index 0000000..850cfb5
--- /dev/null
+++ b/src/primitive/identityid.rs
@@ -0,0 +1,65 @@
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct IdentityId(pub i32);
+
+use crate::{error::ProtocolError, serialize::*};
+
+use crate::serialize::UserType;
+
+impl Serialize for IdentityId {
+    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 IdentityId {
+    fn parse(b: &[u8]) -> Result<(usize, Self), ProtocolError> {
+        let (size, value) = i32::parse(b)?;
+        return Ok((size, IdentityId(value)));
+    }
+}
+
+impl From<i32> for IdentityId {
+    fn from(value: i32) -> Self {
+        IdentityId(value)
+    }
+}
+
+impl std::ops::Deref for IdentityId {
+    type Target = i32;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl UserType for IdentityId {
+    const NAME: &str = "IdentityId";
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    pub fn identityid_parse_test() {
+        let test_bytes: &[u8] = &[0, 0, 0, 1];
+        let (len, res) = IdentityId::parse(test_bytes).unwrap();
+        assert_eq!(len, test_bytes.len());
+        assert_eq!(res, IdentityId(1));
+    }
+
+    #[test]
+    pub fn identityid_serialize_test() {
+        let res = IdentityId(1).serialize().unwrap();
+        let expected_bytes: &[u8] = &[
+            0, 0, 0, 10, 73, 100, 101, 110, 116, 105, 116, 121, 73, 100, 0, 0, 0, 1,
+        ];
+        assert_eq!(res, expected_bytes);
+    }
+}
diff --git a/src/primitive/mod.rs b/src/primitive/mod.rs
index 7e629b0..dbc82d0 100644
--- a/src/primitive/mod.rs
+++ b/src/primitive/mod.rs
@@ -1,6 +1,7 @@
 mod bufferid;
 mod bufferinfo;
 mod datetime;
+mod identityid;
 mod message;
 mod msgid;
 mod peerptr;
@@ -15,6 +16,7 @@ mod variantmap;
 pub use bufferid::*;
 pub use bufferinfo::*;
 pub use datetime::*;
+pub use identityid::*;
 pub use message::*;
 pub use msgid::*;
 pub use peerptr::*;
diff --git a/src/primitive/variant.rs b/src/primitive/variant.rs
index 41d20d2..e8eea86 100644
--- a/src/primitive/variant.rs
+++ b/src/primitive/variant.rs
@@ -4,8 +4,8 @@ use itertools::Itertools;
 use log::{error, trace};
 
 use crate::error::ProtocolError;
-use crate::primitive::StringList;
 use crate::primitive::{self, PeerPtr};
+use crate::primitive::{IdentityId, StringList};
 use crate::serialize::*;
 
 use crate::primitive::{BufferId, BufferInfo, Date, DateTime, Message, MsgId, Time, VariantList, VariantMap};
@@ -28,6 +28,7 @@ pub enum Variant {
     UserType(String, Vec<u8>),
     BufferId(BufferId),
     BufferInfo(BufferInfo),
+    IdentityId(IdentityId),
     Message(Message),
     MsgId(MsgId),
     Time(Time),
@@ -190,6 +191,7 @@ impl Serialize for Variant {
             }
             Variant::BufferId(v) => v.serialize_variant(),
             Variant::BufferInfo(v) => v.serialize_variant(),
+            Variant::IdentityId(v) => v.serialize_variant(),
             Variant::Message(v) => v.serialize_variant(),
             Variant::MsgId(v) => v.serialize_variant(),
             Variant::PeerPtr(v) => v.serialize_variant(),
@@ -250,12 +252,13 @@ impl Deserialize for Variant {
                         return Ok((len + user_type_len + vlen, Variant::VariantMap(value)));
                     }
                     // As i32
-                    "IdentityId" | "NetworkId" => {
+                    "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)));
                     }
+                    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),
                     Message::NAME => Message::parse_variant(b, len + user_type_len),