| 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::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::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::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>>(&serialized); |
| 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 |
} |