rkyv/impls/core/
primitive.rs

1use crate::{Archive, Archived, Deserialize, Fallible, FixedIsize, FixedUsize, Serialize};
2#[cfg(has_atomics)]
3use core::sync::atomic::{
4    AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
5    AtomicUsize, Ordering,
6};
7#[cfg(has_atomics_64)]
8use core::sync::atomic::{AtomicI64, AtomicU64};
9use core::{
10    marker::{PhantomData, PhantomPinned},
11    num::{
12        NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
13        NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
14    },
15};
16
17macro_rules! impl_primitive {
18    (@serialize $type:ty) => {
19        impl<S: Fallible + ?Sized> Serialize<S> for $type {
20            #[inline]
21            fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
22                Ok(())
23            }
24        }
25    };
26    ($type:ty) => {
27        impl Archive for $type {
28            type Archived = Self;
29            type Resolver = ();
30
31            #[inline]
32            unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
33                out.write(*self);
34            }
35        }
36
37        impl_primitive!(@serialize $type);
38
39        impl<D: Fallible + ?Sized> Deserialize<$type, D> for Archived<$type> {
40            #[inline]
41            fn deserialize(&self, _: &mut D) -> Result<$type, D::Error> {
42                Ok(*self)
43            }
44        }
45    };
46    (@multibyte $type:ty) => {
47        const _: () = {
48            #[cfg(not(any(feature = "archive_le", feature = "archive_be")))]
49            type Archived = $type;
50            #[cfg(feature = "archive_le")]
51            type Archived = crate::rend::LittleEndian<$type>;
52            #[cfg(feature = "archive_be")]
53            type Archived = crate::rend::BigEndian<$type>;
54
55            impl Archive for $type {
56                type Archived = Archived;
57                type Resolver = ();
58
59                #[inline]
60                unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
61                    out.write(to_archived!(*self as Self));
62                }
63            }
64
65            impl_primitive!(@serialize $type);
66
67            impl<D: Fallible + ?Sized> Deserialize<$type, D> for Archived {
68                #[inline]
69                fn deserialize(&self, _: &mut D) -> Result<$type, D::Error> {
70                    Ok(from_archived!(*self))
71                }
72            }
73        };
74    };
75}
76
77#[cfg(has_atomics)]
78macro_rules! impl_atomic {
79    (@serialize_deserialize $type:ty) => {
80        impl<S: Fallible + ?Sized> Serialize<S> for $type {
81            #[inline]
82            fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
83                Ok(())
84            }
85        }
86    };
87    ($type:ty, $prim:ty) => {
88        impl Archive for $type {
89            type Archived = $prim;
90            type Resolver = ();
91
92            #[inline]
93            unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
94                out.write(self.load(Ordering::Relaxed));
95            }
96        }
97
98        impl_atomic!(@serialize_deserialize $type);
99
100        impl<D: Fallible + ?Sized> Deserialize<$type, D> for Archived<$type> {
101            #[inline]
102            fn deserialize(&self, _: &mut D) -> Result<$type, D::Error> {
103                Ok((*self).into())
104            }
105        }
106    };
107    (@multibyte $type:ty, $prim:ty) => {
108        impl Archive for $type {
109            #[cfg(not(any(feature = "archive_le", feature = "archive_be")))]
110            type Archived = $prim;
111            #[cfg(feature = "archive_le")]
112            type Archived = crate::rend::LittleEndian<$prim>;
113            #[cfg(feature = "archive_be")]
114            type Archived = crate::rend::BigEndian<$prim>;
115
116            type Resolver = ();
117
118            #[inline]
119            unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
120                out.write(to_archived!(self.load(Ordering::Relaxed)));
121            }
122        }
123
124        impl_atomic!(@serialize_deserialize $type);
125
126        impl<D: Fallible + ?Sized> Deserialize<$type, D> for Archived<$type> {
127            #[inline]
128            fn deserialize(&self, _: &mut D) -> Result<$type, D::Error> {
129                Ok(from_archived!(*self).into())
130            }
131        }
132    };
133}
134
135impl_primitive!(());
136impl_primitive!(bool);
137impl_primitive!(i8);
138impl_primitive!(u8);
139impl_primitive!(NonZeroI8);
140impl_primitive!(NonZeroU8);
141#[cfg(has_atomics)]
142impl_atomic!(AtomicBool, bool);
143#[cfg(has_atomics)]
144impl_atomic!(AtomicI8, i8);
145#[cfg(has_atomics)]
146impl_atomic!(AtomicU8, u8);
147
148impl_primitive!(@multibyte i16);
149impl_primitive!(@multibyte i32);
150impl_primitive!(@multibyte i64);
151impl_primitive!(@multibyte i128);
152impl_primitive!(@multibyte u16);
153impl_primitive!(@multibyte u32);
154impl_primitive!(@multibyte u64);
155impl_primitive!(@multibyte u128);
156
157impl_primitive!(@multibyte f32);
158impl_primitive!(@multibyte f64);
159
160impl_primitive!(@multibyte char);
161
162impl_primitive!(@multibyte NonZeroI16);
163impl_primitive!(@multibyte NonZeroI32);
164impl_primitive!(@multibyte NonZeroI64);
165impl_primitive!(@multibyte NonZeroI128);
166impl_primitive!(@multibyte NonZeroU16);
167impl_primitive!(@multibyte NonZeroU32);
168impl_primitive!(@multibyte NonZeroU64);
169impl_primitive!(@multibyte NonZeroU128);
170
171#[cfg(has_atomics)]
172impl_atomic!(@multibyte AtomicI16, i16);
173#[cfg(has_atomics)]
174impl_atomic!(@multibyte AtomicI32, i32);
175#[cfg(has_atomics_64)]
176impl_atomic!(@multibyte AtomicI64, i64);
177#[cfg(has_atomics)]
178impl_atomic!(@multibyte AtomicU16, u16);
179#[cfg(has_atomics)]
180impl_atomic!(@multibyte AtomicU32, u32);
181#[cfg(has_atomics_64)]
182impl_atomic!(@multibyte AtomicU64, u64);
183
184// PhantomData
185
186impl<T: ?Sized> Archive for PhantomData<T> {
187    type Archived = PhantomData<T>;
188    type Resolver = ();
189
190    #[inline]
191    unsafe fn resolve(&self, _: usize, _: Self::Resolver, _: *mut Self::Archived) {}
192}
193
194impl<T: ?Sized, S: Fallible + ?Sized> Serialize<S> for PhantomData<T> {
195    #[inline]
196    fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
197        Ok(())
198    }
199}
200
201impl<T: ?Sized, D: Fallible + ?Sized> Deserialize<PhantomData<T>, D> for PhantomData<T> {
202    #[inline]
203    fn deserialize(&self, _: &mut D) -> Result<PhantomData<T>, D::Error> {
204        Ok(PhantomData)
205    }
206}
207
208// PhantomPinned
209impl Archive for PhantomPinned {
210    type Archived = PhantomPinned;
211    type Resolver = ();
212
213    #[inline]
214    unsafe fn resolve(&self, _: usize, _: Self::Resolver, _: *mut Self::Archived) {}
215}
216
217impl<S: Fallible + ?Sized> Serialize<S> for PhantomPinned {
218    #[inline]
219    fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
220        Ok(())
221    }
222}
223
224impl<D: Fallible + ?Sized> Deserialize<PhantomPinned, D> for PhantomPinned {
225    #[inline]
226    fn deserialize(&self, _: &mut D) -> Result<PhantomPinned, D::Error> {
227        Ok(PhantomPinned)
228    }
229}
230
231// usize
232
233impl Archive for usize {
234    type Archived = Archived<FixedUsize>;
235    type Resolver = ();
236
237    #[inline]
238    unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
239        out.write(to_archived!(*self as FixedUsize));
240    }
241}
242
243impl<S: Fallible + ?Sized> Serialize<S> for usize {
244    #[inline]
245    fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
246        Ok(())
247    }
248}
249
250impl<D: Fallible + ?Sized> Deserialize<usize, D> for Archived<usize> {
251    #[inline]
252    fn deserialize(&self, _: &mut D) -> Result<usize, D::Error> {
253        Ok(from_archived!(*self) as usize)
254    }
255}
256
257// isize
258
259impl Archive for isize {
260    type Archived = Archived<FixedIsize>;
261    type Resolver = ();
262
263    #[inline]
264    unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
265        out.write(to_archived!(*self as FixedIsize));
266    }
267}
268
269impl<S: Fallible + ?Sized> Serialize<S> for isize {
270    #[inline]
271    fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
272        Ok(())
273    }
274}
275
276impl<D: Fallible + ?Sized> Deserialize<isize, D> for Archived<isize> {
277    #[inline]
278    fn deserialize(&self, _: &mut D) -> Result<isize, D::Error> {
279        Ok(from_archived!(*self) as isize)
280    }
281}
282
283// NonZeroUsize
284
285type FixedNonZeroUsize = pick_size_type!(NonZeroU16, NonZeroU32, NonZeroU64);
286
287impl Archive for NonZeroUsize {
288    type Archived = Archived<FixedNonZeroUsize>;
289    type Resolver = ();
290
291    #[inline]
292    unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
293        out.write(to_archived!(FixedNonZeroUsize::new_unchecked(
294            self.get() as FixedUsize
295        )));
296    }
297}
298
299impl<S: Fallible + ?Sized> Serialize<S> for NonZeroUsize {
300    #[inline]
301    fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
302        Ok(())
303    }
304}
305
306impl<D: Fallible + ?Sized> Deserialize<NonZeroUsize, D> for Archived<NonZeroUsize> {
307    #[inline]
308    fn deserialize(&self, _: &mut D) -> Result<NonZeroUsize, D::Error> {
309        Ok(unsafe { NonZeroUsize::new_unchecked(from_archived!(*self).get() as usize) })
310    }
311}
312
313// NonZeroIsize
314
315type FixedNonZeroIsize = pick_size_type!(NonZeroI16, NonZeroI32, NonZeroI64);
316
317impl Archive for NonZeroIsize {
318    type Archived = Archived<FixedNonZeroIsize>;
319    type Resolver = ();
320
321    #[inline]
322    unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
323        out.write(to_archived!(FixedNonZeroIsize::new_unchecked(
324            self.get() as FixedIsize
325        )));
326    }
327}
328
329impl<S: Fallible + ?Sized> Serialize<S> for NonZeroIsize {
330    #[inline]
331    fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
332        Ok(())
333    }
334}
335
336impl<D: Fallible + ?Sized> Deserialize<NonZeroIsize, D> for Archived<NonZeroIsize> {
337    #[inline]
338    fn deserialize(&self, _: &mut D) -> Result<NonZeroIsize, D::Error> {
339        Ok(unsafe { NonZeroIsize::new_unchecked(from_archived!(*self).get() as isize) })
340    }
341}
342
343// AtomicUsize
344
345#[cfg(has_atomics)]
346impl Archive for AtomicUsize {
347    type Archived = Archived<FixedUsize>;
348    type Resolver = ();
349
350    #[inline]
351    unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
352        out.write(to_archived!(self.load(Ordering::Relaxed) as FixedUsize));
353    }
354}
355
356#[cfg(has_atomics)]
357impl<S: Fallible + ?Sized> Serialize<S> for AtomicUsize {
358    #[inline]
359    fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
360        Ok(())
361    }
362}
363
364#[cfg(has_atomics)]
365impl<D: Fallible + ?Sized> Deserialize<AtomicUsize, D> for Archived<AtomicUsize> {
366    #[inline]
367    fn deserialize(&self, _: &mut D) -> Result<AtomicUsize, D::Error> {
368        Ok((from_archived!(*self) as usize).into())
369    }
370}
371
372// AtomicIsize
373
374#[cfg(has_atomics)]
375impl Archive for AtomicIsize {
376    type Archived = Archived<FixedIsize>;
377    type Resolver = ();
378
379    #[inline]
380    unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
381        out.write(to_archived!(self.load(Ordering::Relaxed) as FixedIsize));
382    }
383}
384
385#[cfg(has_atomics)]
386impl<S: Fallible + ?Sized> Serialize<S> for AtomicIsize {
387    #[inline]
388    fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
389        Ok(())
390    }
391}
392
393#[cfg(has_atomics)]
394impl<D: Fallible + ?Sized> Deserialize<AtomicIsize, D> for Archived<AtomicIsize> {
395    #[inline]
396    fn deserialize(&self, _: &mut D) -> Result<AtomicIsize, D::Error> {
397        Ok((from_archived!(*self) as isize).into())
398    }
399}
rkyv/impls/core/primitive.rs

rkyv/impls/core/
primitive.rs
