Introduces CRCs

A `crc` feature has been added that brings in the `crc` crate and a new `CrcModifier` flavour. This modifier flavour is similar to the COBS implementation in how it wraps another flavour.

.gitignore

@@ -1,3 +1,4 @@
 /target
 **/*.rs.bk
-Cargo.lock
+Cargo.lock
+.vscode

Cargo.toml

@@ -52,13 +52,18 @@ path = "./postcard-derive"
 version = "0.1.1"
 optional = true
 
+[dependencies.crc]
+version = "3.0.1"
+optional = true
+
 [features]
 default = ["heapless-cas"]
 
 use-std = ["serde/std", "alloc"]
 heapless-cas = ["heapless", "heapless/cas"]
 alloc = ["serde/alloc"]
 use-defmt = ["defmt"]
+use-crc = ["crc"]
 
 # Experimental features!
 #

src/ser/flavors.rs

@@ -411,6 +411,152 @@ where
     }
 }
 
+////////////////////////////////////////
+// CRC
+////////////////////////////////////////
+
+/// This Cyclic Redundancy Check flavor applies [the CRC crate's `Algorithm`](https://docs.rs/crc/latest/crc/struct.Algorithm.html) struct on
+/// the serialized data. The output of this flavor receives the CRC appended to the bytes.
+///
+/// CRCs are used for error detection when reading data back.
+///
+/// The `crc` feature requires enabling to use this module.
+///
+/// More on CRCs: https://en.wikipedia.org/wiki/Cyclic_redundancy_check.
+#[cfg(feature = "crc")]
+pub mod crc {
+    use crc::Digest;
+    use crc::Width;
+
+    use super::Flavor;
+    use super::IndexMut;
+    use crate::Result;
+
+    /// Manages CRC modifications as a flavor.
+    pub struct CrcModifier<'a, B, W>
+    where
+        B: Flavor + IndexMut<usize, Output = u8>,
+        W: Width,
+    {
+        flav: B,
+        digest: Digest<'a, W>,
+    }
+
+    impl<'a, B, W> CrcModifier<'a, B, W>
+    where
+        B: Flavor + IndexMut<usize, Output = u8>,
+        W: Width,
+    {
+        /// Create a new Crc modifier Flavor.
+        pub fn new(bee: B, digest: Digest<'a, W>) -> Self {
+            Self { flav: bee, digest }
+        }
+
+        #[inline(always)]
+        fn try_push_crc(flav: &mut B, crc_bytes: &[u8]) -> Result<()> {
+            for byte in crc_bytes {
+                flav.try_push(*byte)?;
+            }
+            Ok(())
+        }
+    }
+
+    impl<'a, B> Flavor for CrcModifier<'a, B, u8>
+    where
+        B: Flavor + IndexMut<usize, Output = u8>,
+    {
+        type Output = <B as Flavor>::Output;
+
+        #[inline(always)]
+        fn try_push(&mut self, data: u8) -> Result<()> {
+            self.digest.update(&[data]);
+            self.flav.try_push(data)
+        }
+
+        fn finalize(mut self) -> Result<Self::Output> {
+            let crc = self.digest.finalize();
+            Self::try_push_crc(&mut self.flav, &crc.to_le_bytes())?;
+            self.flav.finalize()
+        }
+    }
+
+    impl<'a, B> Flavor for CrcModifier<'a, B, u16>
+    where
+        B: Flavor + IndexMut<usize, Output = u8>,
+    {
+        type Output = <B as Flavor>::Output;
+
+        #[inline(always)]
+        fn try_push(&mut self, data: u8) -> Result<()> {
+            self.digest.update(&[data]);
+            self.flav.try_push(data)
+        }
+
+        fn finalize(mut self) -> Result<Self::Output> {
+            let crc = self.digest.finalize();
+            Self::try_push_crc(&mut self.flav, &crc.to_le_bytes())?;
+            self.flav.finalize()
+        }
+    }
+
+    impl<'a, B> Flavor for CrcModifier<'a, B, u32>
+    where
+        B: Flavor + IndexMut<usize, Output = u8>,
+    {
+        type Output = <B as Flavor>::Output;
+
+        #[inline(always)]
+        fn try_push(&mut self, data: u8) -> Result<()> {
+            self.digest.update(&[data]);
+            self.flav.try_push(data)
+        }
+
+        fn finalize(mut self) -> Result<Self::Output> {
+            let crc = self.digest.finalize();
+            Self::try_push_crc(&mut self.flav, &crc.to_le_bytes())?;
+            self.flav.finalize()
+        }
+    }
+
+    impl<'a, B> Flavor for CrcModifier<'a, B, u64>
+    where
+        B: Flavor + IndexMut<usize, Output = u8>,
+    {
+        type Output = <B as Flavor>::Output;
+
+        #[inline(always)]
+        fn try_push(&mut self, data: u8) -> Result<()> {
+            self.digest.update(&[data]);
+            self.flav.try_push(data)
+        }
+
+        fn finalize(mut self) -> Result<Self::Output> {
+            let crc = self.digest.finalize();
+            Self::try_push_crc(&mut self.flav, &crc.to_le_bytes())?;
+            self.flav.finalize()
+        }
+    }
+
+    impl<'a, B> Flavor for CrcModifier<'a, B, u128>
+    where
+        B: Flavor + IndexMut<usize, Output = u8>,
+    {
+        type Output = <B as Flavor>::Output;
+
+        #[inline(always)]
+        fn try_push(&mut self, data: u8) -> Result<()> {
+            self.digest.update(&[data]);
+            self.flav.try_push(data)
+        }
+
+        fn finalize(mut self) -> Result<Self::Output> {
+            let crc = self.digest.finalize();
+            Self::try_push_crc(&mut self.flav, &crc.to_le_bytes())?;
+            self.flav.finalize()
+        }
+    }
+}
+
 /// The `Size` flavor is a measurement flavor, which accumulates the number of bytes needed to
 /// serialize the data.
 ///

tests/crc.rs

@@ -0,0 +1,17 @@
+#[test]
+#[cfg(feature = "crc")]
+fn test_crc() {
+    use crc::{Crc, CRC_32_ISCSI};
+    use postcard::{
+        ser_flavors::{crc::CrcModifier, Slice},
+        serialize_with_flavor,
+    };
+
+    let data: &[u8] = &[0x01, 0x00, 0x20, 0x30];
+    let buffer = &mut [0u8; 32];
+    let crc = Crc::<u32>::new(&CRC_32_ISCSI);
+    let digest = crc.digest();
+    let res = serialize_with_flavor(data, CrcModifier::new(Slice::new(buffer), digest)).unwrap();
+
+    assert_eq!(res, &[0x04, 0x01, 0x00, 0x20, 0x30, 0x8E, 0xC8, 0x1A, 0x37]);
+}