sequential_storage/
arrayvec_impl.rs

1use arrayvec::{ArrayString, ArrayVec};
2
3use crate::map::{Key, SerializationError};
4
5impl<const CAP: usize> Key for ArrayVec<u8, CAP> {
6    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
7        if buffer.len() < self.len() + 2 {
8            return Err(SerializationError::BufferTooSmall);
9        }
10
11        if self.len() > u16::MAX as usize {
12            return Err(SerializationError::InvalidData);
13        }
14
15        buffer[..2].copy_from_slice(&(self.len() as u16).to_le_bytes());
16        buffer[2..][..self.len()].copy_from_slice(self);
17
18        Ok(self.len() + 2)
19    }
20
21    fn deserialize_from(buffer: &[u8]) -> Result<(Self, usize), SerializationError> {
22        let total_len = Self::get_len(buffer)?;
23
24        if buffer.len() < total_len {
25            return Err(SerializationError::BufferTooSmall);
26        }
27
28        let data_len = total_len - 2;
29
30        let mut output = ArrayVec::new();
31        output
32            .try_extend_from_slice(&buffer[2..][..data_len])
33            .map_err(|_| SerializationError::InvalidFormat)?;
34
35        Ok((output, total_len))
36    }
37
38    fn get_len(buffer: &[u8]) -> Result<usize, SerializationError> {
39        if buffer.len() < 2 {
40            return Err(SerializationError::BufferTooSmall);
41        }
42
43        let len = u16::from_le_bytes(buffer[..2].try_into().unwrap());
44
45        Ok(len as usize + 2)
46    }
47}
48
49impl<const CAP: usize> Key for ArrayString<CAP> {
50    fn serialize_into(&self, buffer: &mut [u8]) -> Result<usize, SerializationError> {
51        if buffer.len() < self.len() + 2 {
52            return Err(SerializationError::BufferTooSmall);
53        }
54
55        if self.len() > u16::MAX as usize {
56            return Err(SerializationError::InvalidData);
57        }
58
59        buffer[..2].copy_from_slice(&(self.len() as u16).to_le_bytes());
60        buffer[2..][..self.len()].copy_from_slice(self.as_bytes());
61
62        Ok(self.len() + 2)
63    }
64
65    fn deserialize_from(buffer: &[u8]) -> Result<(Self, usize), SerializationError> {
66        let total_len = Self::get_len(buffer)?;
67
68        if buffer.len() < total_len {
69            return Err(SerializationError::BufferTooSmall);
70        }
71
72        let data_len = total_len - 2;
73
74        let mut output = ArrayString::new();
75        output
76            .try_push_str(
77                core::str::from_utf8(&buffer[2..][..data_len])
78                    .map_err(|_| SerializationError::InvalidFormat)?,
79            )
80            .map_err(|_| SerializationError::InvalidFormat)?;
81
82        Ok((output, total_len))
83    }
84
85    fn get_len(buffer: &[u8]) -> Result<usize, SerializationError> {
86        if buffer.len() < 2 {
87            return Err(SerializationError::BufferTooSmall);
88        }
89
90        let len = u16::from_le_bytes(buffer[..2].try_into().unwrap());
91
92        Ok(len as usize + 2)
93    }
94}
95
96#[cfg(test)]
97mod tests {
98    use core::str::FromStr;
99
100    use super::*;
101
102    #[test]
103    fn serde_arrayvec() {
104        let mut buffer = [0; 128];
105
106        let val = ArrayVec::<u8, 12>::from_iter([0xAA; 12]);
107        val.serialize_into(&mut buffer).unwrap();
108        let new_val = ArrayVec::<u8, 12>::deserialize_from(&buffer).unwrap();
109
110        assert_eq!((val, 14), new_val);
111    }
112
113    #[test]
114    fn serde_arraystring() {
115        let mut buffer = [0; 128];
116
117        let val = ArrayString::<45>::from_str("Hello world!").unwrap();
118        val.serialize_into(&mut buffer).unwrap();
119        let new_val = ArrayString::<45>::deserialize_from(&buffer).unwrap();
120
121        assert_eq!((val, 14), new_val);
122    }
123}
sequential_storage/arrayvec_impl.rs

sequential_storage/
arrayvec_impl.rs
