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