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