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<T: Encodable> Encodable for Rc<[T]> {
 221     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 222         s.emit_seq(self.len(), |s| {
 223             for (index, e) in self.iter().enumerate() {
 224                 s.emit_seq_elt(index, |s| e.encode(s))?;
 225             }
 226             Ok(())
 227         })
 228     }
 229 }
 230
 231 impl<T: Decodable> Decodable for Rc<[T]> {
 232     fn decode<D: Decoder>(d: &mut D) -> Result<Rc<[T]>, D::Error> {
 233         d.read_seq(|d, len| {
 234             let mut vec = Vec::with_capacity(len);
 235             for index in 0..len {
 236                 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);
 237             }
 238             Ok(vec.into())
 239         })
 240     }
 241 }
 242
 243 impl<T: Encodable> Encodable for Arc<[T]> {
 244     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 245         s.emit_seq(self.len(), |s| {
 246             for (index, e) in self.iter().enumerate() {
 247                 s.emit_seq_elt(index, |s| e.encode(s))?;
 248             }
 249             Ok(())
 250         })
 251     }
 252 }
 253
 254 impl<T: Decodable> Decodable for Arc<[T]> {
 255     fn decode<D: Decoder>(d: &mut D) -> Result<Arc<[T]>, D::Error> {
 256         d.read_seq(|d, len| {
 257             let mut vec = Vec::with_capacity(len);
 258             for index in 0..len {
 259                 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);
 260             }
 261             Ok(vec.into())
 262         })
 263     }
 264 }