cleanup: strong types, optional serde support

Signed-off-by: Richard Zak <richard.j.zak@gmail.com>

Author: rjzak

Cargo.lock

@@ -11,8 +11,13 @@ categories = ["algorithms"]
 description = "Rust implementation of the LZJD algorithm by Edward Raff -- https://github.com/EdwardRaff/jLZJD"
 rust-version = "1.82"
 
+[features]
+default = []
+serde = ["serde/derive"]
+
 [dependencies]
 base64 = "0.22"
+serde = { version = "1.0", optional = true }
 
 [dev-dependencies]
 rstest = "0.26.1"

Cargo.toml

@@ -7,37 +7,38 @@ use std::collections::HashSet;
 use base64::{engine::general_purpose, Engine as _};
 
 /// LZJD digest builder/configuration
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct Lzjd {
     /// number of k smallest hashes to keep (digest size)
-    pub k: usize,
+    k: usize,
+
     /// seed for the `MurmurHash3` hashing
-    pub seed: u32,
+    seed: u32,
 }
 
 impl Default for Lzjd {
+    #[inline]
     fn default() -> Self {
         Self { k: 1024, seed: 0 }
     }
 }
 
 impl Lzjd {
-    /// Create new LZJD config with given k and seed
+    /// Create a new Lzjd hasher with given size and seed
+    #[inline]
     #[must_use]
     pub fn new(k: usize, seed: u32) -> Self {
         Self { k, seed }
     }
 
-    /// Build an LZJD digest from input bytes using `MurmurHash3_x86_32`.
-    ///
-    /// Returns a `Vec<u32>` of exactly `k` entries: the k-smallest hash values (sorted
-    /// ascending as signed i32, matching jLZJD), zero-padded when the input yields fewer
-    /// than `k` unique LZ78 phrases.
+    /// Build an [`LzDigest`] digest from input bytes. Two digests can be used to find similarity,
+    /// or a digest can be saved to a string.
     #[must_use]
     #[allow(clippy::cast_possible_wrap)]
-    pub fn digest_from_bytes(&self, data: &[u8]) -> Vec<u32> {
+    pub fn digest_from_bytes(&self, data: &[u8]) -> LzDigest {
         let n = data.len();
-        let mut seen: HashSet<u32> = HashSet::new();
-        let mut hashes: Vec<u32> = Vec::new();
+        let mut seen = HashSet::new();
+        let mut hashes = Vec::new();
         let mut start = 0usize;
 
         while start < n {
@@ -57,89 +58,134 @@ impl Lzjd {
         }
 
         hashes.sort_unstable_by_key(|&v| v as i32);
-        if hashes.len() > self.k {
-            hashes.truncate(self.k);
-        } else {
+        if hashes.len() != self.k {
             hashes.resize(self.k, 0);
         }
-        hashes
+
+        LzDigest { digest: hashes }
+    }
+
+    /// Convenience: compute digest and similarity between two raw byte inputs
+    #[inline]
+    #[must_use]
+    pub fn similarity_bytes(&self, a: &[u8], b: &[u8]) -> f32 {
+        let da = self.digest_from_bytes(a);
+        let db = self.digest_from_bytes(b);
+        da.similarity(&db)
+    }
+}
+
+/// LZJD digest
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct LzDigest {
+    digest: Vec<u32>,
+}
+
+impl LzDigest {
+    /// Convert an LZJD digest from base64 to an [`LzDigest`]
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the input is not valid base64 or if the decoded length is not a multiple of 4.
+    pub fn from_string(s: &str) -> Result<Self, String> {
+        let bytes = general_purpose::STANDARD
+            .decode(s)
+            .map_err(|e| format!("Base64 decode failed: {e}"))?;
+
+        if bytes.len() % 4 != 0 {
+            return Err("Invalid LZJD Base64 length (not multiple of 4)".into());
+        }
+
+        let mut digest = Vec::with_capacity(bytes.len() / 4);
+        for chunk in bytes.chunks_exact(4) {
+            let h = u32::from_be_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
+            digest.push(h);
+        }
+
+        Ok(Self { digest })
     }
 
-    /// Compute approximate Jaccard similarity between two LZJD digests (both sorted).
+    /// Compute approximate Jaccard similarity between two LZJD digests.
     ///
-    /// Both inputs should be sorted ascending as signed i32 and represent the k-smallest
-    /// hashes of the original sets.  Returns a value in `[0.0, 1.0]`.
+    /// Returns a value in `[0.0, 1.0]`.
     #[must_use]
-    #[allow(clippy::cast_possible_wrap, clippy::cast_precision_loss, clippy::comparison_chain)]
-    pub fn similarity_from_digests(a: &[u32], b: &[u32]) -> f64 {
+    #[allow(
+        clippy::cast_possible_wrap,
+        clippy::cast_precision_loss,
+        clippy::comparison_chain
+    )]
+    pub fn similarity(&self, other: &Self) -> f32 {
         let mut i = 0usize;
         let mut j = 0usize;
         let mut inter = 0usize;
 
-        while i < a.len() && j < b.len() {
-            if a[i] == b[j] {
+        while i < self.digest.len() && j < other.digest.len() {
+            if self.digest[i] == other.digest[j] {
                 inter += 1;
                 i += 1;
                 j += 1;
-            } else if (a[i] as i32) < (b[j] as i32) {
+            } else if (self.digest[i] as i32) < (other.digest[j] as i32) {
                 i += 1;
             } else {
                 j += 1;
             }
         }
 
-        let union = a.len() + b.len() - inter;
+        let union = self.digest.len() + other.digest.len() - inter;
         if union == 0 {
             0.0
         } else {
-            inter as f64 / union as f64
+            inter as f32 / union as f32
         }
     }
+}
 
-    /// Convenience: compute digest and similarity between two raw byte inputs
-    #[must_use]
-    pub fn similarity_bytes(&self, a: &[u8], b: &[u8]) -> f64 {
-        let da = self.digest_from_bytes(a);
-        let db = self.digest_from_bytes(b);
-        Self::similarity_from_digests(&da, &db)
+impl From<LzDigest> for String {
+    fn from(d: LzDigest) -> Self {
+        d.to_string()
     }
+}
 
-    /// Convert an LZJD digest to a base64-encoded string (jLZJD-compatible format).
-    ///
-    /// Each `u32` entry is written as a big-endian i32 (matching Java's default byte order),
-    /// producing a fixed-size array of `k` 4-byte values including any zero-padding.
-    #[must_use]
-    pub fn lzjd_digest_to_base64(digest: &[u32]) -> String {
-        let mut bytes = Vec::with_capacity(digest.len() * 4);
-        for &h in digest {
-            bytes.extend_from_slice(&h.to_be_bytes());
-        }
-        general_purpose::STANDARD.encode(bytes)
+impl From<&LzDigest> for String {
+    fn from(d: &LzDigest) -> Self {
+        d.to_string()
     }
+}
 
-    /// Create a LZJD digest from a base64-encoded string (jLZJD-compatible format).
-    ///
-    /// Reads big-endian i32 values, preserving zero-padded entries.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the base64 string is invalid or not a multiple of 4 bytes.
-    pub fn lzjd_digest_from_base64(b64: &str) -> Result<Vec<u32>, String> {
-        let bytes = general_purpose::STANDARD
-            .decode(b64)
-            .map_err(|e| format!("Base64 decode failed: {e}"))?;
+impl From<&[u8]> for LzDigest {
+    fn from(data: &[u8]) -> Self {
+        Lzjd::default().digest_from_bytes(data)
+    }
+}
 
-        if bytes.len() % 4 != 0 {
-            return Err("Invalid LZJD Base64 length (not multiple of 4)".into());
+impl std::fmt::Display for LzDigest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut bytes = Vec::with_capacity(self.digest.len() * 4);
+        for h in &self.digest {
+            bytes.extend_from_slice(&h.to_be_bytes());
         }
+        write!(f, "{}", general_purpose::STANDARD.encode(bytes))
+    }
+}
 
-        let mut digest = Vec::with_capacity(bytes.len() / 4);
-        for chunk in bytes.chunks_exact(4) {
-            let h = u32::from_be_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
-            digest.push(h);
-        }
+#[cfg(feature = "serde")]
+impl serde::Serialize for LzDigest {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
 
-        Ok(digest)
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for LzDigest {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        LzDigest::from_string(&s).map_err(serde::de::Error::custom)
     }
 }
 
@@ -153,7 +199,7 @@ mod tests {
         let lz = Lzjd::new(16, 0);
         let data = b"abracadabra abracadabra";
         let digest = lz.digest_from_bytes(data);
-        assert!(digest.len() <= 16);
+        assert!(digest.digest.len() <= 16);
         // subsequent call same input yields same digest
         let digest2 = lz.digest_from_bytes(data);
         assert_eq!(digest, digest2);
@@ -188,31 +234,32 @@ mod tests {
         let digest = lz.digest_from_bytes(data);
 
         // Save to Base64
-        let b64 = Lzjd::lzjd_digest_to_base64(&digest);
+        let b64 = digest.to_string();
         println!("Base64 LZJD: {b64}");
 
         // Load from Base64
-        let decoded = Lzjd::lzjd_digest_from_base64(&b64).unwrap();
+        let decoded = LzDigest::from_string(&b64).unwrap();
 
         // Verify exact match
         assert_eq!(digest, decoded);
     }
 
     #[rstest]
-    #[case(include_str!("../testdata/lorem_ipsum_5.txt"), include_str!("../testdata/lorem_ipsum_5.lzjd.txt"))]
-    #[case(include_str!("../testdata/lorem_ipsum_6.txt"), include_str!("../testdata/lorem_ipsum_6.lzjd.txt"))]
-    #[case(include_str!("../testdata/lorem_ipsum_10.txt"), include_str!("../testdata/lorem_ipsum_10.lzjd.txt"))]
+    #[case(include_bytes!("../testdata/lorem_ipsum_5.txt"), include_str!("../testdata/lorem_ipsum_5.lzjd.txt"))]
+    #[case(include_bytes!("../testdata/lorem_ipsum_6.txt"), include_str!("../testdata/lorem_ipsum_6.lzjd.txt"))]
+    #[case(include_bytes!("../testdata/lorem_ipsum_10.txt"), include_str!("../testdata/lorem_ipsum_10.lzjd.txt"))]
+    #[case(include_bytes!("../testdata/random.bin"), include_str!("../testdata/random.bin.lzjd.txt"))]
     #[test]
-    fn lorem_ipsum(#[case] data: &str, #[case] expected_hash: &str) {
+    fn lorem_ipsum(#[case] data: &[u8], #[case] expected_hash: &str) {
         let lz = Lzjd::new(1024, 0);
-        let digest = lz.digest_from_bytes(data.as_bytes());
-        let lzjd_hash = Lzjd::lzjd_digest_to_base64(&digest);
+        let digest = lz.digest_from_bytes(data);
+        let lzjd_hash = digest.to_string();
         assert_eq!(lzjd_hash, expected_hash);
 
-        let decoded = Lzjd::lzjd_digest_from_base64(expected_hash).unwrap();
+        let decoded = LzDigest::from_string(expected_hash).unwrap();
         assert_eq!(digest, decoded);
 
-        let similarity = Lzjd::similarity_from_digests(&digest, &decoded);
+        let similarity = digest.similarity(&decoded);
         assert_eq!(format!("{similarity:.2}"), "1.00");
     }
 }

src/lzjd.rs

@@ -25,7 +25,12 @@ pub fn murmur3_x86_32(data: &[u8], seed: u32) -> u32 {
     let mut h1 = seed;
 
     for i in 0..n_blocks {
-        let k_bytes = [data[4 * i], data[4 * i + 1], data[4 * i + 2], data[4 * i + 3]];
+        let k_bytes = [
+            data[4 * i],
+            data[4 * i + 1],
+            data[4 * i + 2],
+            data[4 * i + 3],
+        ];
         let mut k1 = u32::from_le_bytes(k_bytes);
         k1 = k1.wrapping_mul(C1).rotate_left(15).wrapping_mul(C2);
         h1 ^= k1;

src/murmur3.rs

@@ -0,0 +1 @@
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