commonware_codec/types/
vec.rs

1//! Codec implementation for [`Vec<T>`].
2//!
3//! For portability and consistency between architectures,
4//! the length of the vector must fit within a [u32].
5
6use crate::{EncodeSize, Error, RangeCfg, Read, Write};
7#[cfg(not(feature = "std"))]
8use alloc::vec::Vec;
9use bytes::{Buf, BufMut};
10
11impl<T: Write> Write for Vec<T> {
12    #[inline]
13    fn write(&self, buf: &mut impl BufMut) {
14        self.as_slice().write(buf)
15    }
16}
17
18impl<T: EncodeSize> EncodeSize for Vec<T> {
19    #[inline]
20    fn encode_size(&self) -> usize {
21        self.as_slice().encode_size()
22    }
23}
24
25impl<T: Write> Write for &[T] {
26    #[inline]
27    fn write(&self, buf: &mut impl BufMut) {
28        self.len().write(buf);
29        for item in self.iter() {
30            item.write(buf);
31        }
32    }
33}
34
35impl<T: EncodeSize> EncodeSize for &[T] {
36    #[inline]
37    fn encode_size(&self) -> usize {
38        self.len().encode_size() + self.iter().map(EncodeSize::encode_size).sum::<usize>()
39    }
40}
41
42impl<T: Read> Read for Vec<T> {
43    type Cfg = (RangeCfg, T::Cfg);
44
45    #[inline]
46    fn read_cfg(buf: &mut impl Buf, (range, cfg): &Self::Cfg) -> Result<Self, Error> {
47        let len = usize::read_cfg(buf, range)?;
48        let mut vec = Vec::with_capacity(len);
49        for _ in 0..len {
50            vec.push(T::read_cfg(buf, cfg)?);
51        }
52        Ok(vec)
53    }
54}
55
56#[cfg(test)]
57mod tests {
58    use super::*;
59    use crate::{DecodeRangeExt, Encode};
60    #[cfg(not(feature = "std"))]
61    use alloc::vec;
62
63    #[test]
64    fn test_vec() {
65        let vec_values = [vec![], vec![1u8], vec![1u8, 2u8, 3u8]];
66        for value in vec_values {
67            let encoded = value.encode();
68            assert_eq!(encoded.len(), value.len() * core::mem::size_of::<u8>() + 1);
69
70            // Valid decoding
71            let len = value.len();
72            let decoded = Vec::<u8>::decode_range(encoded, len..=len).unwrap();
73            assert_eq!(value, decoded);
74
75            // Failure for too long
76            assert!(matches!(
77                Vec::<u8>::decode_range(value.encode(), 0..len),
78                Err(Error::InvalidLength(_))
79            ));
80
81            // Failure for too short
82            assert!(matches!(
83                Vec::<u8>::decode_range(value.encode(), len + 1..),
84                Err(Error::InvalidLength(_))
85            ));
86        }
87    }
88
89    #[test]
90    fn test_slice() {
91        let slice_values: [&[u8]; 3] =
92            [[].as_slice(), [1u8].as_slice(), [1u8, 2u8, 3u8].as_slice()];
93        for value in slice_values {
94            let encoded = value.encode();
95            assert_eq!(encoded.len(), core::mem::size_of_val(value) + 1);
96
97            // Valid decoding
98            let len = value.len();
99            let decoded = Vec::<u8>::decode_range(encoded, len..=len).unwrap();
100            assert_eq!(value, decoded);
101
102            // Failure for too long
103            assert!(matches!(
104                Vec::<u8>::decode_range(value.encode(), 0..len),
105                Err(Error::InvalidLength(_))
106            ));
107
108            // Failure for too short
109            assert!(matches!(
110                Vec::<u8>::decode_range(value.encode(), len + 1..),
111                Err(Error::InvalidLength(_))
112            ));
113        }
114    }
115
116    #[test]
117    fn test_conformity() {
118        assert_eq!(Vec::<u8>::new().encode(), &[0x00][..]);
119        assert_eq!(
120            vec![0x01u8, 0x02u8, 0x03u8].encode(),
121            &[0x03, 0x01, 0x02, 0x03][..]
122        );
123
124        let v_u16: Vec<u16> = vec![0x1234, 0xABCD];
125        assert_eq!(v_u16.encode(), &[0x02, 0x12, 0x34, 0xAB, 0xCD][..]);
126
127        let v_bool: Vec<bool> = vec![true, false, true];
128        assert_eq!(v_bool.encode(), &[0x03, 0x01, 0x00, 0x01][..]);
129
130        let v_empty_u32: Vec<u32> = Vec::new();
131        assert_eq!(v_empty_u32.encode(), &[0x00][..]);
132
133        // Test with a length that requires a multi-byte varint
134        let v_long_u8: Vec<u8> = vec![0xCC; 200]; // 200 = 0xC8 = 0x80 + 0x48 -> 0xC8 0x01
135        let mut expected_long_u8 = vec![0xC8, 0x01];
136        expected_long_u8.extend_from_slice(&[0xCC; 200]);
137        assert_eq!(v_long_u8.encode(), expected_long_u8.as_slice());
138    }
139}
commonware_codec/types/vec.rs

commonware_codec/types/
vec.rs
