1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
use std::fmt; use std::marker::PhantomData; use serde::ser::{Serialize, Serializer, SerializeSeq}; use serde::de::{Deserialize, Deserializer, Visitor, SeqAccess}; use super::{ManyToMany, ERROR}; impl<L, R> Serialize for ManyToMany<L, R> where L: std::hash::Hash + Eq + Clone + Serialize, R: std::hash::Hash + Eq + Clone + Serialize { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, { let keys = self.get_left_keys(); let mut seq = serializer.serialize_seq(None)?; for left in keys { let values = self.get_left(left).expect(ERROR); for value in values { seq.serialize_element(&(left, value))?; } } seq.end() } } struct ManyToManyVisitor<L: std::hash::Hash + Eq + Clone, R: std::hash::Hash + Eq + Clone> { marker: PhantomData<fn() -> ManyToMany<L, R>> } impl<L: std::hash::Hash + Eq + Clone, R: std::hash::Hash + Eq + Clone> ManyToManyVisitor<L, R> { fn new() -> Self { ManyToManyVisitor { marker: PhantomData } } } impl<'de, L, R> Visitor<'de> for ManyToManyVisitor<L, R> where L: std::hash::Hash + Eq + Clone + Deserialize<'de>, R: std::hash::Hash + Eq + Clone + Deserialize<'de> { type Value = ManyToMany<L, R>; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("many-to-many map") } fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> where A: SeqAccess<'de>, { let mut map = ManyToMany::new(); while let Some((left, right)) = seq.next_element()? as Option<(L, R)> { map.insert(left, right); } Ok(map) } } impl<'de, L, R> Deserialize<'de> for ManyToMany<L, R> where L: std::hash::Hash + Eq + Clone + Deserialize<'de>, R: std::hash::Hash + Eq + Clone + Deserialize<'de> { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>, { deserializer.deserialize_seq(ManyToManyVisitor::new()) } }