compiler/rustc_serialize/src/collection_impls.rs

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