1 //! Implementations of serialization for structures found in liballoc
3 use crate::{Decodable, Decoder, Encodable, Encoder};
4 use smallvec::{Array, SmallVec};
5 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, LinkedList, VecDeque};
6 use std::hash::{BuildHasher, Hash};
11 impl<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;
18 impl<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()
25 impl<S: Encoder, T: Encodable<S>> Encodable<S> for ThinVec<T> {
26 fn encode(&self, s: &mut S) {
27 self.as_slice().encode(s);
31 impl<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()
38 impl<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() {
47 impl<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()
54 impl<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() {
63 impl<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()
70 impl<S: Encoder, K, V> Encodable<S> for BTreeMap<K, V>
72 K: Encodable<S> + PartialEq + Ord,
75 fn encode(&self, e: &mut S) {
76 e.emit_usize(self.len());
77 for (key, val) in self.iter() {
84 impl<D: Decoder, K, V> Decodable<D> for BTreeMap<K, V>
86 K: Decodable<D> + PartialEq + Ord,
89 fn decode(d: &mut D) -> BTreeMap<K, V> {
90 let len = d.read_usize();
91 let mut map = BTreeMap::new();
93 let key = Decodable::decode(d);
94 let val = Decodable::decode(d);
101 impl<S: Encoder, T> Encodable<S> for BTreeSet<T>
103 T: Encodable<S> + PartialEq + Ord,
105 fn encode(&self, s: &mut S) {
106 s.emit_usize(self.len());
107 for e in self.iter() {
113 impl<D: Decoder, T> Decodable<D> for BTreeSet<T>
115 T: Decodable<D> + PartialEq + Ord,
117 fn decode(d: &mut D) -> BTreeSet<T> {
118 let len = d.read_usize();
119 let mut set = BTreeSet::new();
121 set.insert(Decodable::decode(d));
127 impl<E: Encoder, K, V, S> Encodable<E> for HashMap<K, V, S>
129 K: Encodable<E> + Eq,
133 fn encode(&self, e: &mut E) {
134 e.emit_usize(self.len());
135 for (key, val) in self.iter() {
142 impl<D: Decoder, K, V, S> Decodable<D> for HashMap<K, V, S>
144 K: Decodable<D> + Hash + Eq,
146 S: BuildHasher + Default,
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);
153 let key = Decodable::decode(d);
154 let val = Decodable::decode(d);
155 map.insert(key, val);
161 impl<E: Encoder, T, S> Encodable<E> for HashSet<T, S>
163 T: Encodable<E> + Eq,
166 fn encode(&self, s: &mut E) {
167 s.emit_usize(self.len());
168 for e in self.iter() {
174 impl<D: Decoder, T, S> Decodable<D> for HashSet<T, S>
176 T: Decodable<D> + Hash + Eq,
177 S: BuildHasher + Default,
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);
184 set.insert(Decodable::decode(d));
190 impl<E: Encoder, K, V, S> Encodable<E> for indexmap::IndexMap<K, V, S>
192 K: Encodable<E> + Hash + Eq,
196 fn encode(&self, e: &mut E) {
197 e.emit_usize(self.len());
198 for (key, val) in self.iter() {
205 impl<D: Decoder, K, V, S> Decodable<D> for indexmap::IndexMap<K, V, S>
207 K: Decodable<D> + Hash + Eq,
209 S: BuildHasher + Default,
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);
216 let key = Decodable::decode(d);
217 let val = Decodable::decode(d);
218 map.insert(key, val);
224 impl<E: Encoder, T, S> Encodable<E> for indexmap::IndexSet<T, S>
226 T: Encodable<E> + Hash + Eq,
229 fn encode(&self, s: &mut E) {
230 s.emit_usize(self.len());
231 for e in self.iter() {
237 impl<D: Decoder, T, S> Decodable<D> for indexmap::IndexSet<T, S>
239 T: Decodable<D> + Hash + Eq,
240 S: BuildHasher + Default,
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);
247 set.insert(Decodable::decode(d));
253 impl<E: Encoder, T: Encodable<E>> Encodable<E> for Rc<[T]> {
254 fn encode(&self, s: &mut E) {
255 let slice: &[T] = self;
260 impl<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);
267 impl<E: Encoder, T: Encodable<E>> Encodable<E> for Arc<[T]> {
268 fn encode(&self, s: &mut E) {
269 let slice: &[T] = self;
274 impl<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);