sequential_storage/
heapless_impl.rs

1use core::str::FromStr;
2
3use heapless::{String, Vec};
4
5use crate::map::{Key, SerializationError, Value};
6
7// heapless:: Vec
8
9impl<const CAP: usize> Key for Vec<u8, CAP> {
10    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
11        if self.len() > u16::MAX as usize {
12            return Err(SerializationError::InvalidData);
13        }
14
15        if buffer.len() < self.len() + 2 {
16            return Err(SerializationError::BufferTooSmall);
17        }
18
19        buffer[..2].copy_from_slice(&(self.len() as u16).to_le_bytes());
20        buffer[2..][..self.len()].copy_from_slice(self);
21
22        Ok(self.len() + 2)
23    }
24
25    fn deserialize_from(buffer: &[u8]) -> Result<(Self, usize), SerializationError> {
26        let total_len = Self::get_len(buffer)?;
27
28        if buffer.len() < total_len {
29            return Err(SerializationError::BufferTooSmall);
30        }
31
32        let data_len = total_len - 2;
33
34        let mut output = Vec::new();
35        output
36            .extend_from_slice(&buffer[2..][..data_len])
37            .map_err(|_| SerializationError::InvalidFormat)?;
38
39        Ok((output, total_len))
40    }
41
42    fn get_len(buffer: &[u8]) -> Result<usize, SerializationError> {
43        if buffer.len() < 2 {
44            return Err(SerializationError::BufferTooSmall);
45        }
46
47        let len = u16::from_le_bytes(buffer[..2].try_into().unwrap());
48
49        Ok(len as usize + 2)
50    }
51}
52
53impl<'a, const CAP: usize> Value<'a> for Vec<u8, CAP> {
54    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
55        if buffer.len() < self.len() {
56            return Err(SerializationError::BufferTooSmall);
57        }
58
59        buffer[..self.len()].copy_from_slice(self.as_slice());
60        Ok(self.len())
61    }
62
63    fn deserialize_from(buffer: &'a [u8]) -> Result<(Self, usize), SerializationError>
64    where
65        Self: Sized,
66    {
67        let value = Vec::try_from(buffer).map_err(|_| SerializationError::InvalidFormat)?;
68        Ok((value, buffer.len()))
69    }
70}
71
72// heapless::String
73
74impl<const CAP: usize> Key for String<CAP> {
75    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
76        if self.len() > u16::MAX as usize {
77            return Err(SerializationError::InvalidData);
78        }
79
80        if buffer.len() < self.len() + 2 {
81            return Err(SerializationError::InvalidFormat);
82        }
83
84        buffer[..2].copy_from_slice(&(self.len() as u16).to_le_bytes());
85        buffer[2..][..self.len()].copy_from_slice(self.as_bytes());
86
87        Ok(self.len() + 2)
88    }
89
90    fn deserialize_from(buffer: &[u8]) -> Result<(Self, usize), SerializationError> {
91        let total_len = Self::get_len(buffer)?;
92
93        if buffer.len() < total_len {
94            return Err(SerializationError::BufferTooSmall);
95        }
96
97        let data_len = total_len - 2;
98
99        let mut output = String::new();
100        output
101            .push_str(
102                core::str::from_utf8(&buffer[2..][..data_len])
103                    .map_err(|_| SerializationError::InvalidFormat)?,
104            )
105            .map_err(|_| SerializationError::InvalidFormat)?;
106
107        Ok((output, total_len))
108    }
109
110    fn get_len(buffer: &[u8]) -> Result<usize, SerializationError> {
111        if buffer.len() < 2 {
112            return Err(SerializationError::BufferTooSmall);
113        }
114
115        let len = u16::from_le_bytes(buffer[..2].try_into().unwrap());
116
117        Ok(len as usize + 2)
118    }
119}
120
121impl<'a, const CAP: usize> Value<'a> for String<CAP> {
122    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
123        if buffer.len() < self.len() {
124            return Err(SerializationError::BufferTooSmall);
125        }
126
127        buffer[..self.len()].copy_from_slice(self.as_bytes());
128        Ok(self.len())
129    }
130
131    fn deserialize_from(buffer: &'a [u8]) -> Result<(Self, usize), SerializationError>
132    where
133        Self: Sized,
134    {
135        let output = String::from_str(
136            core::str::from_utf8(buffer).map_err(|_| SerializationError::InvalidFormat)?,
137        )
138        .map_err(|_| SerializationError::BufferTooSmall)?;
139
140        Ok((output, buffer.len()))
141    }
142}
143
144#[cfg(test)]
145mod tests {
146    use core::str::FromStr;
147
148    use super::*;
149
150    #[test]
151    fn key_serde_heapless_vec() {
152        let mut buffer = [0; 128];
153
154        let val = Vec::<u8, 12>::from_iter([0xAA; 12]);
155        Key::serialize_into(&val, &mut buffer).unwrap();
156        let new_val = <Vec<u8, 12> as Key>::deserialize_from(&buffer).unwrap();
157
158        assert_eq!((val, 14), new_val);
159    }
160
161    #[test]
162    fn key_serde_heapless_string() {
163        let mut buffer = [0; 128];
164
165        let val = String::<45>::from_str("Hello world!").unwrap();
166        Key::serialize_into(&val, &mut buffer).unwrap();
167        let new_val = <String<45> as Key>::deserialize_from(&buffer).unwrap();
168
169        assert_eq!((val, 14), new_val);
170    }
171
172    #[test]
173    fn value_serde_heapless_vec() {
174        let mut buffer = [0; 12];
175
176        let val = Vec::<u8, 12>::from_iter([0xAA; 12]);
177        Value::serialize_into(&val, &mut buffer).unwrap();
178        let (new_val, size) = <Vec<u8, 12> as Value>::deserialize_from(&buffer).unwrap();
179
180        assert_eq!(val, new_val);
181        assert_eq!(size, 12);
182    }
183
184    #[test]
185    fn value_serde_heapless_string() {
186        let mut buffer = [0; 12];
187
188        let val = String::<45>::from_str("Hello world!").unwrap();
189        Value::serialize_into(&val, &mut buffer).unwrap();
190        let (new_val, size) = <String<45> as Value>::deserialize_from(&buffer).unwrap();
191
192        assert_eq!(val, new_val);
193        assert_eq!(size, 12);
194    }
195}
sequential_storage/heapless_impl.rs

sequential_storage/
heapless_impl.rs
