rkyv_test/impls/
rend.rs

1use crate::{rend::*, Archive, Archived, Deserialize, Fallible, Serialize};
2#[cfg(has_atomics)]
3use core::sync::atomic::Ordering;
4
5macro_rules! impl_rend_primitive {
6    ($type:ty) => {
7        impl Archive for $type {
8            type Archived = Self;
9            type Resolver = ();
10
11            #[inline]
12            unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
13                out.write(*self);
14            }
15        }
16
17        // Safety: rend primitives always have the same representation archived and unarchived and
18        // contain no padding
19        #[cfg(feature = "copy")]
20        unsafe impl crate::copy::ArchiveCopySafe for $type {}
21
22        impl<S: Fallible + ?Sized> Serialize<S> for $type {
23            #[inline]
24            fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
25                Ok(())
26            }
27        }
28
29        impl<D: Fallible + ?Sized> Deserialize<$type, D> for Archived<$type> {
30            #[inline]
31            fn deserialize(&self, _: &mut D) -> Result<$type, D::Error> {
32                Ok(*self)
33            }
34        }
35    };
36}
37
38#[cfg(has_atomics)]
39macro_rules! impl_rend_atomic {
40    ($type:ty, $prim:ty) => {
41        impl Archive for $type {
42            type Archived = $prim;
43            type Resolver = ();
44
45            #[inline]
46            unsafe fn resolve(&self, _: usize, _: Self::Resolver, out: *mut Self::Archived) {
47                out.write(<$prim>::new(self.load(Ordering::Relaxed)));
48            }
49        }
50
51        impl<S: Fallible + ?Sized> Serialize<S> for $type {
52            #[inline]
53            fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
54                Ok(())
55            }
56        }
57
58        impl<D: Fallible + ?Sized> Deserialize<$type, D> for $prim {
59            #[inline]
60            fn deserialize(&self, _: &mut D) -> Result<$type, D::Error> {
61                Ok(self.value().into())
62            }
63        }
64    };
65}
66
67impl_rend_primitive!(i16_be);
68impl_rend_primitive!(i32_be);
69impl_rend_primitive!(i64_be);
70impl_rend_primitive!(i128_be);
71impl_rend_primitive!(u16_be);
72impl_rend_primitive!(u32_be);
73impl_rend_primitive!(u64_be);
74impl_rend_primitive!(u128_be);
75
76impl_rend_primitive!(f32_be);
77impl_rend_primitive!(f64_be);
78
79impl_rend_primitive!(char_be);
80
81impl_rend_primitive!(NonZeroI16_be);
82impl_rend_primitive!(NonZeroI32_be);
83impl_rend_primitive!(NonZeroI64_be);
84impl_rend_primitive!(NonZeroI128_be);
85impl_rend_primitive!(NonZeroU16_be);
86impl_rend_primitive!(NonZeroU32_be);
87impl_rend_primitive!(NonZeroU64_be);
88impl_rend_primitive!(NonZeroU128_be);
89
90#[cfg(has_atomics)]
91impl_rend_atomic!(AtomicI16_be, i16_be);
92#[cfg(has_atomics)]
93impl_rend_atomic!(AtomicI32_be, i32_be);
94#[cfg(has_atomics_64)]
95impl_rend_atomic!(AtomicI64_be, i64_be);
96#[cfg(has_atomics)]
97impl_rend_atomic!(AtomicU16_be, u16_be);
98#[cfg(has_atomics)]
99impl_rend_atomic!(AtomicU32_be, u32_be);
100#[cfg(has_atomics_64)]
101impl_rend_atomic!(AtomicU64_be, u64_be);
102
103impl_rend_primitive!(i16_le);
104impl_rend_primitive!(i32_le);
105impl_rend_primitive!(i64_le);
106impl_rend_primitive!(i128_le);
107impl_rend_primitive!(u16_le);
108impl_rend_primitive!(u32_le);
109impl_rend_primitive!(u64_le);
110impl_rend_primitive!(u128_le);
111
112impl_rend_primitive!(f32_le);
113impl_rend_primitive!(f64_le);
114
115impl_rend_primitive!(char_le);
116
117impl_rend_primitive!(NonZeroI16_le);
118impl_rend_primitive!(NonZeroI32_le);
119impl_rend_primitive!(NonZeroI64_le);
120impl_rend_primitive!(NonZeroI128_le);
121impl_rend_primitive!(NonZeroU16_le);
122impl_rend_primitive!(NonZeroU32_le);
123impl_rend_primitive!(NonZeroU64_le);
124impl_rend_primitive!(NonZeroU128_le);
125
126#[cfg(has_atomics)]
127impl_rend_atomic!(AtomicI16_le, i16_le);
128#[cfg(has_atomics)]
129impl_rend_atomic!(AtomicI32_le, i32_le);
130#[cfg(has_atomics_64)]
131impl_rend_atomic!(AtomicI64_le, i64_le);
132#[cfg(has_atomics)]
133impl_rend_atomic!(AtomicU16_le, u16_le);
134#[cfg(has_atomics)]
135impl_rend_atomic!(AtomicU32_le, u32_le);
136#[cfg(has_atomics_64)]
137impl_rend_atomic!(AtomicU64_le, u64_le);
138
139#[cfg(test)]
140mod tests {
141    use crate::{
142        archived_root, ser::serializers::CoreSerializer, ser::Serializer, Deserialize, Infallible,
143        Serialize,
144    };
145    use core::fmt;
146
147    type DefaultSerializer = CoreSerializer<256, 256>;
148
149    fn test_archive<T>(value: &T)
150    where
151        T: fmt::Debug + PartialEq + Serialize<DefaultSerializer>,
152        T::Archived: fmt::Debug + PartialEq<T> + Deserialize<T, Infallible>,
153    {
154        let mut serializer = DefaultSerializer::default();
155        serializer
156            .serialize_value(value)
157            .expect("failed to archive value");
158        let len = serializer.pos();
159        let buffer = serializer.into_serializer().into_inner();
160
161        let archived_value = unsafe { archived_root::<T>(&buffer[0..len]) };
162        assert_eq!(archived_value, value);
163        let mut deserializer = Infallible;
164        assert_eq!(
165            &archived_value.deserialize(&mut deserializer).unwrap(),
166            value
167        );
168    }
169
170    #[test]
171    fn archive_rend() {
172        use crate::rend::*;
173
174        test_archive(&f32_be::new(1234567f32));
175        test_archive(&f64_be::new(12345678901234f64));
176        test_archive(&i16_be::new(12345i16));
177        test_archive(&i32_be::new(1234567890i32));
178        test_archive(&i64_be::new(1234567890123456789i64));
179        test_archive(&i128_be::new(123456789012345678901234567890123456789i128));
180        test_archive(&u16_be::new(12345u16));
181        test_archive(&u32_be::new(1234567890u32));
182        test_archive(&u64_be::new(12345678901234567890u64));
183        test_archive(&u128_be::new(123456789012345678901234567890123456789u128));
184
185        test_archive(&f32_le::new(1234567f32));
186        test_archive(&f64_le::new(12345678901234f64));
187        test_archive(&i16_le::new(12345i16));
188        test_archive(&i32_le::new(1234567890i32));
189        test_archive(&i64_le::new(1234567890123456789i64));
190        test_archive(&i128_le::new(123456789012345678901234567890123456789i128));
191        test_archive(&u16_le::new(12345u16));
192        test_archive(&u32_le::new(1234567890u32));
193        test_archive(&u64_le::new(12345678901234567890u64));
194        test_archive(&u128_le::new(123456789012345678901234567890123456789u128));
195    }
196
197    #[test]
198    fn archive_rend_endianness() {
199        // Check representations to make sure endianness is preserved
200        use crate::{
201            rend::{BigEndian, LittleEndian},
202            ser::Serializer,
203        };
204
205        // Big endian
206        let value = BigEndian::<i32>::new(0x12345678);
207
208        let mut serializer = DefaultSerializer::default();
209        serializer.serialize_value(&value).unwrap();
210        let buf = serializer.into_serializer().into_inner();
211
212        assert_eq!(&buf[0..4], &[0x12, 0x34, 0x56, 0x78]);
213
214        // Little endian
215        let value = LittleEndian::<i32>::new(0x12345678i32);
216
217        let mut serializer = DefaultSerializer::default();
218        serializer.serialize_value(&value).unwrap();
219        let buf = serializer.into_serializer().into_inner();
220
221        assert_eq!(&buf[0..4], &[0x78, 0x56, 0x34, 0x12]);
222    }
223
224    #[test]
225    fn archive_rend_nonzero() {
226        use crate::rend::*;
227        use core::num::{
228            NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroU128, NonZeroU16, NonZeroU32,
229            NonZeroU64,
230        };
231
232        unsafe {
233            test_archive(&NonZeroI16_be::new(NonZeroI16::new_unchecked(12345)));
234            test_archive(&NonZeroI32_be::new(NonZeroI32::new_unchecked(1234567890)));
235            test_archive(&NonZeroI64_be::new(NonZeroI64::new_unchecked(
236                1234567890123456789,
237            )));
238            test_archive(&NonZeroI128_be::new(NonZeroI128::new_unchecked(
239                123456789012345678901234567890123456789,
240            )));
241            test_archive(&NonZeroU16_be::new(NonZeroU16::new_unchecked(12345)));
242            test_archive(&NonZeroU32_be::new(NonZeroU32::new_unchecked(1234567890)));
243            test_archive(&NonZeroU64_be::new(NonZeroU64::new_unchecked(
244                1234567890123456789,
245            )));
246            test_archive(&NonZeroU128_be::new(NonZeroU128::new_unchecked(
247                123456789012345678901234567890123456789,
248            )));
249
250            test_archive(&NonZeroI16_le::new(NonZeroI16::new_unchecked(12345)));
251            test_archive(&NonZeroI32_le::new(NonZeroI32::new_unchecked(1234567890)));
252            test_archive(&NonZeroI64_le::new(NonZeroI64::new_unchecked(
253                1234567890123456789,
254            )));
255            test_archive(&NonZeroI128_le::new(NonZeroI128::new_unchecked(
256                123456789012345678901234567890123456789,
257            )));
258            test_archive(&NonZeroU16_le::new(NonZeroU16::new_unchecked(12345)));
259            test_archive(&NonZeroU32_le::new(NonZeroU32::new_unchecked(1234567890)));
260            test_archive(&NonZeroU64_le::new(NonZeroU64::new_unchecked(
261                1234567890123456789,
262            )));
263            test_archive(&NonZeroU128_le::new(NonZeroU128::new_unchecked(
264                123456789012345678901234567890123456789,
265            )));
266        }
267    }
268}
rkyv_test/impls/rend.rs

rkyv_test/impls/
rend.rs
