rustc_serialize/
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
13use std::hash::Hash;
14
15use {Decodable, Encodable, Decoder, Encoder, cap_capacity};
16use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet};
17
18impl<
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                try!(s.emit_seq_elt(i, |s| e.encode(s)));
25            }
26            Ok(())
27        })
28    }
29}
30
31impl<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(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
37            }
38            Ok(list)
39        })
40    }
41}
42
43impl<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                try!(s.emit_seq_elt(i, |s| e.encode(s)));
48            }
49            Ok(())
50        })
51    }
52}
53
54impl<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(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
60            }
61            Ok(deque)
62        })
63    }
64}
65
66impl<
67    K: Encodable + Ord,
68    V: Encodable
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.iter() {
74                try!(e.emit_map_elt_key(i, |e| key.encode(e)));
75                try!(e.emit_map_elt_val(i, |e| val.encode(e)));
76                i += 1;
77            }
78            Ok(())
79        })
80    }
81}
82
83impl<
84    K: Decodable + Ord,
85    V: Decodable
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 = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
92                let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
93                map.insert(key, val);
94            }
95            Ok(map)
96        })
97    }
98}
99
100impl<
101    T: Encodable + 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.iter() {
107                try!(s.emit_seq_elt(i, |s| e.encode(s)));
108                i += 1;
109            }
110            Ok(())
111        })
112    }
113}
114
115impl<
116    T: Decodable + 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(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
123            }
124            Ok(set)
125        })
126    }
127}
128
129impl<K, V> Encodable for HashMap<K, V>
130    where K: Encodable + Hash + Eq,
131          V: Encodable,
132{
133    fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
134        e.emit_map(self.len(), |e| {
135            let mut i = 0;
136            for (key, val) in self.iter() {
137                try!(e.emit_map_elt_key(i, |e| key.encode(e)));
138                try!(e.emit_map_elt_val(i, |e| val.encode(e)));
139                i += 1;
140            }
141            Ok(())
142        })
143    }
144}
145
146impl<K, V> Decodable for HashMap<K, V>
147    where K: Decodable + Hash + Eq,
148          V: Decodable,
149{
150    fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V>, D::Error> {
151        d.read_map(|d, len| {
152            let mut map = HashMap::with_capacity(cap_capacity::<(K, V)>(len));
153            for i in 0..len {
154                let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
155                let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
156                map.insert(key, val);
157            }
158            Ok(map)
159        })
160    }
161}
162
163impl<T> Encodable for HashSet<T> where T: Encodable + Hash + Eq {
164    fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
165        s.emit_seq(self.len(), |s| {
166            let mut i = 0;
167            for e in self.iter() {
168                try!(s.emit_seq_elt(i, |s| e.encode(s)));
169                i += 1;
170            }
171            Ok(())
172        })
173    }
174}
175
176impl<T> Decodable for HashSet<T> where T: Decodable + Hash + Eq, {
177    fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T>, D::Error> {
178        d.read_seq(|d, len| {
179            let mut set = HashSet::with_capacity(cap_capacity::<T>(len));
180            for i in 0..len {
181                set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
182            }
183            Ok(set)
184        })
185    }
186}
rustc_serialize/collection_impls.rs

rustc_serialize/
collection_impls.rs
