src/libserialize/collection_impls.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Implementations of serialization for structures found in liballoc
  12
  13 use std::hash::{Hash, BuildHasher};
  14
  15 use {Decodable, Encodable, Decoder, Encoder};
  16 use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet};
  17
  18 impl<
  19     T: Encodable
  20 > Encodable for LinkedList<T> {
  21     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
  22         s.emit_seq(self.len(), |s| {
  23             for (i, e) in self.iter().enumerate() {
  24                 s.emit_seq_elt(i, |s| e.encode(s))?;
  25             }
  26             Ok(())
  27         })
  28     }
  29 }
  30
  31 impl<T:Decodable> Decodable for LinkedList<T> {
  32     fn decode<D: Decoder>(d: &mut D) -> Result<LinkedList<T>, D::Error> {
  33         d.read_seq(|d, len| {
  34             let mut list = LinkedList::new();
  35             for i in 0..len {
  36                 list.push_back(d.read_seq_elt(i, |d| Decodable::decode(d))?);
  37             }
  38             Ok(list)
  39         })
  40     }
  41 }
  42
  43 impl<T: Encodable> Encodable for VecDeque<T> {
  44     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
  45         s.emit_seq(self.len(), |s| {
  46             for (i, e) in self.iter().enumerate() {
  47                 s.emit_seq_elt(i, |s| e.encode(s))?;
  48             }
  49             Ok(())
  50         })
  51     }
  52 }
  53
  54 impl<T:Decodable> Decodable for VecDeque<T> {
  55     fn decode<D: Decoder>(d: &mut D) -> Result<VecDeque<T>, D::Error> {
  56         d.read_seq(|d, len| {
  57             let mut deque: VecDeque<T> = VecDeque::new();
  58             for i in 0..len {
  59                 deque.push_back(d.read_seq_elt(i, |d| Decodable::decode(d))?);
  60             }
  61             Ok(deque)
  62         })
  63     }
  64 }
  65
  66 impl<
  67     K: Encodable + PartialEq + Ord,
  68     V: Encodable + PartialEq
  69 > Encodable for BTreeMap<K, V> {
  70     fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
  71         e.emit_map(self.len(), |e| {
  72             let mut i = 0;
  73             for (key, val) in self {
  74                 e.emit_map_elt_key(i, |e| key.encode(e))?;
  75                 e.emit_map_elt_val(i, |e| val.encode(e))?;
  76                 i += 1;
  77             }
  78             Ok(())
  79         })
  80     }
  81 }
  82
  83 impl<
  84     K: Decodable + PartialEq + Ord,
  85     V: Decodable + PartialEq
  86 > Decodable for BTreeMap<K, V> {
  87     fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
  88         d.read_map(|d, len| {
  89             let mut map = BTreeMap::new();
  90             for i in 0..len {
  91                 let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?;
  92                 let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?;
  93                 map.insert(key, val);
  94             }
  95             Ok(map)
  96         })
  97     }
  98 }
  99
 100 impl<
 101     T: Encodable + PartialEq + Ord
 102 > Encodable for BTreeSet<T> {
 103     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
 104         s.emit_seq(self.len(), |s| {
 105             let mut i = 0;
 106             for e in self {
 107                 s.emit_seq_elt(i, |s| e.encode(s))?;
 108                 i += 1;
 109             }
 110             Ok(())
 111         })
 112     }
 113 }
 114
 115 impl<
 116     T: Decodable + PartialEq + Ord
 117 > Decodable for BTreeSet<T> {
 118     fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
 119         d.read_seq(|d, len| {
 120             let mut set = BTreeSet::new();
 121             for i in 0..len {
 122                 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
 123             }
 124             Ok(set)
 125         })
 126     }
 127 }
 128
 129 impl<K, V, S> Encodable for HashMap<K, V, S>
 130     where K: Encodable + Hash + Eq,
 131           V: Encodable,
 132           S: BuildHasher,
 133 {
 134     fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
 135         e.emit_map(self.len(), |e| {
 136             let mut i = 0;
 137             for (key, val) in self {
 138                 e.emit_map_elt_key(i, |e| key.encode(e))?;
 139                 e.emit_map_elt_val(i, |e| val.encode(e))?;
 140                 i += 1;
 141             }
 142             Ok(())
 143         })
 144     }
 145 }
 146
 147 impl<K, V, S> Decodable for HashMap<K, V, S>
 148     where K: Decodable + Hash + Eq,
 149           V: Decodable,
 150           S: BuildHasher + Default,
 151 {
 152     fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> {
 153         d.read_map(|d, len| {
 154             let state = Default::default();
 155             let mut map = HashMap::with_capacity_and_hasher(len, state);
 156             for i in 0..len {
 157                 let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?;
 158                 let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?;
 159                 map.insert(key, val);
 160             }
 161             Ok(map)
 162         })
 163     }
 164 }
 165
 166 impl<T, S> Encodable for HashSet<T, S>
 167     where T: Encodable + Hash + Eq,
 168           S: BuildHasher,
 169 {
 170     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 171         s.emit_seq(self.len(), |s| {
 172             let mut i = 0;
 173             for e in self {
 174                 s.emit_seq_elt(i, |s| e.encode(s))?;
 175                 i += 1;
 176             }
 177             Ok(())
 178         })
 179     }
 180 }
 181
 182 impl<T, S> Decodable for HashSet<T, S>
 183     where T: Decodable + Hash + Eq,
 184           S: BuildHasher + Default,
 185 {
 186     fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> {
 187         d.read_seq(|d, len| {
 188             let state = Default::default();
 189             let mut set = HashSet::with_capacity_and_hasher(len, state);
 190             for i in 0..len {
 191                 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
 192             }
 193             Ok(set)
 194         })
 195     }
 196 }