compiler/rustc_serialize/src/collection_impls.rs

   1 //! Implementations of serialization for structures found in liballoc
   2
   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};
   7 use std::rc::Rc;
   8 use std::sync::Arc;
   9 use thin_vec::ThinVec;
  10
  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;
  14         slice.encode(s);
  15     }
  16 }
  17
  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()
  22     }
  23 }
  24
  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);
  28     }
  29 }
  30
  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()
  35     }
  36 }
  37
  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() {
  42             e.encode(s);
  43         }
  44     }
  45 }
  46
  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()
  51     }
  52 }
  53
  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() {
  58             e.encode(s);
  59         }
  60     }
  61 }
  62
  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()
  67     }
  68 }
  69
  70 impl<S: Encoder, K, V> Encodable<S> for BTreeMap<K, V>
  71 where
  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
  84 impl<D: Decoder, K, V> Decodable<D> for BTreeMap<K, V>
  85 where
  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
 101 impl<S: Encoder, T> Encodable<S> for BTreeSet<T>
 102 where
 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
 113 impl<D: Decoder, T> Decodable<D> for BTreeSet<T>
 114 where
 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
 127 impl<E: Encoder, K, V, S> Encodable<E> for HashMap<K, V, S>
 128 where
 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
 142 impl<D: Decoder, K, V, S> Decodable<D> for HashMap<K, V, S>
 143 where
 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
 161 impl<E: Encoder, T, S> Encodable<E> for HashSet<T, S>
 162 where
 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
 174 impl<D: Decoder, T, S> Decodable<D> for HashSet<T, S>
 175 where
 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
 190 impl<E: Encoder, K, V, S> Encodable<E> for indexmap::IndexMap<K, V, S>
 191 where
 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
 205 impl<D: Decoder, K, V, S> Decodable<D> for indexmap::IndexMap<K, V, S>
 206 where
 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
 224 impl<E: Encoder, T, S> Encodable<E> for indexmap::IndexSet<T, S>
 225 where
 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
 237 impl<D: Decoder, T, S> Decodable<D> for indexmap::IndexSet<T, S>
 238 where
 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
 253 impl<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
 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);
 263         vec.into()
 264     }
 265 }
 266
 267 impl<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
 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);
 277         vec.into()
 278     }
 279 }