1 //! Serde serialization/deserialization implementation
2 
3 use core::fmt;
4 use core::marker::PhantomData;
5 use serde::de::{self, SeqAccess, Visitor};
6 use serde::{ser::SerializeTuple, Deserialize, Deserializer, Serialize, Serializer};
7 use {ArrayLength, GenericArray};
8 
9 impl<T, N> Serialize for GenericArray<T, N>
10 where
11     T: Serialize,
12     N: ArrayLength<T>,
13 {
14     #[inline]
serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,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::to_usize())?;
20         for el in self {
21             tup.serialize_element(el)?;
22         }
23 
24         tup.end()
25     }
26 }
27 
28 struct GAVisitor<T, N> {
29     _t: PhantomData<T>,
30     _n: PhantomData<N>,
31 }
32 
33 impl<'de, T, N> Visitor<'de> for GAVisitor<T, N>
34 where
35     T: Deserialize<'de> + Default,
36     N: ArrayLength<T>,
37 {
38     type Value = GenericArray<T, N>;
39 
expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result40     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
41         formatter.write_str("struct GenericArray")
42     }
43 
visit_seq<A>(self, mut seq: A) -> Result<GenericArray<T, N>, A::Error> where A: SeqAccess<'de>,44     fn visit_seq<A>(self, mut seq: A) -> Result<GenericArray<T, N>, A::Error>
45     where
46         A: SeqAccess<'de>,
47     {
48         let mut result = GenericArray::default();
49         for i in 0..N::to_usize() {
50             result[i] = seq
51                 .next_element()?
52                 .ok_or_else(|| de::Error::invalid_length(i, &self))?;
53         }
54         Ok(result)
55     }
56 }
57 
58 impl<'de, T, N> Deserialize<'de> for GenericArray<T, N>
59 where
60     T: Deserialize<'de> + Default,
61     N: ArrayLength<T>,
62 {
deserialize<D>(deserializer: D) -> Result<GenericArray<T, N>, D::Error> where D: Deserializer<'de>,63     fn deserialize<D>(deserializer: D) -> Result<GenericArray<T, N>, D::Error>
64     where
65         D: Deserializer<'de>,
66     {
67         let visitor = GAVisitor {
68             _t: PhantomData,
69             _n: PhantomData,
70         };
71         deserializer.deserialize_tuple(N::to_usize(), visitor)
72     }
73 }
74 
75 #[cfg(test)]
76 mod tests {
77     use super::*;
78     use bincode;
79     use typenum;
80 
81     #[test]
test_serialize()82     fn test_serialize() {
83         let array = GenericArray::<u8, typenum::U2>::default();
84         let serialized = bincode::serialize(&array);
85         assert!(serialized.is_ok());
86     }
87 
88     #[test]
test_deserialize()89     fn test_deserialize() {
90         let mut array = GenericArray::<u8, typenum::U2>::default();
91         array[0] = 1;
92         array[1] = 2;
93         let serialized = bincode::serialize(&array).unwrap();
94         let deserialized = bincode::deserialize::<GenericArray<u8, typenum::U2>>(&array);
95         assert!(deserialized.is_ok());
96         let array = deserialized.unwrap();
97         assert_eq!(array[0], 1);
98         assert_eq!(array[1], 2);
99     }
100 
101     #[test]
test_serialized_size()102     fn test_serialized_size() {
103         let array = GenericArray::<u8, typenum::U1>::default();
104         let size = bincode::serialized_size(&array).unwrap();
105         assert_eq!(size, 1);
106     }
107 
108 }
109