Skip to main content

pltrs_core/archive/
std_impls.rs

1//! [`Archive`] for the standard library's types.
2
3use 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
30/// [`Archive`] for unsigned integers, as varints.
31macro_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
53/// [`Archive`] for signed integers, as zigzag varints.
54macro_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
125/// Strings read back as `&'static str` are interned: each distinct string
126/// is allocated once, for the life of the process.
127impl 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
310/// Writes `len` items, the length first.
311fn 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
320/// Reads items written by [`encode_items`] into a collection.
321fn 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
422/// [`Archive`] for tuples, element by element.
423macro_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);