Implement serde_with::SerializeAs and serde_with ::DeserializeAs for ArrayVec

Cargo.toml

@@ -19,6 +19,11 @@ version = "1.0"
 optional = true
 default-features = false
 
+[dependencies.serde_with]
+version = "3"
+optional = true
+default-features = false
+
 [dependencies.zeroize]
 version = "1.4"
 optional = true
@@ -30,6 +35,7 @@ version = "1.0"
 [dev-dependencies]
 matches = { version = "0.1" }
 bencher = "0.1.4"
+serde_with = { version = "3" }
 
 [[bench]]
 name = "extend"
@@ -42,6 +48,7 @@ harness = false
 [features]
 default = ["std"]
 std = []
+serde = ["dep:serde", "dep:serde_with"]
 
 [profile.bench]
 debug = true

src/arrayvec.rs

@@ -17,8 +17,11 @@ use std::io;
 use std::mem::ManuallyDrop;
 use std::mem::MaybeUninit;
 
-#[cfg(feature="serde")]
-use serde::{Serialize, Deserialize, Serializer, Deserializer};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+#[cfg(feature = "serde")]
+use serde_with::{de::DeserializeAsWrap, ser::SerializeAsWrap, DeserializeAs, SerializeAs};
 
 use crate::LenUint;
 use crate::errors::CapacityError;
@@ -1262,7 +1265,18 @@ impl<T: Serialize, const CAP: usize> Serialize for ArrayVec<T, CAP> {
     }
 }
 
-#[cfg(feature="serde")]
+#[cfg(feature = "serde")]
+/// Requires crate feature `"serde"`
+impl<T, U: SerializeAs<T>, const CAP: usize> SerializeAs<ArrayVec<T, CAP>> for ArrayVec<U, CAP> {
+    fn serialize_as<S>(source: &ArrayVec<T, CAP>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.collect_seq(source.iter().map(SerializeAsWrap::<T, U>::new))
+    }
+}
+
+#[cfg(feature = "serde")]
 /// Requires crate feature `"serde"`
 impl<'de, T: Deserialize<'de>, const CAP: usize> Deserialize<'de> for ArrayVec<T, CAP> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -1286,7 +1300,7 @@ impl<'de, T: Deserialize<'de>, const CAP: usize> Deserialize<'de> for ArrayVec<T
                 let mut values = ArrayVec::<T, CAP>::new();
 
                 while let Some(value) = seq.next_element()? {
-                    if let Err(_) = values.try_push(value) {
+                    if values.try_push(value).is_err() {
                         return Err(SA::Error::invalid_length(CAP + 1, &self));
                     }
                 }
@@ -1298,3 +1312,51 @@ impl<'de, T: Deserialize<'de>, const CAP: usize> Deserialize<'de> for ArrayVec<T
         deserializer.deserialize_seq(ArrayVecVisitor::<T, CAP>(PhantomData))
     }
 }
+
+#[cfg(feature = "serde")]
+/// Requires crate feature `"serde"`
+impl<'de, T, U, const CAP: usize> DeserializeAs<'de, ArrayVec<T, CAP>> for ArrayVec<U, CAP>
+where
+    U: DeserializeAs<'de, T>,
+{
+    fn deserialize_as<D>(deserializer: D) -> Result<ArrayVec<T, CAP>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        use serde::de::{Error, SeqAccess, Visitor};
+        use std::marker::PhantomData;
+
+        struct ArrayVecVisitor<'de, T, U, const CAP: usize>(PhantomData<(&'de (), U, [T; CAP])>);
+
+        impl<'de, T, U, const CAP: usize> Visitor<'de> for ArrayVecVisitor<'de, T, U, CAP>
+        where
+            U: DeserializeAs<'de, T>,
+        {
+            type Value = ArrayVec<T, CAP>;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                write!(formatter, "an array with no more than {} items", CAP)
+            }
+
+            fn visit_seq<SA>(self, mut seq: SA) -> Result<Self::Value, SA::Error>
+            where
+                SA: SeqAccess<'de>,
+            {
+                let mut values = ArrayVec::<T, CAP>::new();
+
+                while let Some(value) = seq
+                    .next_element()?
+                    .map(|v: DeserializeAsWrap<T, U>| v.into_inner())
+                {
+                    if let Err(_) = values.try_push(value) {
+                        return Err(SA::Error::invalid_length(CAP + 1, &self));
+                    }
+                }
+
+                Ok(values)
+            }
+        }
+
+        deserializer.deserialize_seq(ArrayVecVisitor::<T, U, CAP>(PhantomData))
+    }
+}

tests/serde.rs

@@ -5,7 +5,8 @@ extern crate serde_test;
 mod array_vec {
     use arrayvec::ArrayVec;
 
-    use serde_test::{Token, assert_tokens, assert_de_tokens_error};
+    use serde_test::{assert_de_tokens_error, assert_tokens, Token};
+    use serde_with::{serde_as, DisplayFromStr};
 
     #[test]
     fn test_ser_de_empty() {
@@ -36,12 +37,44 @@ mod array_vec {
 
     #[test]
     fn test_de_too_large() {
-        assert_de_tokens_error::<ArrayVec<u32, 2>>(&[
-            Token::Seq { len: Some(3) },
-            Token::U32(13),
-            Token::U32(42),
-            Token::U32(68),
-        ], "invalid length 3, expected an array with no more than 2 items");
+        assert_de_tokens_error::<ArrayVec<u32, 2>>(
+            &[
+                Token::Seq { len: Some(3) },
+                Token::U32(13),
+                Token::U32(42),
+                Token::U32(68),
+            ],
+            "invalid length 3, expected an array with no more than 2 items",
+        );
+    }
+
+    #[serde_as]
+    #[derive(serde::Serialize, serde::Deserialize, PartialEq, Eq, Debug)]
+    struct SerdeAs {
+        #[serde_as(as = "ArrayVec<DisplayFromStr, 3>")]
+        x: ArrayVec<u32, 3>
+    }
+
+    #[test]
+    fn test_ser_de_as() {
+        let mut serde_as = SerdeAs {x: ArrayVec::<u32, 3>::new()};
+        serde_as.x.push(20);
+        serde_as.x.push(55);
+        serde_as.x.push(123);
+
+        assert_tokens(
+            &serde_as,
+            &[
+                Token::Struct { name: "SerdeAs", len: 1 },
+                Token::Str("x"),
+                Token::Seq { len: Some(3) },
+                Token::Str("20"),
+                Token::Str("55"),
+                Token::Str("123"),
+                Token::SeqEnd,
+                Token::StructEnd,
+            ],
+        );
     }
 }