1 //! Implementations of serialization for structures found in liballoc
3 use std::hash::{BuildHasher, Hash};
5 use crate::{Decodable, Decoder, Encodable, Encoder};
6 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, LinkedList, VecDeque};
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>
84 K: Encodable + PartialEq + Ord,
87 fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
88 e.emit_map(self.len(), |e| {
90 for (key, val) in self {
91 e.emit_map_elt_key(i, |e| key.encode(e))?;
92 e.emit_map_elt_val(i, |e| val.encode(e))?;
100 impl<K, V> Decodable for BTreeMap<K, V>
102 K: Decodable + PartialEq + Ord,
105 fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
106 d.read_map(|d, len| {
107 let mut map = BTreeMap::new();
109 let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?;
110 let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?;
111 map.insert(key, val);
118 impl<T> Encodable for BTreeSet<T>
120 T: Encodable + PartialEq + Ord,
122 fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
123 s.emit_seq(self.len(), |s| {
126 s.emit_seq_elt(i, |s| e.encode(s))?;
134 impl<T> Decodable for BTreeSet<T>
136 T: Decodable + PartialEq + Ord,
138 fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
139 d.read_seq(|d, len| {
140 let mut set = BTreeSet::new();
142 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
149 impl<K, V, S> Encodable for HashMap<K, V, S>
155 fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
156 e.emit_map(self.len(), |e| {
158 for (key, val) in self {
159 e.emit_map_elt_key(i, |e| key.encode(e))?;
160 e.emit_map_elt_val(i, |e| val.encode(e))?;
168 impl<K, V, S> Decodable for HashMap<K, V, S>
170 K: Decodable + Hash + Eq,
172 S: BuildHasher + Default,
174 fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> {
175 d.read_map(|d, len| {
176 let state = Default::default();
177 let mut map = HashMap::with_capacity_and_hasher(len, state);
179 let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?;
180 let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?;
181 map.insert(key, val);
188 impl<T, S> Encodable for HashSet<T, S>
193 fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
194 s.emit_seq(self.len(), |s| {
197 s.emit_seq_elt(i, |s| e.encode(s))?;
205 impl<T, S> Decodable for HashSet<T, S>
207 T: Decodable + Hash + Eq,
208 S: BuildHasher + Default,
210 fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> {
211 d.read_seq(|d, len| {
212 let state = Default::default();
213 let mut set = HashSet::with_capacity_and_hasher(len, state);
215 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
222 impl<K, V, S> Encodable for indexmap::IndexMap<K, V, S>
224 K: Encodable + Hash + Eq,
228 fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
229 e.emit_map(self.len(), |e| {
231 for (key, val) in self {
232 e.emit_map_elt_key(i, |e| key.encode(e))?;
233 e.emit_map_elt_val(i, |e| val.encode(e))?;
241 impl<K, V, S> Decodable for indexmap::IndexMap<K, V, S>
243 K: Decodable + Hash + Eq,
245 S: BuildHasher + Default,
247 fn decode<D: Decoder>(d: &mut D) -> Result<indexmap::IndexMap<K, V, S>, D::Error> {
248 d.read_map(|d, len| {
249 let state = Default::default();
250 let mut map = indexmap::IndexMap::with_capacity_and_hasher(len, state);
252 let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?;
253 let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?;
254 map.insert(key, val);
261 impl<T, S> Encodable for indexmap::IndexSet<T, S>
263 T: Encodable + Hash + Eq,
266 fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
267 s.emit_seq(self.len(), |s| {
270 s.emit_seq_elt(i, |s| e.encode(s))?;
278 impl<T, S> Decodable for indexmap::IndexSet<T, S>
280 T: Decodable + Hash + Eq,
281 S: BuildHasher + Default,
283 fn decode<D: Decoder>(d: &mut D) -> Result<indexmap::IndexSet<T, S>, D::Error> {
284 d.read_seq(|d, len| {
285 let state = Default::default();
286 let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state);
288 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
295 impl<T: Encodable> Encodable for Rc<[T]> {
296 fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
297 s.emit_seq(self.len(), |s| {
298 for (index, e) in self.iter().enumerate() {
299 s.emit_seq_elt(index, |s| e.encode(s))?;
306 impl<T: Decodable> Decodable for Rc<[T]> {
307 fn decode<D: Decoder>(d: &mut D) -> Result<Rc<[T]>, D::Error> {
308 d.read_seq(|d, len| {
309 let mut vec = Vec::with_capacity(len);
310 for index in 0..len {
311 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);
318 impl<T: Encodable> Encodable for Arc<[T]> {
319 fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
320 s.emit_seq(self.len(), |s| {
321 for (index, e) in self.iter().enumerate() {
322 s.emit_seq_elt(index, |s| e.encode(s))?;
329 impl<T: Decodable> Decodable for Arc<[T]> {
330 fn decode<D: Decoder>(d: &mut D) -> Result<Arc<[T]>, D::Error> {
331 d.read_seq(|d, len| {
332 let mut vec = Vec::with_capacity(len);
333 for index in 0..len {
334 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);