From 58eb9e51595838aa28e24db69ff01a5509852357 Mon Sep 17 00:00:00 2001
From: Max Audron <audron@cocaine.farm>
Date: Wed, 26 Feb 2025 19:15:11 +0100
Subject: implement IdentityId

---
 src/primitive/bufferid.rs   |  2 +-
 src/primitive/identityid.rs | 65 +++++++++++++++++++++++++++++++++++++++++++++
 src/primitive/mod.rs        |  2 ++
 src/primitive/variant.rs    |  7 +++--
 4 files changed, 73 insertions(+), 3 deletions(-)
 create mode 100644 src/primitive/identityid.rs

(limited to 'src/primitive')

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),
-- 
cgit v1.2.3