src/libserialize/collection_impls.rs

   1 //! Implementations of serialization for structures found in liballoc
   2
   3 use std::hash::{Hash, BuildHasher};
   4
   5 use crate::{Decodable, Encodable, Decoder, Encoder};
   6 use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet};
   7 use std::rc::Rc;
   8 use std::sync::Arc;
   9
  10 use smallvec::{Array, SmallVec};
  11
  12 impl<A: Array<Item: Encodable>> Encodable for SmallVec<A> {
  13     fn encode<S: Encoder>(&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<A: Array<Item: Decodable>> Decodable for SmallVec<A> {
  24     fn decode<D: Decoder>(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<T: Encodable> Encodable for LinkedList<T> {
  37     fn encode<S: Encoder>(&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<T:Decodable> Decodable for LinkedList<T> {
  48     fn decode<D: Decoder>(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<T: Encodable> Encodable for VecDeque<T> {
  60     fn encode<S: Encoder>(&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<T:Decodable> Decodable for VecDeque<T> {
  71     fn decode<D: Decoder>(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<K, V> Encodable for BTreeMap<K, V>
  83     where K: Encodable + PartialEq + Ord,
  84           V: Encodable
  85 {
  86     fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
  87         e.emit_map(self.len(), |e| {
  88             let mut i = 0;
  89             for (key, val) in self {
  90                 e.emit_map_elt_key(i, |e| key.encode(e))?;
  91                 e.emit_map_elt_val(i, |e| val.encode(e))?;
  92                 i += 1;
  93             }
  94             Ok(())
  95         })
  96     }
  97 }
  98
  99 impl<K, V> Decodable for BTreeMap<K, V>
 100     where K: Decodable + PartialEq + Ord,
 101           V: Decodable
 102 {
 103     fn decode<D: Decoder>(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<T> Encodable for BTreeSet<T>
 117     where T: Encodable + PartialEq + Ord
 118 {
 119     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
 120         s.emit_seq(self.len(), |s| {
 121             let mut i = 0;
 122             for e in self {
 123                 s.emit_seq_elt(i, |s| e.encode(s))?;
 124                 i += 1;
 125             }
 126             Ok(())
 127         })
 128     }
 129 }
 130
 131 impl<T> Decodable for BTreeSet<T>
 132     where T: Decodable + PartialEq + Ord
 133 {
 134     fn decode<D: Decoder>(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<K, V, S> Encodable for HashMap<K, V, S>
 146     where K: Encodable + Eq,
 147           V: Encodable,
 148           S: BuildHasher,
 149 {
 150     fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
 151         e.emit_map(self.len(), |e| {
 152             let mut i = 0;
 153             for (key, val) in self {
 154                 e.emit_map_elt_key(i, |e| key.encode(e))?;
 155                 e.emit_map_elt_val(i, |e| val.encode(e))?;
 156                 i += 1;
 157             }
 158             Ok(())
 159         })
 160     }
 161 }
 162
 163 impl<K, V, S> Decodable for HashMap<K, V, S>
 164     where K: Decodable + Hash + Eq,
 165           V: Decodable,
 166           S: BuildHasher + Default,
 167 {
 168     fn decode<D: Decoder>(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<T, S> Encodable for HashSet<T, S>
 183     where T: Encodable + Eq,
 184           S: BuildHasher,
 185 {
 186     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 187         s.emit_seq(self.len(), |s| {
 188             let mut i = 0;
 189             for e in self {
 190                 s.emit_seq_elt(i, |s| e.encode(s))?;
 191                 i += 1;
 192             }
 193             Ok(())
 194         })
 195     }
 196 }
 197
 198 impl<T, S> Decodable for HashSet<T, S>
 199     where T: Decodable + Hash + Eq,
 200           S: BuildHasher + Default,
 201 {
 202     fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> {
 203         d.read_seq(|d, len| {
 204             let state = Default::default();
 205             let mut set = HashSet::with_capacity_and_hasher(len, state);
 206             for i in 0..len {
 207                 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
 208             }
 209             Ok(set)
 210         })
 211     }
 212 }
 213
 214 impl<K, V, S> Encodable for indexmap::IndexMap<K, V, S>
 215     where K: Encodable + Hash + Eq,
 216           V: Encodable,
 217           S: BuildHasher,
 218 {
 219     fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
 220         e.emit_map(self.len(), |e| {
 221             let mut i = 0;
 222             for (key, val) in self {
 223                 e.emit_map_elt_key(i, |e| key.encode(e))?;
 224                 e.emit_map_elt_val(i, |e| val.encode(e))?;
 225                 i += 1;
 226             }
 227             Ok(())
 228         })
 229     }
 230 }
 231
 232 impl<K, V, S> Decodable for indexmap::IndexMap<K, V, S>
 233     where K: Decodable + Hash + Eq,
 234           V: Decodable,
 235           S: BuildHasher + Default,
 236 {
 237     fn decode<D: Decoder>(d: &mut D) -> Result<indexmap::IndexMap<K, V, S>, D::Error> {
 238         d.read_map(|d, len| {
 239             let state = Default::default();
 240             let mut map = indexmap::IndexMap::with_capacity_and_hasher(len, state);
 241             for i in 0..len {
 242                 let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?;
 243                 let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?;
 244                 map.insert(key, val);
 245             }
 246             Ok(map)
 247         })
 248     }
 249 }
 250
 251 impl<T, S> Encodable for indexmap::IndexSet<T, S>
 252     where T: Encodable + Hash + Eq,
 253           S: BuildHasher,
 254 {
 255     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 256         s.emit_seq(self.len(), |s| {
 257             let mut i = 0;
 258             for e in self {
 259                 s.emit_seq_elt(i, |s| e.encode(s))?;
 260                 i += 1;
 261             }
 262             Ok(())
 263         })
 264     }
 265 }
 266
 267 impl<T, S> Decodable for indexmap::IndexSet<T, S>
 268     where T: Decodable + Hash + Eq,
 269           S: BuildHasher + Default,
 270 {
 271     fn decode<D: Decoder>(d: &mut D) -> Result<indexmap::IndexSet<T, S>, D::Error> {
 272         d.read_seq(|d, len| {
 273             let state = Default::default();
 274             let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state);
 275             for i in 0..len {
 276                 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
 277             }
 278             Ok(set)
 279         })
 280     }
 281 }
 282
 283 impl<T: Encodable> Encodable for Rc<[T]> {
 284     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 285         s.emit_seq(self.len(), |s| {
 286             for (index, e) in self.iter().enumerate() {
 287                 s.emit_seq_elt(index, |s| e.encode(s))?;
 288             }
 289             Ok(())
 290         })
 291     }
 292 }
 293
 294 impl<T: Decodable> Decodable for Rc<[T]> {
 295     fn decode<D: Decoder>(d: &mut D) -> Result<Rc<[T]>, D::Error> {
 296         d.read_seq(|d, len| {
 297             let mut vec = Vec::with_capacity(len);
 298             for index in 0..len {
 299                 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);
 300             }
 301             Ok(vec.into())
 302         })
 303     }
 304 }
 305
 306 impl<T: Encodable> Encodable for Arc<[T]> {
 307     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 308         s.emit_seq(self.len(), |s| {
 309             for (index, e) in self.iter().enumerate() {
 310                 s.emit_seq_elt(index, |s| e.encode(s))?;
 311             }
 312             Ok(())
 313         })
 314     }
 315 }
 316
 317 impl<T: Decodable> Decodable for Arc<[T]> {
 318     fn decode<D: Decoder>(d: &mut D) -> Result<Arc<[T]>, D::Error> {
 319         d.read_seq(|d, len| {
 320             let mut vec = Vec::with_capacity(len);
 321             for index in 0..len {
 322                 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);
 323             }
 324             Ok(vec.into())
 325         })
 326     }
 327 }