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::de::{self, SeqAccess, Visitor};
8use serde::{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 = GenericArray::uninit();
67            let mut builder = IntrusiveArrayBuilder::new(&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({
87                    builder.finish();
88                    IntrusiveArrayBuilder::array_assume_init(dst)
89                });
90            }
91
92            Err(de::Error::invalid_length(*position, &self))
93        }
94    }
95}
96
97impl<'de, T, N: ArrayLength> Deserialize<'de> for GenericArray<T, N>
98where
99    T: Deserialize<'de>,
100{
101    fn deserialize<D>(deserializer: D) -> Result<GenericArray<T, N>, D::Error>
102    where
103        D: Deserializer<'de>,
104    {
105        let visitor = GAVisitor {
106            _t: PhantomData,
107            _n: PhantomData,
108        };
109        deserializer.deserialize_tuple(N::USIZE, visitor)
110    }
111}
112
113#[cfg(test)]
114mod tests {
115    use super::*;
116
117    #[test]
118    fn test_serialize() {
119        let array = GenericArray::<u8, typenum::U2>::default();
120        let serialized = bincode::serialize(&array);
121        assert!(serialized.is_ok());
122    }
123
124    #[test]
125    fn test_deserialize() {
126        let mut array = GenericArray::<u8, typenum::U2>::default();
127        array[0] = 1;
128        array[1] = 2;
129        let serialized = bincode::serialize(&array).unwrap();
130        let deserialized = bincode::deserialize::<GenericArray<u8, typenum::U2>>(&serialized);
131        assert!(deserialized.is_ok());
132        let array = deserialized.unwrap();
133        assert_eq!(array[0], 1);
134        assert_eq!(array[1], 2);
135    }
136
137    #[test]
138    fn test_serialized_size() {
139        let array = GenericArray::<u8, typenum::U1>::default();
140        let size = bincode::serialized_size(&array).unwrap();
141        assert_eq!(size, 1);
142    }
143
144    #[test]
145    #[should_panic]
146    fn test_too_many() {
147        let serialized = "[1, 2, 3, 4, 5]";
148        let _ = serde_json::from_str::<GenericArray<u8, typenum::U4>>(serialized).unwrap();
149    }
150}
generic_array/impl_serde.rs

generic_array/
impl_serde.rs
