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