generic_array/
impl_serde.rs

1//! Serde serialization/deserialization implementation
2
3use crate::{ArrayLength, GenericArray, IntrusiveArrayBuilder};
4use core::fmt;
5use core::marker::PhantomData;
6
7use serde_core::de::{self, SeqAccess, Visitor};
8use serde_core::{ser::SerializeTuple, Deserialize, Deserializer, Serialize, Serializer};
9
10impl<T, N: ArrayLength> Serialize for GenericArray<T, N>
11where
12    T: Serialize,
13{
14    #[inline]
15    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
16    where
17        S: Serializer,
18    {
19        let mut tup = serializer.serialize_tuple(N::USIZE)?;
20        for el in self {
21            tup.serialize_element(el)?;
22        }
23
24        tup.end()
25    }
26}
27
28struct GAVisitor<T, N> {
29    _t: PhantomData<T>,
30    _n: PhantomData<N>,
31}
32
33// to avoid extra computation when testing for extra elements in the sequence
34struct Dummy;
35impl<'de> Deserialize<'de> for Dummy {
36    fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
37    where
38        D: Deserializer<'de>,
39    {
40        Ok(Dummy)
41    }
42}
43
44impl<'de, T, N: ArrayLength> Visitor<'de> for GAVisitor<T, N>
45where
46    T: Deserialize<'de>,
47{
48    type Value = GenericArray<T, N>;
49
50    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
51        write!(formatter, "struct GenericArray<T, U{}>", N::USIZE)
52    }
53
54    fn visit_seq<A>(self, mut seq: A) -> Result<GenericArray<T, N>, A::Error>
55    where
56        A: SeqAccess<'de>,
57    {
58        match seq.size_hint() {
59            Some(n) if n != N::USIZE => {
60                return Err(de::Error::invalid_length(n, &self));
61            }
62            _ => {}
63        }
64
65        unsafe {
66            let mut dst = core::mem::MaybeUninit::<GenericArray<T, N>>::uninit();
67            let mut builder = IntrusiveArrayBuilder::new_alt(&mut dst);
68
69            let (build_iter, position) = builder.iter_position();
70
71            for dst in build_iter {
72                match seq.next_element()? {
73                    Some(el) => {
74                        dst.write(el);
75                        *position += 1;
76                    }
77                    None => break,
78                }
79            }
80
81            if *position == N::USIZE {
82                if seq.size_hint() != Some(0) && seq.next_element::<Dummy>()?.is_some() {
83                    return Err(de::Error::invalid_length(*position + 1, &self));
84                }
85
86                return Ok(builder.finish_and_assume_init());
87            }
88
89            Err(de::Error::invalid_length(*position, &self))
90        }
91    }
92}
93
94impl<'de, T, N: ArrayLength> Deserialize<'de> for GenericArray<T, N>
95where
96    T: Deserialize<'de>,
97{
98    fn deserialize<D>(deserializer: D) -> Result<GenericArray<T, N>, D::Error>
99    where
100        D: Deserializer<'de>,
101    {
102        let visitor = GAVisitor {
103            _t: PhantomData,
104            _n: PhantomData,
105        };
106        deserializer.deserialize_tuple(N::USIZE, visitor)
107    }
108}
109
110#[cfg(test)]
111mod tests {
112    use super::*;
113
114    #[test]
115    fn test_serialize() {
116        let array = GenericArray::<u8, typenum::U2>::default();
117        let serialized = bincode::serialize(&array);
118        assert!(serialized.is_ok());
119    }
120
121    #[test]
122    fn test_deserialize() {
123        let mut array = GenericArray::<u8, typenum::U2>::default();
124        array[0] = 1;
125        array[1] = 2;
126        let serialized = bincode::serialize(&array).unwrap();
127        let deserialized = bincode::deserialize::<GenericArray<u8, typenum::U2>>(&serialized);
128        assert!(deserialized.is_ok());
129        let array = deserialized.unwrap();
130        assert_eq!(array[0], 1);
131        assert_eq!(array[1], 2);
132    }
133
134    #[test]
135    fn test_serialized_size() {
136        let array = GenericArray::<u8, typenum::U1>::default();
137        let size = bincode::serialized_size(&array).unwrap();
138        assert_eq!(size, 1);
139    }
140
141    #[test]
142    #[should_panic]
143    fn test_too_many() {
144        let serialized = "[1, 2, 3, 4, 5]";
145        let _ = serde_json::from_str::<GenericArray<u8, typenum::U4>>(serialized).unwrap();
146    }
147}
generic_array/impl_serde.rs

generic_array/
impl_serde.rs
