sequential_storage/
alloc_impl.rs

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

sequential_storage/
alloc_impl.rs
