1 //! Implementations of serialization for structures found in liballoc
3 use std::hash::{Hash, BuildHasher};
5 use crate::{Decodable, Encodable, Decoder, Encoder};
6 use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet};
10 use smallvec::{Array, SmallVec};
12 impl<A: Array<Item: Encodable>> Encodable for SmallVec<A> {
13 fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
14 s.emit_seq(self.len(), |s| {
15 for (i, e) in self.iter().enumerate() {
16 s.emit_seq_elt(i, |s| e.encode(s))?;
23 impl<A: Array<Item: Decodable>> Decodable for SmallVec<A> {
24 fn decode<D: Decoder>(d: &mut D) -> Result<SmallVec<A>, D::Error> {
26 let mut vec = SmallVec::with_capacity(len);
27 // FIXME(#48994) - could just be collected into a Result<SmallVec, D::Error>
29 vec.push(d.read_seq_elt(i, |d| Decodable::decode(d))?);
36 impl<T: Encodable> Encodable for LinkedList<T> {
37 fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
38 s.emit_seq(self.len(), |s| {
39 for (i, e) in self.iter().enumerate() {
40 s.emit_seq_elt(i, |s| e.encode(s))?;
47 impl<T:Decodable> Decodable for LinkedList<T> {
48 fn decode<D: Decoder>(d: &mut D) -> Result<LinkedList<T>, D::Error> {
50 let mut list = LinkedList::new();
52 list.push_back(d.read_seq_elt(i, |d| Decodable::decode(d))?);
59 impl<T: Encodable> Encodable for VecDeque<T> {
60 fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
61 s.emit_seq(self.len(), |s| {
62 for (i, e) in self.iter().enumerate() {
63 s.emit_seq_elt(i, |s| e.encode(s))?;
70 impl<T:Decodable> Decodable for VecDeque<T> {
71 fn decode<D: Decoder>(d: &mut D) -> Result<VecDeque<T>, D::Error> {
73 let mut deque: VecDeque<T> = VecDeque::with_capacity(len);
75 deque.push_back(d.read_seq_elt(i, |d| Decodable::decode(d))?);
82 impl<K, V> Encodable for BTreeMap<K, V>
83 where K: Encodable + PartialEq + Ord,
86 fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
87 e.emit_map(self.len(), |e| {
89 for (key, val) in self {
90 e.emit_map_elt_key(i, |e| key.encode(e))?;
91 e.emit_map_elt_val(i, |e| val.encode(e))?;
99 impl<K, V> Decodable for BTreeMap<K, V>
100 where K: Decodable + PartialEq + Ord,
103 fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
104 d.read_map(|d, len| {
105 let mut map = BTreeMap::new();
107 let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?;
108 let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?;
109 map.insert(key, val);
116 impl<T> Encodable for BTreeSet<T>
117 where T: Encodable + PartialEq + Ord
119 fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
120 s.emit_seq(self.len(), |s| {
123 s.emit_seq_elt(i, |s| e.encode(s))?;
131 impl<T> Decodable for BTreeSet<T>
132 where T: Decodable + PartialEq + Ord
134 fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
135 d.read_seq(|d, len| {
136 let mut set = BTreeSet::new();
138 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
145 impl<K, V, S> Encodable for HashMap<K, V, S>
146 where K: Encodable + Eq,
150 fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
151 e.emit_map(self.len(), |e| {
153 for (key, val) in self {
154 e.emit_map_elt_key(i, |e| key.encode(e))?;
155 e.emit_map_elt_val(i, |e| val.encode(e))?;
163 impl<K, V, S> Decodable for HashMap<K, V, S>
164 where K: Decodable + Hash + Eq,
166 S: BuildHasher + Default,
168 fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> {
169 d.read_map(|d, len| {
170 let state = Default::default();
171 let mut map = HashMap::with_capacity_and_hasher(len, state);
173 let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?;
174 let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?;
175 map.insert(key, val);
182 impl<T, S> Encodable for HashSet<T, S>
183 where T: Encodable + Eq,
186 fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
187 s.emit_seq(self.len(), |s| {
190 s.emit_seq_elt(i, |s| e.encode(s))?;
198 impl<T, S> Decodable for HashSet<T, S>
199 where T: Decodable + Hash + Eq,
200 S: BuildHasher + Default,
202 fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> {
203 d.read_seq(|d, len| {
204 let state = Default::default();
205 let mut set = HashSet::with_capacity_and_hasher(len, state);
207 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
214 impl<K, V, S> Encodable for indexmap::IndexMap<K, V, S>
215 where K: Encodable + Hash + Eq,
219 fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
220 e.emit_map(self.len(), |e| {
222 for (key, val) in self {
223 e.emit_map_elt_key(i, |e| key.encode(e))?;
224 e.emit_map_elt_val(i, |e| val.encode(e))?;
232 impl<K, V, S> Decodable for indexmap::IndexMap<K, V, S>
233 where K: Decodable + Hash + Eq,
235 S: BuildHasher + Default,
237 fn decode<D: Decoder>(d: &mut D) -> Result<indexmap::IndexMap<K, V, S>, D::Error> {
238 d.read_map(|d, len| {
239 let state = Default::default();
240 let mut map = indexmap::IndexMap::with_capacity_and_hasher(len, state);
242 let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?;
243 let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?;
244 map.insert(key, val);
251 impl<T, S> Encodable for indexmap::IndexSet<T, S>
252 where T: Encodable + Hash + Eq,
255 fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
256 s.emit_seq(self.len(), |s| {
259 s.emit_seq_elt(i, |s| e.encode(s))?;
267 impl<T, S> Decodable for indexmap::IndexSet<T, S>
268 where T: Decodable + Hash + Eq,
269 S: BuildHasher + Default,
271 fn decode<D: Decoder>(d: &mut D) -> Result<indexmap::IndexSet<T, S>, D::Error> {
272 d.read_seq(|d, len| {
273 let state = Default::default();
274 let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state);
276 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
283 impl<T: Encodable> Encodable for Rc<[T]> {
284 fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
285 s.emit_seq(self.len(), |s| {
286 for (index, e) in self.iter().enumerate() {
287 s.emit_seq_elt(index, |s| e.encode(s))?;
294 impl<T: Decodable> Decodable for Rc<[T]> {
295 fn decode<D: Decoder>(d: &mut D) -> Result<Rc<[T]>, D::Error> {
296 d.read_seq(|d, len| {
297 let mut vec = Vec::with_capacity(len);
298 for index in 0..len {
299 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);
306 impl<T: Encodable> Encodable for Arc<[T]> {
307 fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
308 s.emit_seq(self.len(), |s| {
309 for (index, e) in self.iter().enumerate() {
310 s.emit_seq_elt(index, |s| e.encode(s))?;
317 impl<T: Decodable> Decodable for Arc<[T]> {
318 fn decode<D: Decoder>(d: &mut D) -> Result<Arc<[T]>, D::Error> {
319 d.read_seq(|d, len| {
320 let mut vec = Vec::with_capacity(len);
321 for index in 0..len {
322 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);