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