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 buffer.len() < self.len() + 2 {
12            return Err(SerializationError::BufferTooSmall);
13        }
14
15        if self.len() > u16::MAX as usize {
16            return Err(SerializationError::InvalidData);
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, SerializationError>
64    where
65        Self: Sized,
66    {
67        Vec::try_from(buffer).map_err(|_| SerializationError::InvalidFormat)
68    }
69}
70
71// heapless::String
72
73impl<const CAP: usize> Key for String<CAP> {
74    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
75        if buffer.len() < self.len() + 2 {
76            return Err(SerializationError::InvalidFormat);
77        }
78
79        if self.len() > u16::MAX as usize {
80            return Err(SerializationError::InvalidData);
81        }
82
83        buffer[..2].copy_from_slice(&(self.len() as u16).to_le_bytes());
84        buffer[2..][..self.len()].copy_from_slice(self.as_bytes());
85
86        Ok(self.len() + 2)
87    }
88
89    fn deserialize_from(buffer: &[u8]) -> Result<(Self, usize), SerializationError> {
90        let total_len = Self::get_len(buffer)?;
91
92        if buffer.len() < total_len {
93            return Err(SerializationError::BufferTooSmall);
94        }
95
96        let data_len = total_len - 2;
97
98        let mut output = String::new();
99        output
100            .push_str(
101                core::str::from_utf8(&buffer[2..][..data_len])
102                    .map_err(|_| SerializationError::InvalidFormat)?,
103            )
104            .map_err(|_| SerializationError::InvalidFormat)?;
105
106        Ok((output, total_len))
107    }
108
109    fn get_len(buffer: &[u8]) -> Result<usize, SerializationError> {
110        if buffer.len() < 2 {
111            return Err(SerializationError::BufferTooSmall);
112        }
113
114        let len = u16::from_le_bytes(buffer[..2].try_into().unwrap());
115
116        Ok(len as usize + 2)
117    }
118}
119
120impl<'a, const CAP: usize> Value<'a> for String<CAP> {
121    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
122        if buffer.len() < self.len() {
123            return Err(SerializationError::BufferTooSmall);
124        }
125
126        buffer[..self.len()].copy_from_slice(self.as_bytes());
127        Ok(self.len())
128    }
129
130    fn deserialize_from(buffer: &'a [u8]) -> Result<Self, SerializationError>
131    where
132        Self: Sized,
133    {
134        let output = String::from_str(
135            core::str::from_utf8(buffer).map_err(|_| SerializationError::InvalidFormat)?,
136        )
137        .map_err(|_| SerializationError::BufferTooSmall)?;
138
139        Ok(output)
140    }
141}
142
143#[cfg(test)]
144mod tests {
145    use core::str::FromStr;
146
147    use super::*;
148
149    #[test]
150    fn key_serde_heapless_vec() {
151        let mut buffer = [0; 128];
152
153        let val = Vec::<u8, 12>::from_iter([0xAA; 12]);
154        Key::serialize_into(&val, &mut buffer).unwrap();
155        let new_val = <Vec<u8, 12> as Key>::deserialize_from(&buffer).unwrap();
156
157        assert_eq!((val, 14), new_val);
158    }
159
160    #[test]
161    fn key_serde_heapless_string() {
162        let mut buffer = [0; 128];
163
164        let val = String::<45>::from_str("Hello world!").unwrap();
165        Key::serialize_into(&val, &mut buffer).unwrap();
166        let new_val = <String<45> as Key>::deserialize_from(&buffer).unwrap();
167
168        assert_eq!((val, 14), new_val);
169    }
170
171    #[test]
172    fn value_serde_heapless_vec() {
173        let mut buffer = [0; 12];
174
175        let val = Vec::<u8, 12>::from_iter([0xAA; 12]);
176        Value::serialize_into(&val, &mut buffer).unwrap();
177        let new_val = <Vec<u8, 12> as Value>::deserialize_from(&buffer).unwrap();
178
179        assert_eq!(val, new_val);
180    }
181
182    #[test]
183    fn value_serde_heapless_string() {
184        let mut buffer = [0; 12];
185
186        let val = String::<45>::from_str("Hello world!").unwrap();
187        Value::serialize_into(&val, &mut buffer).unwrap();
188        let new_val = <String<45> as Value>::deserialize_from(&buffer).unwrap();
189
190        assert_eq!(val, new_val);
191    }
192}
sequential_storage/heapless_impl.rs

sequential_storage/
heapless_impl.rs
