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 // VecMap
  12 #![allow(deprecated)]
  13
  14 //! Implementations of serialization for structures found in libcollections
  15
  16 use std::usize;
  17 use std::default::Default;
  18 use std::hash::Hash;
  19 use std::collections::hash_state::HashState;
  20
  21 use {Decodable, Encodable, Decoder, Encoder};
  22 use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet, VecMap};
  23 use collections::enum_set::{EnumSet, CLike};
  24
  25 impl<
  26     T: Encodable
  27 > Encodable for LinkedList<T> {
  28     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
  29         s.emit_seq(self.len(), |s| {
  30             for (i, e) in self.iter().enumerate() {
  31                 try!(s.emit_seq_elt(i, |s| e.encode(s)));
  32             }
  33             Ok(())
  34         })
  35     }
  36 }
  37
  38 impl<T:Decodable> Decodable for LinkedList<T> {
  39     fn decode<D: Decoder>(d: &mut D) -> Result<LinkedList<T>, D::Error> {
  40         d.read_seq(|d, len| {
  41             let mut list = LinkedList::new();
  42             for i in 0..len {
  43                 list.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
  44             }
  45             Ok(list)
  46         })
  47     }
  48 }
  49
  50 impl<T: Encodable> Encodable for VecDeque<T> {
  51     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
  52         s.emit_seq(self.len(), |s| {
  53             for (i, e) in self.iter().enumerate() {
  54                 try!(s.emit_seq_elt(i, |s| e.encode(s)));
  55             }
  56             Ok(())
  57         })
  58     }
  59 }
  60
  61 impl<T:Decodable> Decodable for VecDeque<T> {
  62     fn decode<D: Decoder>(d: &mut D) -> Result<VecDeque<T>, D::Error> {
  63         d.read_seq(|d, len| {
  64             let mut deque: VecDeque<T> = VecDeque::new();
  65             for i in 0..len {
  66                 deque.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
  67             }
  68             Ok(deque)
  69         })
  70     }
  71 }
  72
  73 impl<
  74     K: Encodable + PartialEq + Ord,
  75     V: Encodable + PartialEq
  76 > Encodable for BTreeMap<K, V> {
  77     fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
  78         e.emit_map(self.len(), |e| {
  79             let mut i = 0;
  80             for (key, val) in self {
  81                 try!(e.emit_map_elt_key(i, |e| key.encode(e)));
  82                 try!(e.emit_map_elt_val(i, |e| val.encode(e)));
  83                 i += 1;
  84             }
  85             Ok(())
  86         })
  87     }
  88 }
  89
  90 impl<
  91     K: Decodable + PartialEq + Ord,
  92     V: Decodable + PartialEq
  93 > Decodable for BTreeMap<K, V> {
  94     fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
  95         d.read_map(|d, len| {
  96             let mut map = BTreeMap::new();
  97             for i in 0..len {
  98                 let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
  99                 let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
 100                 map.insert(key, val);
 101             }
 102             Ok(map)
 103         })
 104     }
 105 }
 106
 107 impl<
 108     T: Encodable + PartialEq + Ord
 109 > Encodable for BTreeSet<T> {
 110     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
 111         s.emit_seq(self.len(), |s| {
 112             let mut i = 0;
 113             for e in self {
 114                 try!(s.emit_seq_elt(i, |s| e.encode(s)));
 115                 i += 1;
 116             }
 117             Ok(())
 118         })
 119     }
 120 }
 121
 122 impl<
 123     T: Decodable + PartialEq + Ord
 124 > Decodable for BTreeSet<T> {
 125     fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
 126         d.read_seq(|d, len| {
 127             let mut set = BTreeSet::new();
 128             for i in 0..len {
 129                 set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
 130             }
 131             Ok(set)
 132         })
 133     }
 134 }
 135
 136 impl<
 137     T: Encodable + CLike
 138 > Encodable for EnumSet<T> {
 139     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
 140         let mut bits = 0;
 141         for item in self {
 142             bits |= item.to_usize();
 143         }
 144         s.emit_uint(bits)
 145     }
 146 }
 147
 148 impl<
 149     T: Decodable + CLike
 150 > Decodable for EnumSet<T> {
 151     fn decode<D: Decoder>(d: &mut D) -> Result<EnumSet<T>, D::Error> {
 152         let bits = try!(d.read_uint());
 153         let mut set = EnumSet::new();
 154         for bit in 0..usize::BITS {
 155             if bits & (1 << bit) != 0 {
 156                 set.insert(CLike::from_usize(1 << bit));
 157             }
 158         }
 159         Ok(set)
 160     }
 161 }
 162
 163 impl<K, V, S> Encodable for HashMap<K, V, S>
 164     where K: Encodable + Hash + Eq,
 165           V: Encodable,
 166           S: HashState,
 167 {
 168     fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
 169         e.emit_map(self.len(), |e| {
 170             let mut i = 0;
 171             for (key, val) in self {
 172                 try!(e.emit_map_elt_key(i, |e| key.encode(e)));
 173                 try!(e.emit_map_elt_val(i, |e| val.encode(e)));
 174                 i += 1;
 175             }
 176             Ok(())
 177         })
 178     }
 179 }
 180
 181 impl<K, V, S> Decodable for HashMap<K, V, S>
 182     where K: Decodable + Hash + Eq,
 183           V: Decodable,
 184           S: HashState + Default,
 185 {
 186     fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> {
 187         d.read_map(|d, len| {
 188             let state = Default::default();
 189             let mut map = HashMap::with_capacity_and_hash_state(len, state);
 190             for i in 0..len {
 191                 let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
 192                 let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
 193                 map.insert(key, val);
 194             }
 195             Ok(map)
 196         })
 197     }
 198 }
 199
 200 impl<T, S> Encodable for HashSet<T, S>
 201     where T: Encodable + Hash + Eq,
 202           S: HashState,
 203 {
 204     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 205         s.emit_seq(self.len(), |s| {
 206             let mut i = 0;
 207             for e in self {
 208                 try!(s.emit_seq_elt(i, |s| e.encode(s)));
 209                 i += 1;
 210             }
 211             Ok(())
 212         })
 213     }
 214 }
 215
 216 impl<T, S> Decodable for HashSet<T, S>
 217     where T: Decodable + Hash + Eq,
 218           S: HashState + Default,
 219 {
 220     fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> {
 221         d.read_seq(|d, len| {
 222             let state = Default::default();
 223             let mut set = HashSet::with_capacity_and_hash_state(len, state);
 224             for i in 0..len {
 225                 set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
 226             }
 227             Ok(set)
 228         })
 229     }
 230 }
 231
 232 impl<V: Encodable> Encodable for VecMap<V> {
 233     fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
 234         e.emit_map(self.len(), |e| {
 235                 for (i, (key, val)) in self.iter().enumerate() {
 236                     try!(e.emit_map_elt_key(i, |e| key.encode(e)));
 237                     try!(e.emit_map_elt_val(i, |e| val.encode(e)));
 238                 }
 239                 Ok(())
 240             })
 241     }
 242 }
 243
 244 impl<V: Decodable> Decodable for VecMap<V> {
 245     fn decode<D: Decoder>(d: &mut D) -> Result<VecMap<V>, D::Error> {
 246         d.read_map(|d, len| {
 247             let mut map = VecMap::new();
 248             for i in 0..len {
 249                 let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
 250                 let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
 251                 map.insert(key, val);
 252             }
 253             Ok(map)
 254         })
 255     }
 256 }