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