[codec] Impl Encode for &[T: Encode] (#1513)

Author: clabby

codec/src/types/vec.rs

@@ -9,16 +9,30 @@ use alloc::vec::Vec;
 use bytes::{Buf, BufMut};
 
 impl<T: Write> Write for Vec<T> {
+    #[inline]
+    fn write(&self, buf: &mut impl BufMut) {
+        self.as_slice().write(buf)
+    }
+}
+
+impl<T: EncodeSize> EncodeSize for Vec<T> {
+    #[inline]
+    fn encode_size(&self) -> usize {
+        self.as_slice().encode_size()
+    }
+}
+
+impl<T: Write> Write for &[T] {
     #[inline]
     fn write(&self, buf: &mut impl BufMut) {
         self.len().write(buf);
-        for item in self {
+        for item in self.iter() {
             item.write(buf);
         }
     }
 }
 
-impl<T: EncodeSize> EncodeSize for Vec<T> {
+impl<T: EncodeSize> EncodeSize for &[T] {
     #[inline]
     fn encode_size(&self) -> usize {
         self.len().encode_size() + self.iter().map(EncodeSize::encode_size).sum::<usize>()
@@ -72,6 +86,33 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_slice() {
+        let slice_values: [&[u8]; 3] =
+            [[].as_slice(), [1u8].as_slice(), [1u8, 2u8, 3u8].as_slice()];
+        for value in slice_values {
+            let encoded = value.encode();
+            assert_eq!(encoded.len(), core::mem::size_of_val(value) + 1);
+
+            // Valid decoding
+            let len = value.len();
+            let decoded = Vec::<u8>::decode_range(encoded, len..=len).unwrap();
+            assert_eq!(value, decoded);
+
+            // Failure for too long
+            assert!(matches!(
+                Vec::<u8>::decode_range(value.encode(), 0..len),
+                Err(Error::InvalidLength(_))
+            ));
+
+            // Failure for too short
+            assert!(matches!(
+                Vec::<u8>::decode_range(value.encode(), len + 1..),
+                Err(Error::InvalidLength(_))
+            ));
+        }
+    }
+
     #[test]
     fn test_conformity() {
         assert_eq!(Vec::<u8>::new().encode(), &[0x00][..]);