vendor/generic-array-0.12.4/src/impl_serde.rs

   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]
  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
  40     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  41         formatter.write_str("struct GenericArray")
  42     }
  43
  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 {
  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]
  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]
  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]
 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 }