sequential_storage/
heapless_09_impl.rs

1use core::str::FromStr;
2
3use heapless_09::{String, Vec};
4
5use crate::map::{Key, SerializationError, Value};
6
7// heapless:: Vec
8
9impl<LenType: heapless_09::LenType, const CAP: usize> Key for Vec<u8, CAP, LenType> {
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        if buffer.len() < self.len() + 2 {
15            return Err(SerializationError::BufferTooSmall);
16        }
17
18        buffer[..2].copy_from_slice(&(self.len() as u16).to_le_bytes());
19        buffer[2..][..self.len()].copy_from_slice(self);
20
21        Ok(self.len() + 2)
22    }
23
24    fn deserialize_from(buffer: &[u8]) -> Result<(Self, usize), SerializationError> {
25        let total_len = Self::get_len(buffer)?;
26
27        if buffer.len() < total_len {
28            return Err(SerializationError::BufferTooSmall);
29        }
30
31        let data_len = total_len - 2;
32
33        let mut output = Vec::new();
34        output
35            .extend_from_slice(&buffer[2..][..data_len])
36            .map_err(|_| SerializationError::InvalidFormat)?;
37
38        Ok((output, total_len))
39    }
40
41    fn get_len(buffer: &[u8]) -> Result<usize, SerializationError> {
42        if buffer.len() < 2 {
43            return Err(SerializationError::BufferTooSmall);
44        }
45
46        let len = u16::from_le_bytes(buffer[..2].try_into().unwrap());
47
48        Ok(len as usize + 2)
49    }
50}
51
52impl<'a, LenType: heapless_09::LenType, const CAP: usize> Value<'a> for Vec<u8, CAP, LenType> {
53    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
54        if buffer.len() < self.len() {
55            return Err(SerializationError::BufferTooSmall);
56        }
57
58        buffer[..self.len()].copy_from_slice(self.as_slice());
59        Ok(self.len())
60    }
61
62    fn deserialize_from(buffer: &'a [u8]) -> Result<(Self, usize), SerializationError>
63    where
64        Self: Sized,
65    {
66        let value = Vec::try_from(buffer).map_err(|_| SerializationError::InvalidFormat)?;
67        Ok((value, buffer.len()))
68    }
69}
70
71// heapless::String
72
73impl<LenType: heapless_09::LenType, const CAP: usize> Key for String<CAP, LenType> {
74    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
75        if self.len() > u16::MAX as usize {
76            return Err(SerializationError::InvalidData);
77        }
78
79        if buffer.len() < self.len() + 2 {
80            return Err(SerializationError::InvalidFormat);
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, LenType: heapless_09::LenType, const CAP: usize> Value<'a> for String<CAP, LenType> {
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, usize), 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, buffer.len()))
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, size) = <Vec<u8, 12> as Value>::deserialize_from(&buffer).unwrap();
178
179        assert_eq!(val, new_val);
180        assert_eq!(size, 12);
181    }
182
183    #[test]
184    fn value_serde_heapless_string() {
185        let mut buffer = [0; 12];
186
187        let val = String::<45>::from_str("Hello world!").unwrap();
188        Value::serialize_into(&val, &mut buffer).unwrap();
189        let (new_val, size) = <String<45> as Value>::deserialize_from(&buffer).unwrap();
190
191        assert_eq!(val, new_val);
192        assert_eq!(size, 12);
193    }
194}
sequential_storage/heapless_09_impl.rs

sequential_storage/
heapless_09_impl.rs
