1use std::borrow::Cow;
4use std::cell::{Cell, RefCell};
5use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
6use std::hash::{BuildHasher, Hash};
7use std::marker::PhantomData;
8use std::ops::Range;
9use std::path::PathBuf;
10use std::rc::Rc;
11use std::sync::Arc;
12
13use super::{Archive, ArchiveError, ArchiveRc, Decoder, Encoder};
14
15impl Archive for bool {
16 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
17 encoder.write_u8(u8::from(*self));
18 Ok(())
19 }
20
21 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
22 match decoder.read_u8()? {
23 0 => Ok(false),
24 1 => Ok(true),
25 byte => Err(ArchiveError::invalid(format!("{byte} is no boolean"))),
26 }
27 }
28}
29
30macro_rules! archive_unsigned {
32 ($($ty:ty),*) => {$(
33 impl Archive for $ty {
34 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
35 let value = u64::try_from(*self).map_err(|_| {
36 ArchiveError::unsupported(concat!("a ", stringify!($ty), " beyond 64 bits"))
37 })?;
38 encoder.write_varint(value);
39 Ok(())
40 }
41
42 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
43 <$ty>::try_from(decoder.read_varint()?).map_err(|_| {
44 ArchiveError::invalid(concat!("integer out of range for ", stringify!($ty)))
45 })
46 }
47 }
48 )*};
49}
50
51archive_unsigned!(u8, u16, u32, u64, usize);
52
53macro_rules! archive_signed {
55 ($($ty:ty),*) => {$(
56 impl Archive for $ty {
57 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
58 let value = i64::try_from(*self).map_err(|_| {
59 ArchiveError::unsupported(concat!("an ", stringify!($ty), " beyond 64 bits"))
60 })?;
61 encoder.write_signed(value);
62 Ok(())
63 }
64
65 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
66 <$ty>::try_from(decoder.read_signed()?).map_err(|_| {
67 ArchiveError::invalid(concat!("integer out of range for ", stringify!($ty)))
68 })
69 }
70 }
71 )*};
72}
73
74archive_signed!(i8, i16, i32, i64, isize);
75
76impl Archive for f64 {
77 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
78 encoder.write_f64(*self);
79 Ok(())
80 }
81
82 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
83 decoder.read_f64()
84 }
85}
86
87impl Archive for f32 {
88 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
89 encoder.write_raw(&self.to_bits().to_le_bytes());
90 Ok(())
91 }
92
93 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
94 let mut bits = [0; 4];
95 bits.copy_from_slice(decoder.read_raw(4)?);
96 Ok(f32::from_bits(u32::from_le_bytes(bits)))
97 }
98}
99
100impl Archive for char {
101 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
102 encoder.write_varint(u64::from(*self));
103 Ok(())
104 }
105
106 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
107 u32::try_from(decoder.read_varint()?)
108 .ok()
109 .and_then(char::from_u32)
110 .ok_or_else(|| ArchiveError::invalid("not a character"))
111 }
112}
113
114impl Archive for String {
115 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
116 encoder.write_str(self);
117 Ok(())
118 }
119
120 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
121 decoder.read_str()
122 }
123}
124
125impl Archive for &'static str {
128 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
129 encoder.write_str(self);
130 Ok(())
131 }
132
133 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
134 Ok(crate::interned(&decoder.read_str()?))
135 }
136}
137
138impl Archive for Cow<'static, str> {
139 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
140 encoder.write_str(self);
141 Ok(())
142 }
143
144 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
145 decoder.read_str().map(Cow::Owned)
146 }
147}
148
149impl Archive for PathBuf {
150 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
151 let text = self
152 .to_str()
153 .ok_or_else(|| ArchiveError::unsupported("a path that is not UTF-8"))?;
154 encoder.write_str(text);
155 Ok(())
156 }
157
158 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
159 decoder.read_str().map(PathBuf::from)
160 }
161}
162
163impl Archive for () {
164 fn encode(&self, _encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
165 Ok(())
166 }
167
168 fn decode(_decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
169 Ok(())
170 }
171}
172
173impl<T: ?Sized> Archive for PhantomData<T> {
174 fn encode(&self, _encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
175 Ok(())
176 }
177
178 fn decode(_decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
179 Ok(PhantomData)
180 }
181}
182
183impl<T: Archive> Archive for Option<T> {
184 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
185 match self {
186 None => {
187 encoder.write_u8(0);
188 Ok(())
189 }
190 Some(value) => {
191 encoder.write_u8(1);
192 value.encode(encoder)
193 }
194 }
195 }
196
197 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
198 match decoder.read_u8()? {
199 0 => Ok(None),
200 1 => T::decode(decoder).map(Some),
201 byte => Err(ArchiveError::invalid(format!("{byte} is no option tag"))),
202 }
203 }
204}
205
206impl<T: Archive, E: Archive> Archive for Result<T, E> {
207 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
208 match self {
209 Ok(value) => {
210 encoder.write_u8(0);
211 value.encode(encoder)
212 }
213 Err(error) => {
214 encoder.write_u8(1);
215 error.encode(encoder)
216 }
217 }
218 }
219
220 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
221 match decoder.read_u8()? {
222 0 => T::decode(decoder).map(Ok),
223 1 => E::decode(decoder).map(Err),
224 byte => Err(ArchiveError::invalid(format!("{byte} is no result tag"))),
225 }
226 }
227}
228
229impl<T: Archive> Archive for Box<T> {
230 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
231 (**self).encode(encoder)
232 }
233
234 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
235 decoder.nested(T::decode).map(Box::new)
236 }
237}
238
239impl<T: Archive + 'static> ArchiveRc for T {
240 fn encode_rc(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
241 self.encode(encoder)
242 }
243
244 fn decode_rc(decoder: &mut Decoder<'_>) -> Result<Rc<Self>, ArchiveError> {
245 T::decode(decoder).map(Rc::new)
246 }
247}
248
249impl ArchiveRc for str {
250 fn encode_rc(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
251 encoder.write_str(self);
252 Ok(())
253 }
254
255 fn decode_rc(decoder: &mut Decoder<'_>) -> Result<Rc<Self>, ArchiveError> {
256 decoder.read_str().map(Rc::from)
257 }
258}
259
260impl<T: Archive + 'static> ArchiveRc for [T] {
261 fn encode_rc(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
262 encode_items(self.iter(), self.len(), encoder)
263 }
264
265 fn decode_rc(decoder: &mut Decoder<'_>) -> Result<Rc<Self>, ArchiveError> {
266 Vec::<T>::decode(decoder).map(Rc::from)
267 }
268}
269
270impl<T: ?Sized + ArchiveRc> Archive for Rc<T> {
271 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
272 encoder.shared(self, |encoder| (**self).encode_rc(encoder))
273 }
274
275 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
276 decoder.shared(T::decode_rc)
277 }
278}
279
280impl<T: Archive + Send + Sync + 'static> Archive for Arc<T> {
281 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
282 encoder.shared_arc(self, |encoder| (**self).encode(encoder))
283 }
284
285 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
286 decoder.shared_arc(|decoder| T::decode(decoder).map(Arc::new))
287 }
288}
289
290impl<T: Archive> Archive for RefCell<T> {
291 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
292 self.borrow().encode(encoder)
293 }
294
295 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
296 T::decode(decoder).map(RefCell::new)
297 }
298}
299
300impl<T: Archive + Copy> Archive for Cell<T> {
301 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
302 self.get().encode(encoder)
303 }
304
305 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
306 T::decode(decoder).map(Cell::new)
307 }
308}
309
310fn encode_items<'v, T: Archive + 'v>(
312 items: impl Iterator<Item = &'v T>,
313 len: usize,
314 encoder: &mut Encoder<'_>,
315) -> Result<(), ArchiveError> {
316 encoder.write_len(len);
317 items.into_iter().try_for_each(|item| item.encode(encoder))
318}
319
320fn decode_items<T: Archive, C: FromIterator<T>>(
322 decoder: &mut Decoder<'_>,
323) -> Result<C, ArchiveError> {
324 let len = decoder.read_sequence_len()?;
325 decoder.nested(|decoder| (0..len).map(|_| T::decode(decoder)).collect())
326}
327
328impl<T: Archive> Archive for Vec<T> {
329 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
330 encode_items(self.iter(), self.len(), encoder)
331 }
332
333 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
334 decode_items(decoder)
335 }
336}
337
338impl<T: Archive> Archive for VecDeque<T> {
339 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
340 encode_items(self.iter(), self.len(), encoder)
341 }
342
343 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
344 decode_items(decoder)
345 }
346}
347
348impl<T: Archive + Ord> Archive for BTreeSet<T> {
349 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
350 encode_items(self.iter(), self.len(), encoder)
351 }
352
353 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
354 decode_items(decoder)
355 }
356}
357
358impl<T: Archive + Eq + Hash, S: BuildHasher + Default> Archive for HashSet<T, S> {
359 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
360 encode_items(self.iter(), self.len(), encoder)
361 }
362
363 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
364 decode_items(decoder)
365 }
366}
367
368impl<K: Archive + Ord, V: Archive> Archive for BTreeMap<K, V> {
369 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
370 encoder.write_len(self.len());
371 self.iter().try_for_each(|(key, value)| {
372 key.encode(encoder)?;
373 value.encode(encoder)
374 })
375 }
376
377 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
378 decode_items::<(K, V), _>(decoder)
379 }
380}
381
382impl<K: Archive + Eq + Hash, V: Archive, S: BuildHasher + Default> Archive for HashMap<K, V, S> {
383 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
384 encoder.write_len(self.len());
385 self.iter().try_for_each(|(key, value)| {
386 key.encode(encoder)?;
387 value.encode(encoder)
388 })
389 }
390
391 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
392 decode_items::<(K, V), _>(decoder)
393 }
394}
395
396impl<T: Archive, const N: usize> Archive for [T; N] {
397 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
398 self.iter().try_for_each(|item| item.encode(encoder))
399 }
400
401 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
402 let items: Vec<T> = (0..N)
403 .map(|_| T::decode(decoder))
404 .collect::<Result<_, _>>()?;
405 items
406 .try_into()
407 .map_err(|_| ArchiveError::invalid("array of the wrong length"))
408 }
409}
410
411impl<T: Archive> Archive for Range<T> {
412 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
413 self.start.encode(encoder)?;
414 self.end.encode(encoder)
415 }
416
417 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
418 Ok(T::decode(decoder)?..T::decode(decoder)?)
419 }
420}
421
422macro_rules! archive_tuple {
424 ($($name:ident),+) => {
425 impl<$($name: Archive),+> Archive for ($($name,)+) {
426 #[allow(non_snake_case, reason = "the elements are named after their types")]
427 fn encode(&self, encoder: &mut Encoder<'_>) -> Result<(), ArchiveError> {
428 let ($($name,)+) = self;
429 $($name.encode(encoder)?;)+
430 Ok(())
431 }
432
433 fn decode(decoder: &mut Decoder<'_>) -> Result<Self, ArchiveError> {
434 Ok(($($name::decode(decoder)?,)+))
435 }
436 }
437 };
438}
439
440archive_tuple!(A);
441archive_tuple!(A, B);
442archive_tuple!(A, B, C);
443archive_tuple!(A, B, C, D);
444archive_tuple!(A, B, C, D, E);
445archive_tuple!(A, B, C, D, E, F);
446archive_tuple!(A, B, C, D, E, F, G);
447archive_tuple!(A, B, C, D, E, F, G, H);