src/libserialize/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<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
  84     K: Encodable + PartialEq + Ord,
  85     V: Encodable,
  86 {
  87     fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
  88         e.emit_map(self.len(), |e| {
  89             let mut i = 0;
  90             for (key, val) in self {
  91                 e.emit_map_elt_key(i, |e| key.encode(e))?;
  92                 e.emit_map_elt_val(i, |e| val.encode(e))?;
  93                 i += 1;
  94             }
  95             Ok(())
  96         })
  97     }
  98 }
  99
 100 impl<K, V> Decodable for BTreeMap<K, V>
 101 where
 102     K: Decodable + PartialEq + Ord,
 103     V: Decodable,
 104 {
 105     fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
 106         d.read_map(|d, len| {
 107             let mut map = BTreeMap::new();
 108             for i in 0..len {
 109                 let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?;
 110                 let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?;
 111                 map.insert(key, val);
 112             }
 113             Ok(map)
 114         })
 115     }
 116 }
 117
 118 impl<T> Encodable for BTreeSet<T>
 119 where
 120     T: Encodable + PartialEq + Ord,
 121 {
 122     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
 123         s.emit_seq(self.len(), |s| {
 124             let mut i = 0;
 125             for e in self {
 126                 s.emit_seq_elt(i, |s| e.encode(s))?;
 127                 i += 1;
 128             }
 129             Ok(())
 130         })
 131     }
 132 }
 133
 134 impl<T> Decodable for BTreeSet<T>
 135 where
 136     T: Decodable + PartialEq + Ord,
 137 {
 138     fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
 139         d.read_seq(|d, len| {
 140             let mut set = BTreeSet::new();
 141             for i in 0..len {
 142                 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
 143             }
 144             Ok(set)
 145         })
 146     }
 147 }
 148
 149 impl<K, V, S> Encodable for HashMap<K, V, S>
 150 where
 151     K: Encodable + Eq,
 152     V: Encodable,
 153     S: BuildHasher,
 154 {
 155     fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
 156         e.emit_map(self.len(), |e| {
 157             let mut i = 0;
 158             for (key, val) in self {
 159                 e.emit_map_elt_key(i, |e| key.encode(e))?;
 160                 e.emit_map_elt_val(i, |e| val.encode(e))?;
 161                 i += 1;
 162             }
 163             Ok(())
 164         })
 165     }
 166 }
 167
 168 impl<K, V, S> Decodable for HashMap<K, V, S>
 169 where
 170     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
 190     T: Encodable + Eq,
 191     S: BuildHasher,
 192 {
 193     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 194         s.emit_seq(self.len(), |s| {
 195             let mut i = 0;
 196             for e in self {
 197                 s.emit_seq_elt(i, |s| e.encode(s))?;
 198                 i += 1;
 199             }
 200             Ok(())
 201         })
 202     }
 203 }
 204
 205 impl<T, S> Decodable for HashSet<T, S>
 206 where
 207     T: Decodable + Hash + Eq,
 208     S: BuildHasher + Default,
 209 {
 210     fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> {
 211         d.read_seq(|d, len| {
 212             let state = Default::default();
 213             let mut set = HashSet::with_capacity_and_hasher(len, state);
 214             for i in 0..len {
 215                 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
 216             }
 217             Ok(set)
 218         })
 219     }
 220 }
 221
 222 impl<K, V, S> Encodable for indexmap::IndexMap<K, V, S>
 223 where
 224     K: Encodable + Hash + Eq,
 225     V: Encodable,
 226     S: BuildHasher,
 227 {
 228     fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
 229         e.emit_map(self.len(), |e| {
 230             let mut i = 0;
 231             for (key, val) in self {
 232                 e.emit_map_elt_key(i, |e| key.encode(e))?;
 233                 e.emit_map_elt_val(i, |e| val.encode(e))?;
 234                 i += 1;
 235             }
 236             Ok(())
 237         })
 238     }
 239 }
 240
 241 impl<K, V, S> Decodable for indexmap::IndexMap<K, V, S>
 242 where
 243     K: Decodable + Hash + Eq,
 244     V: Decodable,
 245     S: BuildHasher + Default,
 246 {
 247     fn decode<D: Decoder>(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<T, S> Encodable for indexmap::IndexSet<T, S>
 262 where
 263     T: Encodable + Hash + Eq,
 264     S: BuildHasher,
 265 {
 266     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 267         s.emit_seq(self.len(), |s| {
 268             let mut i = 0;
 269             for e in self {
 270                 s.emit_seq_elt(i, |s| e.encode(s))?;
 271                 i += 1;
 272             }
 273             Ok(())
 274         })
 275     }
 276 }
 277
 278 impl<T, S> Decodable for indexmap::IndexSet<T, S>
 279 where
 280     T: Decodable + Hash + Eq,
 281     S: BuildHasher + Default,
 282 {
 283     fn decode<D: Decoder>(d: &mut D) -> Result<indexmap::IndexSet<T, S>, D::Error> {
 284         d.read_seq(|d, len| {
 285             let state = Default::default();
 286             let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state);
 287             for i in 0..len {
 288                 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
 289             }
 290             Ok(set)
 291         })
 292     }
 293 }
 294
 295 impl<T: Encodable> Encodable for Rc<[T]> {
 296     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 297         s.emit_seq(self.len(), |s| {
 298             for (index, e) in self.iter().enumerate() {
 299                 s.emit_seq_elt(index, |s| e.encode(s))?;
 300             }
 301             Ok(())
 302         })
 303     }
 304 }
 305
 306 impl<T: Decodable> Decodable for Rc<[T]> {
 307     fn decode<D: Decoder>(d: &mut D) -> Result<Rc<[T]>, D::Error> {
 308         d.read_seq(|d, len| {
 309             let mut vec = Vec::with_capacity(len);
 310             for index in 0..len {
 311                 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);
 312             }
 313             Ok(vec.into())
 314         })
 315     }
 316 }
 317
 318 impl<T: Encodable> Encodable for Arc<[T]> {
 319     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 320         s.emit_seq(self.len(), |s| {
 321             for (index, e) in self.iter().enumerate() {
 322                 s.emit_seq_elt(index, |s| e.encode(s))?;
 323             }
 324             Ok(())
 325         })
 326     }
 327 }
 328
 329 impl<T: Decodable> Decodable for Arc<[T]> {
 330     fn decode<D: Decoder>(d: &mut D) -> Result<Arc<[T]>, D::Error> {
 331         d.read_seq(|d, len| {
 332             let mut vec = Vec::with_capacity(len);
 333             for index in 0..len {
 334                 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);
 335             }
 336             Ok(vec.into())
 337         })
 338     }
 339 }