Merge pull request #14 from xzeck/bug-fix/mismatched-data-type-on-serialize-and-deserialize

Fixed mismatched data type serializing and deserializing bug

Author: xzeck

examples/custom_type.rs

@@ -13,6 +13,8 @@ impl ToBytes for Person {
         v.extend(self.name.as_bytes());
         v
     }
+
+    const TYPE_ID: &'static [u8] = b"Person";
 }
 
 fn main() {

src/lib.rs

@@ -4,7 +4,7 @@ pub use tobytes::ToBytes;
 
 use std::{hash::{BuildHasher, BuildHasherDefault, DefaultHasher, Hasher}, marker::PhantomData};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use serde::de::{Error as DeError};
+use serde::de::Error as DeError;
 
 /// HyperLogLog is a probabilistic data structure for estimating cardinality.
 /// This implementation uses the HyperLogLog algorithm to estimate the
@@ -32,10 +32,11 @@ impl<T: ToBytes, S: BuildHasher + Default> Serialize for HyperLogLog<T, S> {
     where
         Ser: Serializer,
     {
-        // generating a finger print
+        // generating a fingerprint
         // This is so that if the state is saved and then reloaded we can ensure the same hashing function is used to maintain consistence
         let mut hasher = self.hasher_builder.build_hasher();
         hasher.write(b"__hyperloglog_fingerprint__");
+        hasher.write(T::TYPE_ID);
         let fingerprint = hasher.finish();
 
         // generating serializable structure
@@ -61,10 +62,11 @@ impl<'de, T: ToBytes, S: BuildHasher + Default> Deserialize<'de> for HyperLogLog
         // Recompute fingerprint using S::default()
         let mut hasher = S::default().build_hasher();
         hasher.write(b"__hyperloglog_fingerprint__");
+        hasher.write(T::TYPE_ID);
         let expected_fingerprint = hasher.finish();
 
         if expected_fingerprint != data.fingerprint {
-            return Err(D::Error::custom("Hasher mismatch: incompatible hasher used during deserialization"));
+            return Err(D::Error::custom("Hasher mismatch: incompatible hasher or datatype used during deserialization"));
         }
 
         Ok(Self {

src/tobytes.rs

@@ -1,90 +1,121 @@
 pub trait ToBytes {
     fn to_bytes(&self) -> Vec<u8>;
+
+    const TYPE_ID: &'static [u8];
 }
 
 // Integer types (Little Endian)
 impl ToBytes for u8 {
     fn to_bytes(&self) -> Vec<u8> {
         vec![*self]
     }
+
+    const TYPE_ID: &'static [u8] = b"u8";
 }
 
 impl ToBytes for u16 {
     fn to_bytes(&self) -> Vec<u8> {
         self.to_le_bytes().to_vec()
     }
+
+    const TYPE_ID: &'static [u8] = b"u16";
 }
 
 impl ToBytes for u32 {
     fn to_bytes(&self) -> Vec<u8> {
         self.to_le_bytes().to_vec()
     }
+
+    const TYPE_ID: &'static [u8] = b"u32";
 }
 
 impl ToBytes for u64 {
     fn to_bytes(&self) -> Vec<u8> {
         self.to_le_bytes().to_vec()
     }
+
+    const TYPE_ID: &'static [u8] = b"u64";
 }
 
 impl ToBytes for u128 {
     fn to_bytes(&self) -> Vec<u8> {
         self.to_le_bytes().to_vec()
     }
+
+    const TYPE_ID: &'static [u8] = b"u128";
 }
 
 impl ToBytes for i8 {
     fn to_bytes(&self) -> Vec<u8> {
         vec![*self as u8]
     }
+
+    const TYPE_ID: &'static [u8] = b"i8";
+
 }
 
 impl ToBytes for i16 {
     fn to_bytes(&self) -> Vec<u8> {
         self.to_le_bytes().to_vec()
     }
+
+    const TYPE_ID: &'static [u8] = b"i16";
 }
 
 impl ToBytes for i32 {
     fn to_bytes(&self) -> Vec<u8> {
         self.to_le_bytes().to_vec()
     }
+
+    const TYPE_ID: &'static [u8] = b"i32";
 }
 
 impl ToBytes for i64 {
     fn to_bytes(&self) -> Vec<u8> {
         self.to_le_bytes().to_vec()
     }
+
+    const TYPE_ID: &'static [u8] = b"i64";
 }
 
 impl ToBytes for i128 {
     fn to_bytes(&self) -> Vec<u8> {
         self.to_le_bytes().to_vec()
     }
+
+    const TYPE_ID: &'static [u8] = b"i128";
 }
 
 // Floating point types (Native Endian)
 impl ToBytes for f32 {
     fn to_bytes(&self) -> Vec<u8> {
         self.to_ne_bytes().to_vec()
     }
+
+    const TYPE_ID: &'static [u8] = b"f32";
 }
 
 impl ToBytes for f64 {
     fn to_bytes(&self) -> Vec<u8> {
         self.to_ne_bytes().to_vec()
     }
+
+    const TYPE_ID: &'static [u8] = b"f64";
 }
 
 
 impl ToBytes for &str {
     fn to_bytes(&self) -> Vec<u8> {
         self.as_bytes().to_vec()
     }
+
+    const TYPE_ID: &'static [u8] = b"&str";
 }
 
 impl ToBytes for String {
     fn to_bytes(&self) -> Vec<u8> {
         self.as_bytes().to_vec()
     }
+    
+    const TYPE_ID: &'static [u8] = b"String";
 }

tests/integer_tests.rs

@@ -10,6 +10,8 @@ impl ToBytes for Colliding {
     fn to_bytes(&self) -> Vec<u8> {
         vec![0; 8]
     }
+
+    const TYPE_ID: &'static [u8] = b"Colliding";
 }
 
 /// Sequential test of insert and cardinality

tests/serializing_deserializing_test.rs

@@ -58,6 +58,7 @@ fn test_roundtrip_json_identity() {
     let recovered: HyperLogLog<i64, BuildHasherDefault<DefaultHasher>> =
         serde_json::from_str(&original).unwrap();
     let round_trip = serde_json::to_string(&recovered).unwrap();
+
     assert_eq!(original, round_trip, "Serialize→deserialize→serialize should preserve exact JSON");
 }
 
@@ -91,4 +92,17 @@ fn test_xxh3_roundtrip_succeeds() {
         hll.calculate_cardinality(),
         "XXH3→serde→XXH3 roundtrip should work and preserve cardinality"
     );
+}
+
+#[test]
+fn test_error_on_deserializing_mismatched_element_type() {
+    let p = 4;
+    let mut hll: HyperLogLog<i64> = HyperLogLog::new(p);
+
+    let json = serde_json::to_string(&hll).unwrap();
+
+    let res: Result<HyperLogLog<f64>, _> = serde_json::from_str(&json);
+
+    assert!(res.is_err(), "Deserializing different datatype, should fail");
+
 }

tests/string_tests.rs

@@ -111,6 +111,8 @@ impl ToBytes for CollidingString {
     fn to_bytes(&self) -> Vec<u8> {
         Vec::new() // all collide
     }
+
+    const TYPE_ID: &'static [u8] = b"CollidingString";
 }
 
 #[test]