rkyv_test/with/
alloc.rs

1use crate::{
2    boxed::{ArchivedBox, BoxResolver},
3    collections::util::Entry,
4    niche::option_box::{ArchivedOptionBox, OptionBoxResolver},
5    ser::{ScratchSpace, Serializer},
6    string::{ArchivedString, StringResolver},
7    vec::{ArchivedVec, RawArchivedVec, VecResolver},
8    with::{
9        ArchiveWith, AsOwned, AsVec, CopyOptimize, DeserializeWith, Map, Niche, Raw, RefAsBox,
10        SerializeWith, With,
11    },
12    Archive, ArchiveUnsized, ArchivedMetadata, Deserialize, DeserializeUnsized, Fallible,
13    MetadataResolver, Serialize, SerializeUnsized,
14};
15use ::core::marker::PhantomData;
16#[cfg(not(feature = "std"))]
17use alloc::{
18    borrow::Cow,
19    boxed::Box,
20    collections::{BTreeMap, BTreeSet},
21    vec::Vec,
22};
23#[cfg(feature = "std")]
24use std::{
25    borrow::Cow,
26    boxed::Box,
27    collections::{BTreeMap, BTreeSet},
28};
29
30// Map for Vecs
31
32impl<A, O> ArchiveWith<Vec<O>> for Map<A>
33where
34    A: ArchiveWith<O>,
35{
36    type Archived = ArchivedVec<<A as ArchiveWith<O>>::Archived>;
37    type Resolver = VecResolver;
38
39    unsafe fn resolve_with(
40        field: &Vec<O>,
41        pos: usize,
42        resolver: Self::Resolver,
43        out: *mut Self::Archived,
44    ) {
45        ArchivedVec::resolve_from_len(field.len(), pos, resolver, out)
46    }
47}
48
49impl<A, O, S> SerializeWith<Vec<O>, S> for Map<A>
50where
51    S: Fallible + ScratchSpace + Serializer,
52    A: ArchiveWith<O> + SerializeWith<O, S>,
53{
54    fn serialize_with(field: &Vec<O>, s: &mut S) -> Result<Self::Resolver, S::Error> {
55        // Wrapper for O so that we have an Archive and Serialize implementation
56        // and ArchivedVec::serialize_from_* is happy about the bound constraints
57        struct RefWrapper<'o, A, O>(&'o O, PhantomData<A>);
58
59        impl<A: ArchiveWith<O>, O> Archive for RefWrapper<'_, A, O> {
60            type Archived = <A as ArchiveWith<O>>::Archived;
61            type Resolver = <A as ArchiveWith<O>>::Resolver;
62
63            unsafe fn resolve(
64                &self,
65                pos: usize,
66                resolver: Self::Resolver,
67                out: *mut Self::Archived,
68            ) {
69                A::resolve_with(self.0, pos, resolver, out)
70            }
71        }
72
73        impl<A, O, S> Serialize<S> for RefWrapper<'_, A, O>
74        where
75            A: ArchiveWith<O> + SerializeWith<O, S>,
76            S: Fallible + Serializer,
77        {
78            fn serialize(&self, s: &mut S) -> Result<Self::Resolver, S::Error> {
79                A::serialize_with(self.0, s)
80            }
81        }
82
83        let iter = field
84            .iter()
85            .map(|value| RefWrapper::<'_, A, O>(value, PhantomData));
86
87        ArchivedVec::serialize_from_iter(iter, s)
88    }
89}
90
91impl<A, O, D> DeserializeWith<ArchivedVec<<A as ArchiveWith<O>>::Archived>, Vec<O>, D> for Map<A>
92where
93    A: ArchiveWith<O> + DeserializeWith<<A as ArchiveWith<O>>::Archived, O, D>,
94    D: Fallible,
95{
96    fn deserialize_with(
97        field: &ArchivedVec<<A as ArchiveWith<O>>::Archived>,
98        d: &mut D,
99    ) -> Result<Vec<O>, D::Error> {
100        field
101            .iter()
102            .map(|value| <A as DeserializeWith<_, _, D>>::deserialize_with(value, d))
103            .collect()
104    }
105}
106
107// AsOwned
108
109impl<'a, F: Archive + Clone> ArchiveWith<Cow<'a, F>> for AsOwned {
110    type Archived = F::Archived;
111    type Resolver = F::Resolver;
112
113    #[inline]
114    unsafe fn resolve_with(
115        field: &Cow<'a, F>,
116        pos: usize,
117        resolver: Self::Resolver,
118        out: *mut Self::Archived,
119    ) {
120        field.resolve(pos, resolver, out);
121    }
122}
123
124impl<'a, F: Serialize<S> + Clone, S: Fallible + ?Sized> SerializeWith<Cow<'a, F>, S> for AsOwned {
125    #[inline]
126    fn serialize_with(field: &Cow<'a, F>, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
127        field.serialize(serializer)
128    }
129}
130
131impl<'a, T: Archive + Clone, D: Fallible + ?Sized> DeserializeWith<T::Archived, T, D> for AsOwned
132where
133    T::Archived: Deserialize<T, D>,
134{
135    #[inline]
136    fn deserialize_with(field: &T::Archived, deserializer: &mut D) -> Result<T, D::Error> {
137        field.deserialize(deserializer)
138    }
139}
140
141impl<'a, T: Archive + Clone> ArchiveWith<Cow<'a, [T]>> for AsOwned {
142    type Archived = ArchivedVec<T::Archived>;
143    type Resolver = VecResolver;
144
145    #[inline]
146    unsafe fn resolve_with(
147        field: &Cow<'a, [T]>,
148        pos: usize,
149        resolver: Self::Resolver,
150        out: *mut Self::Archived,
151    ) {
152        ArchivedVec::resolve_from_slice(field, pos, resolver, out);
153    }
154}
155
156impl<'a, T: Serialize<S> + Clone, S: ScratchSpace + Serializer + ?Sized>
157    SerializeWith<Cow<'a, [T]>, S> for AsOwned
158{
159    #[inline]
160    fn serialize_with(
161        field: &Cow<'a, [T]>,
162        serializer: &mut S,
163    ) -> Result<Self::Resolver, S::Error> {
164        ArchivedVec::serialize_from_slice(field, serializer)
165    }
166}
167
168impl<'a, T, D> DeserializeWith<ArchivedVec<T::Archived>, Cow<'a, [T]>, D> for AsOwned
169where
170    T: Archive + Clone,
171    T::Archived: Deserialize<T, D>,
172    D: Fallible + ?Sized,
173{
174    #[inline]
175    fn deserialize_with(
176        field: &ArchivedVec<T::Archived>,
177        deserializer: &mut D,
178    ) -> Result<Cow<'a, [T]>, D::Error> {
179        Ok(Cow::Owned(field.deserialize(deserializer)?))
180    }
181}
182
183impl<'a> ArchiveWith<Cow<'a, str>> for AsOwned {
184    type Archived = ArchivedString;
185    type Resolver = StringResolver;
186
187    #[inline]
188    unsafe fn resolve_with(
189        field: &Cow<'a, str>,
190        pos: usize,
191        resolver: Self::Resolver,
192        out: *mut Self::Archived,
193    ) {
194        ArchivedString::resolve_from_str(field, pos, resolver, out);
195    }
196}
197
198impl<'a, S: Serializer + ?Sized> SerializeWith<Cow<'a, str>, S> for AsOwned {
199    #[inline]
200    fn serialize_with(
201        field: &Cow<'a, str>,
202        serializer: &mut S,
203    ) -> Result<Self::Resolver, S::Error> {
204        ArchivedString::serialize_from_str(field, serializer)
205    }
206}
207
208impl<'a, D: Fallible + ?Sized> DeserializeWith<ArchivedString, Cow<'a, str>, D> for AsOwned {
209    #[inline]
210    fn deserialize_with(
211        field: &ArchivedString,
212        deserializer: &mut D,
213    ) -> Result<Cow<'a, str>, D::Error> {
214        Ok(Cow::Owned(field.deserialize(deserializer)?))
215    }
216}
217
218#[cfg(feature = "std")]
219const _: () = {
220    use crate::ffi::{ArchivedCString, CStringResolver};
221    use std::ffi::CStr;
222
223    impl<'a> ArchiveWith<Cow<'a, CStr>> for AsOwned {
224        type Archived = ArchivedCString;
225        type Resolver = CStringResolver;
226
227        #[inline]
228        unsafe fn resolve_with(
229            field: &Cow<'a, CStr>,
230            pos: usize,
231            resolver: Self::Resolver,
232            out: *mut Self::Archived,
233        ) {
234            ArchivedCString::resolve_from_c_str(field, pos, resolver, out);
235        }
236    }
237
238    impl<'a, S: Serializer + ?Sized> SerializeWith<Cow<'a, CStr>, S> for AsOwned {
239        #[inline]
240        fn serialize_with(
241            field: &Cow<'a, CStr>,
242            serializer: &mut S,
243        ) -> Result<Self::Resolver, S::Error> {
244            ArchivedCString::serialize_from_c_str(field, serializer)
245        }
246    }
247
248    impl<'a, D: Fallible + ?Sized> DeserializeWith<ArchivedCString, Cow<'a, CStr>, D> for AsOwned {
249        #[inline]
250        fn deserialize_with(
251            field: &ArchivedCString,
252            deserializer: &mut D,
253        ) -> Result<Cow<'a, CStr>, D::Error> {
254            Ok(Cow::Owned(field.deserialize(deserializer)?))
255        }
256    }
257};
258
259// AsVec
260
261impl<K: Archive, V: Archive> ArchiveWith<BTreeMap<K, V>> for AsVec {
262    type Archived = ArchivedVec<Entry<K::Archived, V::Archived>>;
263    type Resolver = VecResolver;
264
265    unsafe fn resolve_with(
266        field: &BTreeMap<K, V>,
267        pos: usize,
268        resolver: Self::Resolver,
269        out: *mut Self::Archived,
270    ) {
271        ArchivedVec::resolve_from_len(field.len(), pos, resolver, out);
272    }
273}
274
275impl<K, V, S> SerializeWith<BTreeMap<K, V>, S> for AsVec
276where
277    K: Serialize<S>,
278    V: Serialize<S>,
279    S: ScratchSpace + Serializer + ?Sized,
280{
281    fn serialize_with(
282        field: &BTreeMap<K, V>,
283        serializer: &mut S,
284    ) -> Result<Self::Resolver, S::Error> {
285        ArchivedVec::serialize_from_iter(
286            field.iter().map(|(key, value)| Entry { key, value }),
287            serializer,
288        )
289    }
290}
291
292impl<K, V, D> DeserializeWith<ArchivedVec<Entry<K::Archived, V::Archived>>, BTreeMap<K, V>, D>
293    for AsVec
294where
295    K: Archive + Ord,
296    V: Archive,
297    K::Archived: Deserialize<K, D>,
298    V::Archived: Deserialize<V, D>,
299    D: Fallible + ?Sized,
300{
301    fn deserialize_with(
302        field: &ArchivedVec<Entry<K::Archived, V::Archived>>,
303        deserializer: &mut D,
304    ) -> Result<BTreeMap<K, V>, D::Error> {
305        let mut result = BTreeMap::new();
306        for entry in field.iter() {
307            result.insert(
308                entry.key.deserialize(deserializer)?,
309                entry.value.deserialize(deserializer)?,
310            );
311        }
312        Ok(result)
313    }
314}
315
316impl<T: Archive> ArchiveWith<BTreeSet<T>> for AsVec {
317    type Archived = ArchivedVec<T::Archived>;
318    type Resolver = VecResolver;
319
320    unsafe fn resolve_with(
321        field: &BTreeSet<T>,
322        pos: usize,
323        resolver: Self::Resolver,
324        out: *mut Self::Archived,
325    ) {
326        ArchivedVec::resolve_from_len(field.len(), pos, resolver, out);
327    }
328}
329
330impl<T, S> SerializeWith<BTreeSet<T>, S> for AsVec
331where
332    T: Serialize<S>,
333    S: ScratchSpace + Serializer + ?Sized,
334{
335    fn serialize_with(field: &BTreeSet<T>, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
336        ArchivedVec::<T::Archived>::serialize_from_iter::<T, _, _, _>(field.iter(), serializer)
337    }
338}
339
340impl<T, D> DeserializeWith<ArchivedVec<T::Archived>, BTreeSet<T>, D> for AsVec
341where
342    T: Archive + Ord,
343    T::Archived: Deserialize<T, D>,
344    D: Fallible + ?Sized,
345{
346    fn deserialize_with(
347        field: &ArchivedVec<T::Archived>,
348        deserializer: &mut D,
349    ) -> Result<BTreeSet<T>, D::Error> {
350        let mut result = BTreeSet::new();
351        for key in field.iter() {
352            result.insert(key.deserialize(deserializer)?);
353        }
354        Ok(result)
355    }
356}
357
358// Niche
359
360impl<T: ArchiveUnsized + ?Sized> ArchiveWith<Option<Box<T>>> for Niche
361where
362    ArchivedMetadata<T>: Default,
363{
364    type Archived = ArchivedOptionBox<T::Archived>;
365    type Resolver = OptionBoxResolver<T::MetadataResolver>;
366
367    unsafe fn resolve_with(
368        field: &Option<Box<T>>,
369        pos: usize,
370        resolver: Self::Resolver,
371        out: *mut Self::Archived,
372    ) {
373        ArchivedOptionBox::resolve_from_option(field.as_deref(), pos, resolver, out);
374    }
375}
376
377impl<T, S> SerializeWith<Option<Box<T>>, S> for Niche
378where
379    T: SerializeUnsized<S> + ?Sized,
380    S: Serializer + ?Sized,
381    ArchivedMetadata<T>: Default,
382{
383    fn serialize_with(
384        field: &Option<Box<T>>,
385        serializer: &mut S,
386    ) -> Result<Self::Resolver, S::Error> {
387        ArchivedOptionBox::serialize_from_option(field.as_deref(), serializer)
388    }
389}
390
391impl<T, D> DeserializeWith<ArchivedOptionBox<T::Archived>, Option<Box<T>>, D> for Niche
392where
393    T: ArchiveUnsized + ?Sized,
394    T::Archived: DeserializeUnsized<T, D>,
395    D: Fallible + ?Sized,
396{
397    fn deserialize_with(
398        field: &ArchivedOptionBox<T::Archived>,
399        deserializer: &mut D,
400    ) -> Result<Option<Box<T>>, D::Error> {
401        if let Some(value) = field.as_ref() {
402            Ok(Some(value.deserialize(deserializer)?))
403        } else {
404            Ok(None)
405        }
406    }
407}
408
409// CopyOptimize
410
411impl<T: Archive> ArchiveWith<Vec<T>> for CopyOptimize {
412    type Archived = ArchivedVec<T::Archived>;
413    type Resolver = VecResolver;
414
415    unsafe fn resolve_with(
416        field: &Vec<T>,
417        pos: usize,
418        resolver: Self::Resolver,
419        out: *mut Self::Archived,
420    ) {
421        ArchivedVec::resolve_from_len(field.len(), pos, resolver, out);
422    }
423}
424
425impl<T, S> SerializeWith<Vec<T>, S> for CopyOptimize
426where
427    T: Serialize<S>,
428    S: Serializer,
429{
430    fn serialize_with(field: &Vec<T>, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
431        use ::core::mem::size_of;
432
433        // Basic debug assert that T and T::Archived are at least the same size
434        debug_assert_eq!(size_of::<T>(), size_of::<T::Archived>());
435
436        unsafe { ArchivedVec::serialize_copy_from_slice(field.as_slice(), serializer) }
437    }
438}
439
440impl<T, D> DeserializeWith<ArchivedVec<T::Archived>, Vec<T>, D> for CopyOptimize
441where
442    T: Archive,
443    T::Archived: Deserialize<T, D>,
444    D: Fallible + ?Sized,
445{
446    fn deserialize_with(field: &ArchivedVec<T::Archived>, _: &mut D) -> Result<Vec<T>, D::Error> {
447        use ::core::{mem::size_of, ptr::copy_nonoverlapping};
448
449        // Basic debug assert that T and T::Archived are at least the same size
450        debug_assert_eq!(size_of::<T>(), size_of::<T::Archived>());
451
452        let mut result = Vec::with_capacity(field.len());
453        unsafe {
454            copy_nonoverlapping(field.as_ptr().cast(), result.as_mut_ptr(), field.len());
455            result.set_len(field.len());
456        }
457
458        Ok(result)
459    }
460}
461
462impl<T: Archive> ArchiveWith<Box<[T]>> for CopyOptimize {
463    type Archived = ArchivedBox<[T::Archived]>;
464    type Resolver = BoxResolver<MetadataResolver<[T]>>;
465
466    unsafe fn resolve_with(
467        field: &Box<[T]>,
468        pos: usize,
469        resolver: Self::Resolver,
470        out: *mut Self::Archived,
471    ) {
472        ArchivedBox::resolve_from_ref(&**field, pos, resolver, out);
473    }
474}
475
476impl<T, S> SerializeWith<Box<[T]>, S> for CopyOptimize
477where
478    T: Serialize<S>,
479    S: Serializer,
480{
481    fn serialize_with(field: &Box<[T]>, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
482        use ::core::mem::size_of;
483
484        // Basic debug assert that T and T::Archived are at least the same size
485        debug_assert_eq!(size_of::<T>(), size_of::<T::Archived>());
486
487        unsafe { ArchivedBox::<[T::Archived]>::serialize_copy_from_slice(&**field, serializer) }
488    }
489}
490
491impl<T, D> DeserializeWith<ArchivedBox<[T::Archived]>, Box<[T]>, D> for CopyOptimize
492where
493    T: Archive,
494    T::Archived: Deserialize<T, D>,
495    D: Fallible + ?Sized,
496{
497    fn deserialize_with(
498        field: &ArchivedBox<[T::Archived]>,
499        _: &mut D,
500    ) -> Result<Box<[T]>, D::Error> {
501        use ::core::{mem::size_of, ptr::copy_nonoverlapping};
502
503        // Basic debug assert that T and T::Archived are at least the same size
504        debug_assert_eq!(size_of::<T>(), size_of::<T::Archived>());
505
506        let mut result = Vec::with_capacity(field.len());
507        unsafe {
508            copy_nonoverlapping(field.as_ptr().cast(), result.as_mut_ptr(), field.len());
509            result.set_len(field.len());
510        }
511
512        Ok(result.into_boxed_slice())
513    }
514}
515
516impl<'a, T: Archive> ArchiveWith<With<&'a [T], RefAsBox>> for CopyOptimize {
517    type Archived = ArchivedBox<[T::Archived]>;
518    type Resolver = BoxResolver<MetadataResolver<[T]>>;
519
520    unsafe fn resolve_with(
521        field: &With<&'a [T], RefAsBox>,
522        pos: usize,
523        resolver: Self::Resolver,
524        out: *mut Self::Archived,
525    ) {
526        ArchivedBox::resolve_from_ref(*field.as_ref(), pos, resolver, out);
527    }
528}
529
530impl<'a, T, S> SerializeWith<With<&'a [T], RefAsBox>, S> for CopyOptimize
531where
532    T: Serialize<S>,
533    S: Serializer,
534{
535    fn serialize_with(
536        field: &With<&'a [T], RefAsBox>,
537        serializer: &mut S,
538    ) -> Result<Self::Resolver, S::Error> {
539        use ::core::mem::size_of;
540
541        // Basic debug assert that T and T::Archived are at least the same size
542        debug_assert_eq!(size_of::<T>(), size_of::<T::Archived>());
543
544        unsafe {
545            ArchivedBox::<[T::Archived]>::serialize_copy_from_slice(*field.as_ref(), serializer)
546        }
547    }
548}
549
550// Raw
551
552impl<T: Archive> ArchiveWith<Vec<T>> for Raw {
553    type Archived = RawArchivedVec<T::Archived>;
554    type Resolver = VecResolver;
555
556    unsafe fn resolve_with(
557        field: &Vec<T>,
558        pos: usize,
559        resolver: Self::Resolver,
560        out: *mut Self::Archived,
561    ) {
562        RawArchivedVec::resolve_from_slice(field.as_slice(), pos, resolver, out);
563    }
564}
565
566impl<T, S> SerializeWith<Vec<T>, S> for Raw
567where
568    T: Serialize<S>,
569    S: Serializer,
570{
571    fn serialize_with(field: &Vec<T>, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
572        use ::core::mem::size_of;
573
574        // Basic debug assert that T and T::Archived are at least the same size
575        debug_assert_eq!(size_of::<T>(), size_of::<T::Archived>());
576
577        unsafe { ArchivedVec::serialize_copy_from_slice(field.as_slice(), serializer) }
578    }
579}
580
581impl<T, D> DeserializeWith<RawArchivedVec<T::Archived>, Vec<T>, D> for Raw
582where
583    T: Archive,
584    T::Archived: Deserialize<T, D>,
585    D: Fallible + ?Sized,
586{
587    fn deserialize_with(
588        field: &RawArchivedVec<T::Archived>,
589        _: &mut D,
590    ) -> Result<Vec<T>, D::Error> {
591        use ::core::{mem::size_of, ptr::copy_nonoverlapping};
592
593        // Basic debug assert that T and T::Archived are at least the same size
594        debug_assert_eq!(size_of::<T>(), size_of::<T::Archived>());
595
596        let mut result = Vec::with_capacity(field.len());
597        unsafe {
598            copy_nonoverlapping(field.as_ptr().cast(), result.as_mut_ptr(), field.len());
599            result.set_len(field.len());
600        }
601
602        Ok(result)
603    }
604}
rkyv_test/with/alloc.rs

rkyv_test/with/
alloc.rs
