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;
  16 use std::collections::hash_state::HashState;
  17
  18 use {Decodable, Encodable, Decoder, Encoder};
  19 use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet, VecMap};
  20 use collections::enum_set::{EnumSet, CLike};
  21
  22 impl<
  23     T: Encodable
  24 > Encodable for LinkedList<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 LinkedList<T> {
  36     fn decode<D: Decoder>(d: &mut D) -> Result<LinkedList<T>, D::Error> {
  37         d.read_seq(|d, len| {
  38             let mut list = LinkedList::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 VecDeque<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 VecDeque<T> {
  59     fn decode<D: Decoder>(d: &mut D) -> Result<VecDeque<T>, D::Error> {
  60         d.read_seq(|d, len| {
  61             let mut deque: VecDeque<T> = VecDeque::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 + Eq,
 162           V: Encodable,
 163           S: HashState,
 164 {
 165     fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
 166         e.emit_map(self.len(), |e| {
 167             let mut i = 0;
 168             for (key, val) in self {
 169                 try!(e.emit_map_elt_key(i, |e| key.encode(e)));
 170                 try!(e.emit_map_elt_val(i, |e| val.encode(e)));
 171                 i += 1;
 172             }
 173             Ok(())
 174         })
 175     }
 176 }
 177
 178 impl<K, V, S> Decodable for HashMap<K, V, S>
 179     where K: Decodable + Hash + Eq,
 180           V: Decodable,
 181           S: HashState + Default,
 182 {
 183     fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> {
 184         d.read_map(|d, len| {
 185             let state = Default::default();
 186             let mut map = HashMap::with_capacity_and_hash_state(len, state);
 187             for i in 0..len {
 188                 let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
 189                 let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
 190                 map.insert(key, val);
 191             }
 192             Ok(map)
 193         })
 194     }
 195 }
 196
 197 impl<T, S> Encodable for HashSet<T, S>
 198     where T: Encodable + Hash + Eq,
 199           S: HashState,
 200 {
 201     fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
 202         s.emit_seq(self.len(), |s| {
 203             let mut i = 0;
 204             for e in self {
 205                 try!(s.emit_seq_elt(i, |s| e.encode(s)));
 206                 i += 1;
 207             }
 208             Ok(())
 209         })
 210     }
 211 }
 212
 213 impl<T, S> Decodable for HashSet<T, S>
 214     where T: Decodable + Hash + Eq,
 215           S: HashState + Default,
 216 {
 217     fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> {
 218         d.read_seq(|d, len| {
 219             let state = Default::default();
 220             let mut set = HashSet::with_capacity_and_hash_state(len, state);
 221             for i in 0..len {
 222                 set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
 223             }
 224             Ok(set)
 225         })
 226     }
 227 }
 228
 229 impl<V: Encodable> Encodable for VecMap<V> {
 230     fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
 231         e.emit_map(self.len(), |e| {
 232                 for (i, (key, val)) in self.iter().enumerate() {
 233                     try!(e.emit_map_elt_key(i, |e| key.encode(e)));
 234                     try!(e.emit_map_elt_val(i, |e| val.encode(e)));
 235                 }
 236                 Ok(())
 237             })
 238     }
 239 }
 240
 241 impl<V: Decodable> Decodable for VecMap<V> {
 242     fn decode<D: Decoder>(d: &mut D) -> Result<VecMap<V>, D::Error> {
 243         d.read_map(|d, len| {
 244             let mut map = VecMap::new();
 245             for i in 0..len {
 246                 let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
 247                 let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
 248                 map.insert(key, val);
 249             }
 250             Ok(map)
 251         })
 252     }
 253 }