Implement serde as bytes for GenericArray<u8, N>

Author: nickray

PR.txt

@@ -0,0 +1,14 @@
+What's this?
+- new type `ByteBuf` that is a `Vec<u8, N>` with different / more efficient serde (as bytes). Inherits most functionality via its Deref to Vec.
+- some additional methods (into_vec, to_vec, try_to_vec,... from_writer, insert, remove, insert_slice_at, resize_to_capacity, inherent as_slice/as_mut_slice, etc.)
+- wrapper types allowing one to perform efficient serde on slices and byte vectors without using the ByteBuf type
+- addition of some uDebug implementations, dependency on `ufmt` instead of `ufmt-write` (otherwise there would be too many cargo features)
+
+This is a melange of existing `heapless`, `serde_bytes` and `std` code. I've found it very useful to have a standard "extendable bytes" type (merging [u8; N] and Vec<u8, N>), so I believe this is also of independent interest as shared type.
+
+I left out the `Bytes` type from `serde_bytes` as I've found no use for it; could be added.
+
+I would prefer using the name Bytes for ByteBuf, but I think that would be confusing to anyone used to the `serde_bytes` ByteBuf.
+
+MSRV: `insert_slice_at` would profit from `copy_within`, which stabilised in 1.37 while the MSRV is 1.36. I assume we don't want to bump the MSRV.
+

src/serde_as_bytes/de.rs

@@ -1,6 +1,6 @@
 use core::{fmt, marker};
 
-use generic_array::ArrayLength;
+use generic_array::{ArrayLength, GenericArray};
 use serde::Deserializer;
 use serde::de::{Error, Visitor};
 
@@ -24,6 +24,41 @@ impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
     }
 }
 
+impl<'de, N> Deserialize<'de> for GenericArray<u8, N>
+where
+    N: ArrayLength<u8>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct ValueVisitor<'de, N>(marker::PhantomData<(&'de (), N)>);
+
+        impl<'de, N> serde::de::Visitor<'de> for ValueVisitor<'de, N>
+        where
+            N: ArrayLength<u8>,
+        {
+            type Value = GenericArray<u8, N>;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("a sequence")
+            }
+
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                if v.len() > N::to_usize() {
+                    return Err(E::invalid_length(v.len(), &self))?;
+                }
+                Ok(GenericArray::clone_from_slice(v))
+            }
+        }
+
+        deserializer.deserialize_bytes(ValueVisitor(marker::PhantomData))
+    }
+}
+
 impl<'de, N> Deserialize<'de> for Vec<u8, N>
 where
     N: ArrayLength<u8>,

src/serde_as_bytes/ser.rs

@@ -18,6 +18,18 @@ impl Serialize for [u8] {
     }
 }
 
+impl<N> Serialize for generic_array::GenericArray<u8, N>
+where
+    N: ArrayLength<u8>
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_bytes(self.as_slice())
+    }
+}
+
 impl<N> Serialize for crate::Vec<u8, N>
 where
     N: ArrayLength<u8>