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> Encodable for SmallVec<A>
16 fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
17 s.emit_seq(self.len(), |s| {
18 for (i, e) in self.iter().enumerate() {
19 s.emit_seq_elt(i, |s| e.encode(s))?;
26 impl<A> Decodable for SmallVec<A>
30 fn decode<D: Decoder>(d: &mut D) -> Result<SmallVec<A>, D::Error> {
32 let mut vec = SmallVec::with_capacity(len);
33 // FIXME(#48994) - could just be collected into a Result<SmallVec, D::Error>
35 vec.push(d.read_seq_elt(i, |d| Decodable::decode(d))?);
42 impl<T: Encodable> Encodable for LinkedList<T> {
43 fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
44 s.emit_seq(self.len(), |s| {
45 for (i, e) in self.iter().enumerate() {
46 s.emit_seq_elt(i, |s| e.encode(s))?;
53 impl<T:Decodable> Decodable for LinkedList<T> {
54 fn decode<D: Decoder>(d: &mut D) -> Result<LinkedList<T>, D::Error> {
56 let mut list = LinkedList::new();
58 list.push_back(d.read_seq_elt(i, |d| Decodable::decode(d))?);
65 impl<T: Encodable> Encodable for VecDeque<T> {
66 fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
67 s.emit_seq(self.len(), |s| {
68 for (i, e) in self.iter().enumerate() {
69 s.emit_seq_elt(i, |s| e.encode(s))?;
76 impl<T:Decodable> Decodable for VecDeque<T> {
77 fn decode<D: Decoder>(d: &mut D) -> Result<VecDeque<T>, D::Error> {
79 let mut deque: VecDeque<T> = VecDeque::with_capacity(len);
81 deque.push_back(d.read_seq_elt(i, |d| Decodable::decode(d))?);
88 impl<K, V> Encodable for BTreeMap<K, V>
89 where K: Encodable + PartialEq + Ord,
92 fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
93 e.emit_map(self.len(), |e| {
95 for (key, val) in self {
96 e.emit_map_elt_key(i, |e| key.encode(e))?;
97 e.emit_map_elt_val(i, |e| val.encode(e))?;
105 impl<K, V> Decodable for BTreeMap<K, V>
106 where K: Decodable + PartialEq + Ord,
109 fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
110 d.read_map(|d, len| {
111 let mut map = BTreeMap::new();
113 let key = d.read_map_elt_key(i, |d| Decodable::decode(d))?;
114 let val = d.read_map_elt_val(i, |d| Decodable::decode(d))?;
115 map.insert(key, val);
122 impl<T> Encodable for BTreeSet<T>
123 where T: Encodable + PartialEq + Ord
125 fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
126 s.emit_seq(self.len(), |s| {
129 s.emit_seq_elt(i, |s| e.encode(s))?;
137 impl<T> Decodable for BTreeSet<T>
138 where T: Decodable + PartialEq + Ord
140 fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
141 d.read_seq(|d, len| {
142 let mut set = BTreeSet::new();
144 set.insert(d.read_seq_elt(i, |d| Decodable::decode(d))?);
151 impl<K, V, S> Encodable for HashMap<K, V, S>
152 where K: Encodable + Hash + Eq,
156 fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
157 e.emit_map(self.len(), |e| {
159 for (key, val) in self {
160 e.emit_map_elt_key(i, |e| key.encode(e))?;
161 e.emit_map_elt_val(i, |e| val.encode(e))?;
169 impl<K, V, S> Decodable for HashMap<K, V, S>
170 where 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>
189 where T: Encodable + Hash + Eq,
192 fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
193 s.emit_seq(self.len(), |s| {
196 s.emit_seq_elt(i, |s| e.encode(s))?;
204 impl<T, S> Decodable for HashSet<T, S>
205 where T: Decodable + Hash + Eq,
206 S: BuildHasher + Default,
208 fn decode<D: Decoder>(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(i, |d| Decodable::decode(d))?);
220 impl<T: Encodable> Encodable for Rc<[T]> {
221 fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
222 s.emit_seq(self.len(), |s| {
223 for (index, e) in self.iter().enumerate() {
224 s.emit_seq_elt(index, |s| e.encode(s))?;
231 impl<T: Decodable> Decodable for Rc<[T]> {
232 fn decode<D: Decoder>(d: &mut D) -> Result<Rc<[T]>, D::Error> {
233 d.read_seq(|d, len| {
234 let mut vec = Vec::with_capacity(len);
235 for index in 0..len {
236 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);
243 impl<T: Encodable> Encodable for Arc<[T]> {
244 fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
245 s.emit_seq(self.len(), |s| {
246 for (index, e) in self.iter().enumerate() {
247 s.emit_seq_elt(index, |s| e.encode(s))?;
254 impl<T: Decodable> Decodable for Arc<[T]> {
255 fn decode<D: Decoder>(d: &mut D) -> Result<Arc<[T]>, D::Error> {
256 d.read_seq(|d, len| {
257 let mut vec = Vec::with_capacity(len);
258 for index in 0..len {
259 vec.push(d.read_seq_elt(index, |d| Decodable::decode(d))?);