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<S: Encoder, A: Array<Item: Encodable<S>>> Encodable<S> for SmallVec<A> {
13 fn encode(&self, s: &mut S) -> Result<(), S::Error> {
14 let slice: &[A::Item] = self;
19 impl<D: Decoder, A: Array<Item: Decodable<D>>> Decodable<D> for SmallVec<A> {
20 fn decode(d: &mut D) -> Result<SmallVec<A>, D::Error> {
22 let mut vec = SmallVec::with_capacity(len);
23 // FIXME(#48994) - could just be collected into a Result<SmallVec, D::Error>
25 vec.push(d.read_seq_elt(|d| Decodable::decode(d))?);
32 impl<S: Encoder, T: Encodable<S>> Encodable<S> for LinkedList<T> {
33 fn encode(&self, s: &mut S) -> Result<(), S::Error> {
34 s.emit_seq(self.len(), |s| {
35 for (i, e) in self.iter().enumerate() {
36 s.emit_seq_elt(i, |s| e.encode(s))?;
43 impl<D: Decoder, T: Decodable<D>> Decodable<D> for LinkedList<T> {
44 fn decode(d: &mut D) -> Result<LinkedList<T>, D::Error> {
46 let mut list = LinkedList::new();
48 list.push_back(d.read_seq_elt(|d| Decodable::decode(d))?);
55 impl<S: Encoder, T: Encodable<S>> Encodable<S> for VecDeque<T> {
56 fn encode(&self, s: &mut S) -> Result<(), S::Error> {
57 s.emit_seq(self.len(), |s| {
58 for (i, e) in self.iter().enumerate() {
59 s.emit_seq_elt(i, |s| e.encode(s))?;
66 impl<D: Decoder, T: Decodable<D>> Decodable<D> for VecDeque<T> {
67 fn decode(d: &mut D) -> Result<VecDeque<T>, D::Error> {
69 let mut deque: VecDeque<T> = VecDeque::with_capacity(len);
71 deque.push_back(d.read_seq_elt(|d| Decodable::decode(d))?);
78 impl<S: Encoder, K, V> Encodable<S> for BTreeMap<K, V>
80 K: Encodable<S> + PartialEq + Ord,
83 fn encode(&self, e: &mut S) -> Result<(), S::Error> {
84 e.emit_map(self.len(), |e| {
85 for (i, (key, val)) in self.iter().enumerate() {
86 e.emit_map_elt_key(i, |e| key.encode(e))?;
87 e.emit_map_elt_val(|e| val.encode(e))?;
94 impl<D: Decoder, K, V> Decodable<D> for BTreeMap<K, V>
96 K: Decodable<D> + PartialEq + Ord,
99 fn decode(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
100 d.read_map(|d, len| {
101 let mut map = BTreeMap::new();
103 let key = d.read_map_elt_key(|d| Decodable::decode(d))?;
104 let val = d.read_map_elt_val(|d| Decodable::decode(d))?;
105 map.insert(key, val);
112 impl<S: Encoder, T> Encodable<S> for BTreeSet<T>
114 T: Encodable<S> + PartialEq + Ord,
116 fn encode(&self, s: &mut S) -> Result<(), S::Error> {
117 s.emit_seq(self.len(), |s| {
118 for (i, e) in self.iter().enumerate() {
119 s.emit_seq_elt(i, |s| e.encode(s))?;
126 impl<D: Decoder, T> Decodable<D> for BTreeSet<T>
128 T: Decodable<D> + PartialEq + Ord,
130 fn decode(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
131 d.read_seq(|d, len| {
132 let mut set = BTreeSet::new();
134 set.insert(d.read_seq_elt(|d| Decodable::decode(d))?);
141 impl<E: Encoder, K, V, S> Encodable<E> for HashMap<K, V, S>
143 K: Encodable<E> + Eq,
147 fn encode(&self, e: &mut E) -> Result<(), E::Error> {
148 e.emit_map(self.len(), |e| {
149 for (i, (key, val)) in self.iter().enumerate() {
150 e.emit_map_elt_key(i, |e| key.encode(e))?;
151 e.emit_map_elt_val(|e| val.encode(e))?;
158 impl<D: Decoder, K, V, S> Decodable<D> for HashMap<K, V, S>
160 K: Decodable<D> + Hash + Eq,
162 S: BuildHasher + Default,
164 fn decode(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> {
165 d.read_map(|d, len| {
166 let state = Default::default();
167 let mut map = HashMap::with_capacity_and_hasher(len, state);
169 let key = d.read_map_elt_key(|d| Decodable::decode(d))?;
170 let val = d.read_map_elt_val(|d| Decodable::decode(d))?;
171 map.insert(key, val);
178 impl<E: Encoder, T, S> Encodable<E> for HashSet<T, S>
180 T: Encodable<E> + Eq,
183 fn encode(&self, s: &mut E) -> Result<(), E::Error> {
184 s.emit_seq(self.len(), |s| {
185 for (i, e) in self.iter().enumerate() {
186 s.emit_seq_elt(i, |s| e.encode(s))?;
193 impl<E: Encoder, T, S> Encodable<E> for &HashSet<T, S>
195 T: Encodable<E> + Eq,
198 fn encode(&self, s: &mut E) -> Result<(), E::Error> {
203 impl<D: Decoder, T, S> Decodable<D> for HashSet<T, S>
205 T: Decodable<D> + Hash + Eq,
206 S: BuildHasher + Default,
208 fn decode(d: &mut D) -> Result<HashSet<T, S>, D::Error> {
209 d.read_seq(|d, len| {
210 let state = Default::default();
211 let mut set = HashSet::with_capacity_and_hasher(len, state);
213 set.insert(d.read_seq_elt(|d| Decodable::decode(d))?);
220 impl<E: Encoder, K, V, S> Encodable<E> for indexmap::IndexMap<K, V, S>
222 K: Encodable<E> + Hash + Eq,
226 fn encode(&self, e: &mut E) -> Result<(), E::Error> {
227 e.emit_map(self.len(), |e| {
228 for (i, (key, val)) in self.iter().enumerate() {
229 e.emit_map_elt_key(i, |e| key.encode(e))?;
230 e.emit_map_elt_val(|e| val.encode(e))?;
237 impl<D: Decoder, K, V, S> Decodable<D> for indexmap::IndexMap<K, V, S>
239 K: Decodable<D> + Hash + Eq,
241 S: BuildHasher + Default,
243 fn decode(d: &mut D) -> Result<indexmap::IndexMap<K, V, S>, D::Error> {
244 d.read_map(|d, len| {
245 let state = Default::default();
246 let mut map = indexmap::IndexMap::with_capacity_and_hasher(len, state);
248 let key = d.read_map_elt_key(|d| Decodable::decode(d))?;
249 let val = d.read_map_elt_val(|d| Decodable::decode(d))?;
250 map.insert(key, val);
257 impl<E: Encoder, T, S> Encodable<E> for indexmap::IndexSet<T, S>
259 T: Encodable<E> + Hash + Eq,
262 fn encode(&self, s: &mut E) -> Result<(), E::Error> {
263 s.emit_seq(self.len(), |s| {
264 for (i, e) in self.iter().enumerate() {
265 s.emit_seq_elt(i, |s| e.encode(s))?;
272 impl<D: Decoder, T, S> Decodable<D> for indexmap::IndexSet<T, S>
274 T: Decodable<D> + Hash + Eq,
275 S: BuildHasher + Default,
277 fn decode(d: &mut D) -> Result<indexmap::IndexSet<T, S>, D::Error> {
278 d.read_seq(|d, len| {
279 let state = Default::default();
280 let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state);
282 set.insert(d.read_seq_elt(|d| Decodable::decode(d))?);
289 impl<E: Encoder, T: Encodable<E>> Encodable<E> for Rc<[T]> {
290 fn encode(&self, s: &mut E) -> Result<(), E::Error> {
291 let slice: &[T] = self;
296 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<[T]> {
297 fn decode(d: &mut D) -> Result<Rc<[T]>, D::Error> {
298 let vec: Vec<T> = Decodable::decode(d)?;
303 impl<E: Encoder, T: Encodable<E>> Encodable<E> for Arc<[T]> {
304 fn encode(&self, s: &mut E) -> Result<(), E::Error> {
305 let slice: &[T] = self;
310 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Arc<[T]> {
311 fn decode(d: &mut D) -> Result<Arc<[T]>, D::Error> {
312 let vec: Vec<T> = Decodable::decode(d)?;