Merge pull request #540 from MikkelPaulson/add-crc-wrapper

Add a wrapper for the `Crc` struct

Author: Byron

src/crc.rs

@@ -3,55 +3,81 @@
 use std::io;
 use std::io::prelude::*;
 
-#[cfg(not(feature = "zlib-rs"))]
-pub use impl_crc32fast::Crc;
+/// The CRC calculated by a [`CrcReader`].
+#[derive(Debug, Default)]
+pub struct Crc {
+    inner: inner::Crc,
+}
 
-#[cfg(feature = "zlib-rs")]
-pub use impl_zlib_rs::Crc;
+impl Crc {
+    /// Create a new CRC.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Returns the current crc32 checksum.
+    pub fn sum(&self) -> u32 {
+        self.inner.sum()
+    }
+
+    /// 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.inner.amount()
+    }
+
+    /// Update the CRC with the bytes in `data`.
+    pub fn update(&mut self, data: &[u8]) {
+        self.inner.update(data);
+    }
+
+    /// Reset the CRC, to start a new hash.
+    ///
+    /// Do this in favor of creating a new `Crc` instance.
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+
+    /// Combine the CRC with the CRC for the subsequent block of bytes.
+    pub fn combine(&mut self, additional_crc: &Self) {
+        self.inner.combine(&additional_crc.inner);
+    }
+}
 
 #[cfg(not(feature = "zlib-rs"))]
-mod impl_crc32fast {
+mod inner {
     use crc32fast::Hasher;
 
-    /// The CRC calculated by a [`CrcReader`].
-    ///
-    /// [`CrcReader`]: struct.CrcReader.html
     #[derive(Debug, Default)]
     pub struct Crc {
         amt: u32,
         hasher: Hasher,
     }
 
     impl Crc {
-        /// Create a new CRC.
-        pub fn new() -> Self {
-            Self::default()
-        }
-
-        /// Returns the current crc32 checksum.
+        #[inline]
         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>.
+        #[inline]
         pub fn amount(&self) -> u32 {
             self.amt
         }
 
-        /// Update the CRC with the bytes in `data`.
+        #[inline]
         pub fn update(&mut self, data: &[u8]) {
             self.amt = self.amt.wrapping_add(data.len() as u32);
             self.hasher.update(data);
         }
 
-        /// Reset the CRC.
+        #[inline]
         pub fn reset(&mut self) {
             self.amt = 0;
             self.hasher.reset();
         }
 
-        /// Combine the CRC with the CRC for the subsequent block of bytes.
+        #[inline]
         pub fn combine(&mut self, additional_crc: &Self) {
             self.amt = self.amt.wrapping_add(additional_crc.amt);
             self.hasher.combine(&additional_crc.hasher);
@@ -60,46 +86,37 @@ mod impl_crc32fast {
 }
 
 #[cfg(feature = "zlib-rs")]
-mod impl_zlib_rs {
-    /// The CRC calculated by a [`CrcReader`].
-    ///
-    /// [`CrcReader`]: struct.CrcReader.html
+mod inner {
     #[derive(Debug, Default)]
     pub struct Crc {
         consumed: u64,
         state: u32,
     }
 
     impl Crc {
-        /// Create a new CRC.
-        pub fn new() -> Self {
-            Self::default()
-        }
-
-        /// Returns the current crc32 checksum.
+        #[inline]
         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>.
+        #[inline]
         pub fn amount(&self) -> u32 {
             self.consumed as u32
         }
 
-        /// Update the CRC with the bytes in `data`.
+        #[inline]
         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.
+        #[inline]
         pub fn reset(&mut self) {
             self.consumed = 0;
             self.state = 0
         }
 
-        /// Combine the CRC with the CRC for the subsequent block of bytes.
+        #[inline]
         pub fn combine(&mut self, additional_crc: &Self) {
             self.consumed = self.consumed.wrapping_add(additional_crc.consumed);
             self.state = zlib_rs::crc32::crc32_combine(