flat_multimap/
serde.rs

1use crate::{FlatMultimap, FlatMultiset};
2use serde::de::{MapAccess, SeqAccess, Visitor};
3use serde::{Deserialize, Deserializer, Serialize, Serializer};
4use std::fmt;
5use std::hash::{BuildHasher, Hash};
6use std::marker::PhantomData;
7
8impl<K, V, H> Serialize for FlatMultimap<K, V, H>
9where
10    K: Serialize,
11    V: Serialize,
12{
13    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
14    where
15        S: Serializer,
16    {
17        serializer.collect_map(self)
18    }
19}
20
21impl<'de, K, V, S> Deserialize<'de> for FlatMultimap<K, V, S>
22where
23    K: Deserialize<'de> + Eq + Hash,
24    V: Deserialize<'de>,
25    S: BuildHasher + Default,
26{
27    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
28    where
29        D: Deserializer<'de>,
30    {
31        struct MapVisitor<K, V, S> {
32            marker: PhantomData<FlatMultimap<K, V, S>>,
33        }
34
35        impl<'de, K, V, S> Visitor<'de> for MapVisitor<K, V, S>
36        where
37            K: Deserialize<'de> + Eq + Hash,
38            V: Deserialize<'de>,
39            S: BuildHasher + Default,
40        {
41            type Value = FlatMultimap<K, V, S>;
42
43            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
44                formatter.write_str("a map")
45            }
46
47            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
48            where
49                A: MapAccess<'de>,
50            {
51                let mut values = FlatMultimap::with_capacity_and_hasher(
52                    map.size_hint().unwrap_or(0),
53                    S::default(),
54                );
55
56                while let Some((key, value)) = map.next_entry()? {
57                    values.insert(key, value);
58                }
59
60                Ok(values)
61            }
62        }
63
64        let visitor = MapVisitor {
65            marker: PhantomData,
66        };
67
68        deserializer.deserialize_map(visitor)
69    }
70}
71
72impl<T, H> Serialize for FlatMultiset<T, H>
73where
74    T: Serialize,
75{
76    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
77    where
78        S: Serializer,
79    {
80        serializer.collect_seq(self)
81    }
82}
83
84impl<'de, T, S> Deserialize<'de> for FlatMultiset<T, S>
85where
86    T: Deserialize<'de> + Eq + Hash,
87    S: BuildHasher + Default,
88{
89    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
90    where
91        D: Deserializer<'de>,
92    {
93        struct SeqVisitor<T, S> {
94            marker: PhantomData<FlatMultiset<T, S>>,
95        }
96
97        impl<'de, T, S> Visitor<'de> for SeqVisitor<T, S>
98        where
99            T: Deserialize<'de> + Eq + Hash,
100            S: BuildHasher + Default,
101        {
102            type Value = FlatMultiset<T, S>;
103
104            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
105                formatter.write_str("a sequence")
106            }
107
108            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
109            where
110                A: SeqAccess<'de>,
111            {
112                let mut values = FlatMultiset::with_capacity_and_hasher(
113                    seq.size_hint().unwrap_or(0),
114                    S::default(),
115                );
116
117                while let Some(value) = seq.next_element()? {
118                    values.insert(value);
119                }
120
121                Ok(values)
122            }
123        }
124
125        let visitor = SeqVisitor {
126            marker: PhantomData,
127        };
128        deserializer.deserialize_seq(visitor)
129    }
130
131    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
132    where
133        D: Deserializer<'de>,
134    {
135        struct SeqInPlaceVisitor<'a, T, S>(&'a mut FlatMultiset<T, S>);
136
137        impl<'a, 'de, T, S> Visitor<'de> for SeqInPlaceVisitor<'a, T, S>
138        where
139            T: Deserialize<'de> + Eq + Hash,
140            S: BuildHasher + Default,
141        {
142            type Value = ();
143
144            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
145                formatter.write_str("a sequence")
146            }
147
148            #[cfg_attr(feature = "inline-more", inline)]
149            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
150            where
151                A: SeqAccess<'de>,
152            {
153                self.0.clear();
154                self.0.reserve(seq.size_hint().unwrap_or(0));
155
156                while let Some(value) = seq.next_element()? {
157                    self.0.insert(value);
158                }
159
160                Ok(())
161            }
162        }
163
164        deserializer.deserialize_seq(SeqInPlaceVisitor(place))
165    }
166}
flat_multimap/serde.rs

flat_multimap/
serde.rs
