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