im_rc/
ser.rs

1// This Source Code Form is subject to the terms of the Mozilla Public
2// License, v. 2.0. If a copy of the MPL was not distributed with this
3// file, You can obtain one at http://mozilla.org/MPL/2.0/.
4
5use serde::de::{Deserialize, Deserializer, MapAccess, SeqAccess, Visitor};
6use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
7use std::fmt;
8use std::hash::{BuildHasher, Hash};
9use std::marker::PhantomData;
10use std::ops::Deref;
11
12use crate::hashmap::HashMap;
13use crate::hashset::HashSet;
14use crate::ordmap::OrdMap;
15use crate::ordset::OrdSet;
16use crate::vector::Vector;
17
18struct SeqVisitor<'de, S, A>
19where
20    S: From<Vec<A>>,
21    A: Deserialize<'de>,
22{
23    phantom_s: PhantomData<S>,
24    phantom_a: PhantomData<A>,
25    phantom_lifetime: PhantomData<&'de ()>,
26}
27
28impl<'de, S, A> SeqVisitor<'de, S, A>
29where
30    S: From<Vec<A>>,
31    A: Deserialize<'de>,
32{
33    pub(crate) fn new() -> SeqVisitor<'de, S, A> {
34        SeqVisitor {
35            phantom_s: PhantomData,
36            phantom_a: PhantomData,
37            phantom_lifetime: PhantomData,
38        }
39    }
40}
41
42impl<'de, S, A> Visitor<'de> for SeqVisitor<'de, S, A>
43where
44    S: From<Vec<A>>,
45    A: Deserialize<'de>,
46{
47    type Value = S;
48
49    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
50        formatter.write_str("a sequence")
51    }
52
53    fn visit_seq<Access>(self, mut access: Access) -> Result<Self::Value, Access::Error>
54    where
55        Access: SeqAccess<'de>,
56    {
57        let mut v: Vec<A> = match access.size_hint() {
58            None => Vec::new(),
59            Some(l) => Vec::with_capacity(l),
60        };
61        while let Some(i) = access.next_element()? {
62            v.push(i)
63        }
64        Ok(From::from(v))
65    }
66}
67
68struct MapVisitor<'de, S, K, V>
69where
70    S: From<Vec<(K, V)>>,
71    K: Deserialize<'de>,
72    V: Deserialize<'de>,
73{
74    phantom_s: PhantomData<S>,
75    phantom_k: PhantomData<K>,
76    phantom_v: PhantomData<V>,
77    phantom_lifetime: PhantomData<&'de ()>,
78}
79
80impl<'de, S, K, V> MapVisitor<'de, S, K, V>
81where
82    S: From<Vec<(K, V)>>,
83    K: Deserialize<'de>,
84    V: Deserialize<'de>,
85{
86    pub(crate) fn new() -> MapVisitor<'de, S, K, V> {
87        MapVisitor {
88            phantom_s: PhantomData,
89            phantom_k: PhantomData,
90            phantom_v: PhantomData,
91            phantom_lifetime: PhantomData,
92        }
93    }
94}
95
96impl<'de, S, K, V> Visitor<'de> for MapVisitor<'de, S, K, V>
97where
98    S: From<Vec<(K, V)>>,
99    K: Deserialize<'de>,
100    V: Deserialize<'de>,
101{
102    type Value = S;
103
104    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
105        formatter.write_str("a sequence")
106    }
107
108    fn visit_map<Access>(self, mut access: Access) -> Result<Self::Value, Access::Error>
109    where
110        Access: MapAccess<'de>,
111    {
112        let mut v: Vec<(K, V)> = match access.size_hint() {
113            None => Vec::new(),
114            Some(l) => Vec::with_capacity(l),
115        };
116        while let Some(i) = access.next_entry()? {
117            v.push(i)
118        }
119        Ok(From::from(v))
120    }
121}
122
123// Set
124
125impl<'de, A: Deserialize<'de> + Ord + Clone> Deserialize<'de> for OrdSet<A> {
126    fn deserialize<D>(des: D) -> Result<Self, D::Error>
127    where
128        D: Deserializer<'de>,
129    {
130        des.deserialize_seq(SeqVisitor::new())
131    }
132}
133
134impl<A: Ord + Clone + Serialize> Serialize for OrdSet<A> {
135    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
136    where
137        S: Serializer,
138    {
139        let mut s = ser.serialize_seq(Some(self.len()))?;
140        for i in self.iter() {
141            s.serialize_element(i.deref())?;
142        }
143        s.end()
144    }
145}
146
147// Map
148
149impl<'de, K: Deserialize<'de> + Ord + Clone, V: Deserialize<'de> + Clone> Deserialize<'de>
150    for OrdMap<K, V>
151{
152    fn deserialize<D>(des: D) -> Result<Self, D::Error>
153    where
154        D: Deserializer<'de>,
155    {
156        des.deserialize_map(MapVisitor::<'de, OrdMap<K, V>, K, V>::new())
157    }
158}
159
160impl<K: Serialize + Ord + Clone, V: Serialize + Clone> Serialize for OrdMap<K, V> {
161    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
162    where
163        S: Serializer,
164    {
165        let mut s = ser.serialize_map(Some(self.len()))?;
166        for (k, v) in self.iter() {
167            s.serialize_entry(k.deref(), v.deref())?;
168        }
169        s.end()
170    }
171}
172
173// HashMap
174
175impl<'de, K, V, S> Deserialize<'de> for HashMap<K, V, S>
176where
177    K: Deserialize<'de> + Hash + Eq + Clone,
178    V: Deserialize<'de> + Clone,
179    S: BuildHasher + Default,
180{
181    fn deserialize<D>(des: D) -> Result<Self, D::Error>
182    where
183        D: Deserializer<'de>,
184    {
185        des.deserialize_map(MapVisitor::<'de, HashMap<K, V, S>, K, V>::new())
186    }
187}
188
189impl<K, V, S> Serialize for HashMap<K, V, S>
190where
191    K: Serialize + Hash + Eq + Clone,
192    V: Serialize + Clone,
193    S: BuildHasher + Default,
194{
195    fn serialize<Ser>(&self, ser: Ser) -> Result<Ser::Ok, Ser::Error>
196    where
197        Ser: Serializer,
198    {
199        let mut s = ser.serialize_map(Some(self.len()))?;
200        for (k, v) in self.iter() {
201            s.serialize_entry(k.deref(), v.deref())?;
202        }
203        s.end()
204    }
205}
206
207// HashSet
208
209impl<'de, A: Deserialize<'de> + Hash + Eq + Clone, S: BuildHasher + Default> Deserialize<'de>
210    for HashSet<A, S>
211{
212    fn deserialize<D>(des: D) -> Result<Self, D::Error>
213    where
214        D: Deserializer<'de>,
215    {
216        des.deserialize_seq(SeqVisitor::new())
217    }
218}
219
220impl<A: Serialize + Hash + Eq + Clone, S: BuildHasher + Default> Serialize for HashSet<A, S> {
221    fn serialize<Ser>(&self, ser: Ser) -> Result<Ser::Ok, Ser::Error>
222    where
223        Ser: Serializer,
224    {
225        let mut s = ser.serialize_seq(Some(self.len()))?;
226        for i in self.iter() {
227            s.serialize_element(i.deref())?;
228        }
229        s.end()
230    }
231}
232
233// Vector
234
235impl<'de, A: Clone + Deserialize<'de>> Deserialize<'de> for Vector<A> {
236    fn deserialize<D>(des: D) -> Result<Self, D::Error>
237    where
238        D: Deserializer<'de>,
239    {
240        des.deserialize_seq(SeqVisitor::<'de, Vector<A>, A>::new())
241    }
242}
243
244impl<A: Clone + Serialize> Serialize for Vector<A> {
245    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
246    where
247        S: Serializer,
248    {
249        let mut s = ser.serialize_seq(Some(self.len()))?;
250        for i in self.iter() {
251            s.serialize_element(i.deref())?;
252        }
253        s.end()
254    }
255}
256
257// Tests
258
259#[cfg(test)]
260mod test {
261    use super::*;
262    use crate::proptest::{hash_map, hash_set, ord_map, ord_set, vector};
263    use ::proptest::num::i32;
264    use ::proptest::proptest;
265    use serde_json::{from_str, to_string};
266
267    proptest! {
268        #[test]
269        fn ser_ordset(ref v in ord_set(i32::ANY, 0..100)) {
270            assert_eq!(v, &from_str::<OrdSet<i32>>(&to_string(&v).unwrap()).unwrap());
271        }
272
273        #[test]
274        fn ser_ordmap(ref v in ord_map(i32::ANY, i32::ANY, 0..100)) {
275            assert_eq!(v, &from_str::<OrdMap<i32, i32>>(&to_string(&v).unwrap()).unwrap());
276        }
277
278        #[test]
279        fn ser_hashmap(ref v in hash_map(i32::ANY, i32::ANY, 0..100)) {
280            assert_eq!(v, &from_str::<HashMap<i32, i32>>(&to_string(&v).unwrap()).unwrap());
281        }
282
283        #[test]
284        fn ser_hashset(ref v in hash_set(i32::ANY, 0..100)) {
285            assert_eq!(v, &from_str::<HashSet<i32>>(&to_string(&v).unwrap()).unwrap());
286        }
287
288        #[test]
289        fn ser_vector(ref v in vector(i32::ANY, 0..100)) {
290            assert_eq!(v, &from_str::<Vector<i32>>(&to_string(&v).unwrap()).unwrap());
291        }
292    }
293}
im_rc/ser.rs

im_rc/
ser.rs
