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