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