use zlib-rs for crc32 (when available)

folkertdev · folkertdev · commit c584e970419e · 2026-01-13T21:11:13.000+01:00
diff --git a/src/crc.rs b/src/crc.rs
@@ -3,62 +3,123 @@
 use std::io;
 use std::io::prelude::*;
 
-use crc32fast::Hasher;
+#[cfg(not(feature = "zlib-rs"))]
+pub use impl_crc32fast::Crc;
 
-/// The CRC calculated by a [`CrcReader`].
-///
-/// [`CrcReader`]: struct.CrcReader.html
-#[derive(Debug, Default)]
-pub struct Crc {
-    amt: u32,
-    hasher: Hasher,
-}
+#[cfg(feature = "zlib-rs")]
+pub use impl_zlib_rs::Crc;
 
-/// A wrapper around a [`Read`] that calculates the CRC.
-///
-/// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
-#[derive(Debug)]
-pub struct CrcReader<R> {
-    inner: R,
-    crc: Crc,
-}
+#[cfg(not(feature = "zlib-rs"))]
+mod impl_crc32fast {
+    use crc32fast::Hasher;
 
-impl Crc {
-    /// Create a new CRC.
-    pub fn new() -> Self {
-        Self::default()
+    /// The CRC calculated by a [`CrcReader`].
+    ///
+    /// [`CrcReader`]: struct.CrcReader.html
+    #[derive(Debug, Default)]
+    pub struct Crc {
+        amt: u32,
+        hasher: Hasher,
     }
 
-    /// Returns the current crc32 checksum.
-    pub fn sum(&self) -> u32 {
-        self.hasher.clone().finalize()
-    }
+    impl Crc {
+        /// Create a new CRC.
+        pub fn new() -> Self {
+            Self::default()
+        }
 
-    /// The number of bytes that have been used to calculate the CRC.
-    /// This value is only accurate if the amount is lower than 2<sup>32</sup>.
-    pub fn amount(&self) -> u32 {
-        self.amt
-    }
+        /// Returns the current crc32 checksum.
+        pub fn sum(&self) -> u32 {
+            self.hasher.clone().finalize()
+        }
+
+        /// The number of bytes that have been used to calculate the CRC.
+        /// This value is only accurate if the amount is lower than 2<sup>32</sup>.
+        pub fn amount(&self) -> u32 {
+            self.amt
+        }
+
+        /// Update the CRC with the bytes in `data`.
+        pub fn update(&mut self, data: &[u8]) {
+            self.amt = self.amt.wrapping_add(data.len() as u32);
+            self.hasher.update(data);
+        }
+
+        /// Reset the CRC.
+        pub fn reset(&mut self) {
+            self.amt = 0;
+            self.hasher.reset();
+        }
 
-    /// Update the CRC with the bytes in `data`.
-    pub fn update(&mut self, data: &[u8]) {
-        self.amt = self.amt.wrapping_add(data.len() as u32);
-        self.hasher.update(data);
+        /// Combine the CRC with the CRC for the subsequent block of bytes.
+        pub fn combine(&mut self, additional_crc: &Self) {
+            self.amt = self.amt.wrapping_add(additional_crc.amt);
+            self.hasher.combine(&additional_crc.hasher);
+        }
     }
+}
 
-    /// Reset the CRC.
-    pub fn reset(&mut self) {
-        self.amt = 0;
-        self.hasher.reset();
+#[cfg(feature = "zlib-rs")]
+mod impl_zlib_rs {
+    /// The CRC calculated by a [`CrcReader`].
+    ///
+    /// [`CrcReader`]: struct.CrcReader.html
+    #[derive(Debug, Default)]
+    pub struct Crc {
+        consumed: u64,
+        state: u32,
     }
 
-    /// Combine the CRC with the CRC for the subsequent block of bytes.
-    pub fn combine(&mut self, additional_crc: &Crc) {
-        self.amt = self.amt.wrapping_add(additional_crc.amt);
-        self.hasher.combine(&additional_crc.hasher);
+    impl Crc {
+        /// Create a new CRC.
+        pub fn new() -> Self {
+            Self::default()
+        }
+
+        /// Returns the current crc32 checksum.
+        pub fn sum(&self) -> u32 {
+            self.state
+        }
+
+        /// The number of bytes that have been used to calculate the CRC.
+        /// This value is only accurate if the amount is lower than 2<sup>32</sup>.
+        pub fn amount(&self) -> u32 {
+            self.consumed as u32
+        }
+
+        /// Update the CRC with the bytes in `data`.
+        pub fn update(&mut self, data: &[u8]) {
+            self.consumed = self.consumed.wrapping_add(data.len() as u64);
+            self.state = zlib_rs::crc32::crc32(self.state, data);
+        }
+
+        /// Reset the CRC.
+        pub fn reset(&mut self) {
+            self.consumed = 0;
+            self.state = 0
+        }
+
+        /// Combine the CRC with the CRC for the subsequent block of bytes.
+        pub fn combine(&mut self, additional_crc: &Self) {
+            self.consumed = self.consumed.wrapping_add(additional_crc.consumed);
+            self.state = zlib_rs::crc32::crc32_combine(
+                self.state,
+                additional_crc.state,
+                additional_crc.consumed,
+            );
+        }
     }
 }
 
+/// A wrapper around a [`Read`] that calculates the CRC.
+///
+/// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
+#[derive(Debug)]
+pub struct CrcReader<R> {
+    inner: R,
+    crc: Crc,
+}
+
 impl<R: Read> CrcReader<R> {
     /// Create a new `CrcReader`.
     pub fn new(r: R) -> CrcReader<R> {
@@ -173,3 +234,77 @@ impl<W: Write> Write for CrcWriter<W> {
         self.inner.flush()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Crc;
+
+    fn crc_of(data: &[u8]) -> Crc {
+        let mut c = Crc::new();
+        c.update(data);
+        c
+    }
+
+    fn sum_of(data: &[u8]) -> u32 {
+        crc_of(data).sum()
+    }
+
+    #[test]
+    fn new_is_empty() {
+        let c = Crc::new();
+        assert_eq!(c.amount(), 0);
+        assert_eq!(c.sum(), 0);
+    }
+
+    #[test]
+    fn known_vector_hello() {
+        assert_eq!(sum_of(b"hello"), 0x3610_A686);
+    }
+
+    #[test]
+    fn known_vector_quick_brown_fox() {
+        assert_eq!(
+            sum_of(b"The quick brown fox jumps over the lazy dog"),
+            0x414F_A339
+        );
+    }
+
+    #[test]
+    fn update_is_streaming() {
+        let mut c = Crc::new();
+        c.update(b"hello");
+        c.update(b" ");
+        c.update(b"world");
+
+        assert_eq!(c.amount(), 11);
+        assert_eq!(c.sum(), sum_of(b"hello world"));
+    }
+
+    #[test]
+    fn reset_restores_initial_state() {
+        let mut c = Crc::new();
+        c.update(b"abc");
+        assert_ne!(c.sum(), 0);
+        assert_eq!(c.amount(), 3);
+
+        c.reset();
+        assert_eq!(c.amount(), 0);
+        assert_eq!(c.sum(), 0);
+    }
+
+    #[test]
+    fn combine_matches_concatenation() {
+        let a = b"hello ";
+        let b = b"world";
+
+        let mut ca = crc_of(a);
+        let cb = crc_of(b);
+
+        ca.combine(&cb);
+
+        dbg!(&ca);
+
+        assert_eq!(ca.amount(), 11);
+        assert_eq!(ca.sum(), sum_of(b"hello world"));
+    }
+}
