Add optional heapless v0.9

Author: diondokter

.github/workflows/ci.yaml

@@ -20,14 +20,14 @@ jobs:
     steps:
     - uses: actions/checkout@v3
     - uses: dtolnay/rust-toolchain@stable
-    - run: cargo test --features arrayvec
+    - run: cargo test --features arrayvec,heapless,heapless-09,alloc
 
   clippy:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
     - uses: dtolnay/rust-toolchain@stable
-    - run: cargo clippy -- -D warnings
+    - run: cargo clippy --features arrayvec,heapless,heapless-09,alloc -- -D warnings
 
   fuzz:
     runs-on: ubuntu-latest

CHANGELOG.md

@@ -5,6 +5,7 @@
 ## Unreleased
 
 - Fixed the `Value` implementation for `Option<T>` so it now serializes and deserializes properly
+- Add optional heapless v0.9 support
 
 ## 5.0.0 31-07-25
 

Cargo.toml

@@ -19,6 +19,7 @@ futures = { version = "0.3.30", features = ["executor"], optional = true }
 approx = { version = "0.5.1", optional = true }
 arrayvec = { version = "0.7.4", default-features = false, optional = true }
 heapless = { version = "0.8.0", optional = true }
+heapless-09 = { package = "heapless", version = "0.9.0", optional = true }
 
 [dev-dependencies]
 approx = "0.5.1"
@@ -32,6 +33,7 @@ std = []
 arrayvec = ["dep:arrayvec"]
 alloc = []
 heapless = ["dep:heapless"]
+heapless-09 = ["dep:heapless-09"]
 _test = ["dep:futures", "dep:approx", "std", "arrayvec", "alloc", "heapless"]
 
 [lints.rust]

src/heapless_09_impl.rs

@@ -0,0 +1,192 @@
+use core::str::FromStr;
+
+use heapless_09::{String, Vec};
+
+use crate::map::{Key, SerializationError, Value};
+
+// heapless:: Vec
+
+impl<const CAP: usize> Key for Vec<u8, CAP> {
+    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
+        if buffer.len() < self.len() + 2 {
+            return Err(SerializationError::BufferTooSmall);
+        }
+
+        if self.len() > u16::MAX as usize {
+            return Err(SerializationError::InvalidData);
+        }
+
+        buffer[..2].copy_from_slice(&(self.len() as u16).to_le_bytes());
+        buffer[2..][..self.len()].copy_from_slice(self);
+
+        Ok(self.len() + 2)
+    }
+
+    fn deserialize_from(buffer: &[u8]) -> Result<(Self, usize), SerializationError> {
+        let total_len = Self::get_len(buffer)?;
+
+        if buffer.len() < total_len {
+            return Err(SerializationError::BufferTooSmall);
+        }
+
+        let data_len = total_len - 2;
+
+        let mut output = Vec::new();
+        output
+            .extend_from_slice(&buffer[2..][..data_len])
+            .map_err(|_| SerializationError::InvalidFormat)?;
+
+        Ok((output, total_len))
+    }
+
+    fn get_len(buffer: &[u8]) -> Result<usize, SerializationError> {
+        if buffer.len() < 2 {
+            return Err(SerializationError::BufferTooSmall);
+        }
+
+        let len = u16::from_le_bytes(buffer[..2].try_into().unwrap());
+
+        Ok(len as usize + 2)
+    }
+}
+
+impl<'a, const CAP: usize> Value<'a> for Vec<u8, CAP> {
+    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
+        if buffer.len() < self.len() {
+            return Err(SerializationError::BufferTooSmall);
+        }
+
+        buffer[..self.len()].copy_from_slice(self.as_slice());
+        Ok(self.len())
+    }
+
+    fn deserialize_from(buffer: &'a [u8]) -> Result<Self, SerializationError>
+    where
+        Self: Sized,
+    {
+        Vec::try_from(buffer).map_err(|_| SerializationError::InvalidFormat)
+    }
+}
+
+// heapless::String
+
+impl<const CAP: usize> Key for String<CAP> {
+    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
+        if buffer.len() < self.len() + 2 {
+            return Err(SerializationError::InvalidFormat);
+        }
+
+        if self.len() > u16::MAX as usize {
+            return Err(SerializationError::InvalidData);
+        }
+
+        buffer[..2].copy_from_slice(&(self.len() as u16).to_le_bytes());
+        buffer[2..][..self.len()].copy_from_slice(self.as_bytes());
+
+        Ok(self.len() + 2)
+    }
+
+    fn deserialize_from(buffer: &[u8]) -> Result<(Self, usize), SerializationError> {
+        let total_len = Self::get_len(buffer)?;
+
+        if buffer.len() < total_len {
+            return Err(SerializationError::BufferTooSmall);
+        }
+
+        let data_len = total_len - 2;
+
+        let mut output = String::new();
+        output
+            .push_str(
+                core::str::from_utf8(&buffer[2..][..data_len])
+                    .map_err(|_| SerializationError::InvalidFormat)?,
+            )
+            .map_err(|_| SerializationError::InvalidFormat)?;
+
+        Ok((output, total_len))
+    }
+
+    fn get_len(buffer: &[u8]) -> Result<usize, SerializationError> {
+        if buffer.len() < 2 {
+            return Err(SerializationError::BufferTooSmall);
+        }
+
+        let len = u16::from_le_bytes(buffer[..2].try_into().unwrap());
+
+        Ok(len as usize + 2)
+    }
+}
+
+impl<'a, const CAP: usize> Value<'a> for String<CAP> {
+    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
+        if buffer.len() < self.len() {
+            return Err(SerializationError::BufferTooSmall);
+        }
+
+        buffer[..self.len()].copy_from_slice(self.as_bytes());
+        Ok(self.len())
+    }
+
+    fn deserialize_from(buffer: &'a [u8]) -> Result<Self, SerializationError>
+    where
+        Self: Sized,
+    {
+        let output = String::from_str(
+            core::str::from_utf8(buffer).map_err(|_| SerializationError::InvalidFormat)?,
+        )
+        .map_err(|_| SerializationError::BufferTooSmall)?;
+
+        Ok(output)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+
+    use super::*;
+
+    #[test]
+    fn key_serde_heapless_vec() {
+        let mut buffer = [0; 128];
+
+        let val = Vec::<u8, 12>::from_iter([0xAA; 12]);
+        Key::serialize_into(&val, &mut buffer).unwrap();
+        let new_val = <Vec<u8, 12> as Key>::deserialize_from(&buffer).unwrap();
+
+        assert_eq!((val, 14), new_val);
+    }
+
+    #[test]
+    fn key_serde_heapless_string() {
+        let mut buffer = [0; 128];
+
+        let val = String::<45>::from_str("Hello world!").unwrap();
+        Key::serialize_into(&val, &mut buffer).unwrap();
+        let new_val = <String<45> as Key>::deserialize_from(&buffer).unwrap();
+
+        assert_eq!((val, 14), new_val);
+    }
+
+    #[test]
+    fn value_serde_heapless_vec() {
+        let mut buffer = [0; 12];
+
+        let val = Vec::<u8, 12>::from_iter([0xAA; 12]);
+        Value::serialize_into(&val, &mut buffer).unwrap();
+        let new_val = <Vec<u8, 12> as Value>::deserialize_from(&buffer).unwrap();
+
+        assert_eq!(val, new_val);
+    }
+
+    #[test]
+    fn value_serde_heapless_string() {
+        let mut buffer = [0; 12];
+
+        let val = String::<45>::from_str("Hello world!").unwrap();
+        Value::serialize_into(&val, &mut buffer).unwrap();
+        let new_val = <String<45> as Value>::deserialize_from(&buffer).unwrap();
+
+        assert_eq!(val, new_val);
+    }
+}

src/lib.rs

@@ -22,6 +22,8 @@ mod arrayvec_impl;
 pub mod cache;
 #[cfg(feature = "heapless")]
 mod heapless_impl;
+#[cfg(feature = "heapless-09")]
+mod heapless_09_impl;
 mod item;
 pub mod map;
 pub mod queue;