hkalbasi_rustc_ap_rustc_serialize/
collection_impls.rs

1//! Implementations of serialization for structures found in liballoc
2
3use crate::{Decodable, Decoder, Encodable, Encoder};
4use smallvec::{Array, SmallVec};
5use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, LinkedList, VecDeque};
6use std::hash::{BuildHasher, Hash};
7use std::rc::Rc;
8use std::sync::Arc;
9use thin_vec::ThinVec;
10
11impl<S: Encoder, A: Array<Item: Encodable<S>>> Encodable<S> for SmallVec<A> {
12    fn encode(&self, s: &mut S) {
13        let slice: &[A::Item] = self;
14        slice.encode(s);
15    }
16}
17
18impl<D: Decoder, A: Array<Item: Decodable<D>>> Decodable<D> for SmallVec<A> {
19    fn decode(d: &mut D) -> SmallVec<A> {
20        let len = d.read_usize();
21        (0..len).map(|_| Decodable::decode(d)).collect()
22    }
23}
24
25impl<S: Encoder, T: Encodable<S>> Encodable<S> for ThinVec<T> {
26    fn encode(&self, s: &mut S) {
27        self.as_slice().encode(s);
28    }
29}
30
31impl<D: Decoder, T: Decodable<D>> Decodable<D> for ThinVec<T> {
32    fn decode(d: &mut D) -> ThinVec<T> {
33        let len = d.read_usize();
34        (0..len).map(|_| Decodable::decode(d)).collect()
35    }
36}
37
38impl<S: Encoder, T: Encodable<S>> Encodable<S> for LinkedList<T> {
39    fn encode(&self, s: &mut S) {
40        s.emit_usize(self.len());
41        for e in self.iter() {
42            e.encode(s);
43        }
44    }
45}
46
47impl<D: Decoder, T: Decodable<D>> Decodable<D> for LinkedList<T> {
48    fn decode(d: &mut D) -> LinkedList<T> {
49        let len = d.read_usize();
50        (0..len).map(|_| Decodable::decode(d)).collect()
51    }
52}
53
54impl<S: Encoder, T: Encodable<S>> Encodable<S> for VecDeque<T> {
55    fn encode(&self, s: &mut S) {
56        s.emit_usize(self.len());
57        for e in self.iter() {
58            e.encode(s);
59        }
60    }
61}
62
63impl<D: Decoder, T: Decodable<D>> Decodable<D> for VecDeque<T> {
64    fn decode(d: &mut D) -> VecDeque<T> {
65        let len = d.read_usize();
66        (0..len).map(|_| Decodable::decode(d)).collect()
67    }
68}
69
70impl<S: Encoder, K, V> Encodable<S> for BTreeMap<K, V>
71where
72    K: Encodable<S> + PartialEq + Ord,
73    V: Encodable<S>,
74{
75    fn encode(&self, e: &mut S) {
76        e.emit_usize(self.len());
77        for (key, val) in self.iter() {
78            key.encode(e);
79            val.encode(e);
80        }
81    }
82}
83
84impl<D: Decoder, K, V> Decodable<D> for BTreeMap<K, V>
85where
86    K: Decodable<D> + PartialEq + Ord,
87    V: Decodable<D>,
88{
89    fn decode(d: &mut D) -> BTreeMap<K, V> {
90        let len = d.read_usize();
91        let mut map = BTreeMap::new();
92        for _ in 0..len {
93            let key = Decodable::decode(d);
94            let val = Decodable::decode(d);
95            map.insert(key, val);
96        }
97        map
98    }
99}
100
101impl<S: Encoder, T> Encodable<S> for BTreeSet<T>
102where
103    T: Encodable<S> + PartialEq + Ord,
104{
105    fn encode(&self, s: &mut S) {
106        s.emit_usize(self.len());
107        for e in self.iter() {
108            e.encode(s);
109        }
110    }
111}
112
113impl<D: Decoder, T> Decodable<D> for BTreeSet<T>
114where
115    T: Decodable<D> + PartialEq + Ord,
116{
117    fn decode(d: &mut D) -> BTreeSet<T> {
118        let len = d.read_usize();
119        let mut set = BTreeSet::new();
120        for _ in 0..len {
121            set.insert(Decodable::decode(d));
122        }
123        set
124    }
125}
126
127impl<E: Encoder, K, V, S> Encodable<E> for HashMap<K, V, S>
128where
129    K: Encodable<E> + Eq,
130    V: Encodable<E>,
131    S: BuildHasher,
132{
133    fn encode(&self, e: &mut E) {
134        e.emit_usize(self.len());
135        for (key, val) in self.iter() {
136            key.encode(e);
137            val.encode(e);
138        }
139    }
140}
141
142impl<D: Decoder, K, V, S> Decodable<D> for HashMap<K, V, S>
143where
144    K: Decodable<D> + Hash + Eq,
145    V: Decodable<D>,
146    S: BuildHasher + Default,
147{
148    fn decode(d: &mut D) -> HashMap<K, V, S> {
149        let len = d.read_usize();
150        let state = Default::default();
151        let mut map = HashMap::with_capacity_and_hasher(len, state);
152        for _ in 0..len {
153            let key = Decodable::decode(d);
154            let val = Decodable::decode(d);
155            map.insert(key, val);
156        }
157        map
158    }
159}
160
161impl<E: Encoder, T, S> Encodable<E> for HashSet<T, S>
162where
163    T: Encodable<E> + Eq,
164    S: BuildHasher,
165{
166    fn encode(&self, s: &mut E) {
167        s.emit_usize(self.len());
168        for e in self.iter() {
169            e.encode(s);
170        }
171    }
172}
173
174impl<D: Decoder, T, S> Decodable<D> for HashSet<T, S>
175where
176    T: Decodable<D> + Hash + Eq,
177    S: BuildHasher + Default,
178{
179    fn decode(d: &mut D) -> HashSet<T, S> {
180        let len = d.read_usize();
181        let state = Default::default();
182        let mut set = HashSet::with_capacity_and_hasher(len, state);
183        for _ in 0..len {
184            set.insert(Decodable::decode(d));
185        }
186        set
187    }
188}
189
190impl<E: Encoder, K, V, S> Encodable<E> for indexmap::IndexMap<K, V, S>
191where
192    K: Encodable<E> + Hash + Eq,
193    V: Encodable<E>,
194    S: BuildHasher,
195{
196    fn encode(&self, e: &mut E) {
197        e.emit_usize(self.len());
198        for (key, val) in self.iter() {
199            key.encode(e);
200            val.encode(e);
201        }
202    }
203}
204
205impl<D: Decoder, K, V, S> Decodable<D> for indexmap::IndexMap<K, V, S>
206where
207    K: Decodable<D> + Hash + Eq,
208    V: Decodable<D>,
209    S: BuildHasher + Default,
210{
211    fn decode(d: &mut D) -> indexmap::IndexMap<K, V, S> {
212        let len = d.read_usize();
213        let state = Default::default();
214        let mut map = indexmap::IndexMap::with_capacity_and_hasher(len, state);
215        for _ in 0..len {
216            let key = Decodable::decode(d);
217            let val = Decodable::decode(d);
218            map.insert(key, val);
219        }
220        map
221    }
222}
223
224impl<E: Encoder, T, S> Encodable<E> for indexmap::IndexSet<T, S>
225where
226    T: Encodable<E> + Hash + Eq,
227    S: BuildHasher,
228{
229    fn encode(&self, s: &mut E) {
230        s.emit_usize(self.len());
231        for e in self.iter() {
232            e.encode(s);
233        }
234    }
235}
236
237impl<D: Decoder, T, S> Decodable<D> for indexmap::IndexSet<T, S>
238where
239    T: Decodable<D> + Hash + Eq,
240    S: BuildHasher + Default,
241{
242    fn decode(d: &mut D) -> indexmap::IndexSet<T, S> {
243        let len = d.read_usize();
244        let state = Default::default();
245        let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state);
246        for _ in 0..len {
247            set.insert(Decodable::decode(d));
248        }
249        set
250    }
251}
252
253impl<E: Encoder, T: Encodable<E>> Encodable<E> for Rc<[T]> {
254    fn encode(&self, s: &mut E) {
255        let slice: &[T] = self;
256        slice.encode(s);
257    }
258}
259
260impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<[T]> {
261    fn decode(d: &mut D) -> Rc<[T]> {
262        let vec: Vec<T> = Decodable::decode(d);
263        vec.into()
264    }
265}
266
267impl<E: Encoder, T: Encodable<E>> Encodable<E> for Arc<[T]> {
268    fn encode(&self, s: &mut E) {
269        let slice: &[T] = self;
270        slice.encode(s);
271    }
272}
273
274impl<D: Decoder, T: Decodable<D>> Decodable<D> for Arc<[T]> {
275    fn decode(d: &mut D) -> Arc<[T]> {
276        let vec: Vec<T> = Decodable::decode(d);
277        vec.into()
278    }
279}
hkalbasi_rustc_ap_rustc_serialize/collection_impls.rs

hkalbasi_rustc_ap_rustc_serialize/
collection_impls.rs
