rkyv_test/impls/core/
ops.rs

1use crate::{
2    ops::{
3        ArchivedRange, ArchivedRangeFrom, ArchivedRangeInclusive, ArchivedRangeTo,
4        ArchivedRangeToInclusive,
5    },
6    Archive, Archived, Deserialize, Fallible, Serialize,
7};
8use core::ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};
9
10// RangeFull
11
12impl Archive for RangeFull {
13    type Archived = Self;
14    type Resolver = ();
15
16    #[inline]
17    unsafe fn resolve(&self, _: usize, _: Self::Resolver, _: *mut Self::Archived) {}
18}
19
20impl<S: Fallible + ?Sized> Serialize<S> for RangeFull {
21    #[inline]
22    fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
23        Ok(())
24    }
25}
26
27impl<D: Fallible + ?Sized> Deserialize<RangeFull, D> for RangeFull {
28    #[inline]
29    fn deserialize(&self, _: &mut D) -> Result<Self, D::Error> {
30        Ok(RangeFull)
31    }
32}
33
34// Range
35
36impl<T: Archive> Archive for Range<T> {
37    type Archived = ArchivedRange<T::Archived>;
38    type Resolver = Range<T::Resolver>;
39
40    #[inline]
41    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
42        let (fp, fo) = out_field!(out.start);
43        self.start.resolve(pos + fp, resolver.start, fo);
44        let (fp, fo) = out_field!(out.end);
45        self.end.resolve(pos + fp, resolver.end, fo);
46    }
47}
48
49impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for Range<T> {
50    #[inline]
51    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
52        Ok(Range {
53            start: self.start.serialize(serializer)?,
54            end: self.end.serialize(serializer)?,
55        })
56    }
57}
58
59impl<T: Archive, D: Fallible + ?Sized> Deserialize<Range<T>, D> for Archived<Range<T>>
60where
61    T::Archived: Deserialize<T, D>,
62{
63    #[inline]
64    fn deserialize(&self, deserializer: &mut D) -> Result<Range<T>, D::Error> {
65        Ok(Range {
66            start: self.start.deserialize(deserializer)?,
67            end: self.end.deserialize(deserializer)?,
68        })
69    }
70}
71
72impl<T, U: PartialEq<T>> PartialEq<Range<T>> for ArchivedRange<U> {
73    #[inline]
74    fn eq(&self, other: &Range<T>) -> bool {
75        self.start.eq(&other.start) && self.end.eq(&other.end)
76    }
77}
78
79// RangeInclusive
80
81impl<T: Archive> Archive for RangeInclusive<T> {
82    type Archived = ArchivedRangeInclusive<T::Archived>;
83    type Resolver = Range<T::Resolver>;
84
85    #[inline]
86    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
87        let (fp, fo) = out_field!(out.start);
88        self.start().resolve(pos + fp, resolver.start, fo);
89        let (fp, fo) = out_field!(out.end);
90        self.end().resolve(pos + fp, resolver.end, fo);
91    }
92}
93
94impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for RangeInclusive<T> {
95    #[inline]
96    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
97        Ok(Range {
98            start: self.start().serialize(serializer)?,
99            end: self.end().serialize(serializer)?,
100        })
101    }
102}
103
104impl<T, D> Deserialize<RangeInclusive<T>, D> for Archived<RangeInclusive<T>>
105where
106    T: Archive,
107    T::Archived: Deserialize<T, D>,
108    D: Fallible + ?Sized,
109{
110    #[inline]
111    fn deserialize(&self, deserializer: &mut D) -> Result<RangeInclusive<T>, D::Error> {
112        Ok(RangeInclusive::new(
113            self.start.deserialize(deserializer)?,
114            self.end.deserialize(deserializer)?,
115        ))
116    }
117}
118
119impl<T, U: PartialEq<T>> PartialEq<RangeInclusive<T>> for ArchivedRangeInclusive<U> {
120    #[inline]
121    fn eq(&self, other: &RangeInclusive<T>) -> bool {
122        self.start.eq(other.start()) && self.end.eq(other.end())
123    }
124}
125
126// RangeFrom
127
128impl<T: Archive> Archive for RangeFrom<T> {
129    type Archived = ArchivedRangeFrom<T::Archived>;
130    type Resolver = RangeFrom<T::Resolver>;
131
132    #[inline]
133    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
134        let (fp, fo) = out_field!(out.start);
135        self.start.resolve(pos + fp, resolver.start, fo);
136    }
137}
138
139impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for RangeFrom<T> {
140    #[inline]
141    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
142        Ok(RangeFrom {
143            start: self.start.serialize(serializer)?,
144        })
145    }
146}
147
148impl<T: Archive, D: Fallible + ?Sized> Deserialize<RangeFrom<T>, D> for Archived<RangeFrom<T>>
149where
150    T::Archived: Deserialize<T, D>,
151{
152    #[inline]
153    fn deserialize(&self, deserializer: &mut D) -> Result<RangeFrom<T>, D::Error> {
154        Ok(RangeFrom {
155            start: self.start.deserialize(deserializer)?,
156        })
157    }
158}
159
160impl<T, U: PartialEq<T>> PartialEq<RangeFrom<T>> for ArchivedRangeFrom<U> {
161    #[inline]
162    fn eq(&self, other: &RangeFrom<T>) -> bool {
163        self.start.eq(&other.start)
164    }
165}
166
167// RangeTo
168
169impl<T: Archive> Archive for RangeTo<T> {
170    type Archived = ArchivedRangeTo<T::Archived>;
171    type Resolver = RangeTo<T::Resolver>;
172
173    #[inline]
174    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
175        let (fp, fo) = out_field!(out.end);
176        self.end.resolve(pos + fp, resolver.end, fo);
177    }
178}
179
180impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for RangeTo<T> {
181    #[inline]
182    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
183        Ok(RangeTo {
184            end: self.end.serialize(serializer)?,
185        })
186    }
187}
188
189impl<T: Archive, D: Fallible + ?Sized> Deserialize<RangeTo<T>, D> for Archived<RangeTo<T>>
190where
191    T::Archived: Deserialize<T, D>,
192{
193    #[inline]
194    fn deserialize(&self, deserializer: &mut D) -> Result<RangeTo<T>, D::Error> {
195        Ok(RangeTo {
196            end: self.end.deserialize(deserializer)?,
197        })
198    }
199}
200
201impl<T, U: PartialEq<T>> PartialEq<RangeTo<T>> for ArchivedRangeTo<U> {
202    #[inline]
203    fn eq(&self, other: &RangeTo<T>) -> bool {
204        self.end.eq(&other.end)
205    }
206}
207
208// RangeToInclusive
209
210impl<T: Archive> Archive for RangeToInclusive<T> {
211    type Archived = ArchivedRangeToInclusive<T::Archived>;
212    type Resolver = RangeToInclusive<T::Resolver>;
213
214    #[inline]
215    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
216        let (fp, fo) = out_field!(out.end);
217        self.end.resolve(pos + fp, resolver.end, fo);
218    }
219}
220
221impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for RangeToInclusive<T> {
222    #[inline]
223    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
224        Ok(RangeToInclusive {
225            end: self.end.serialize(serializer)?,
226        })
227    }
228}
229
230impl<T, D> Deserialize<RangeToInclusive<T>, D> for Archived<RangeToInclusive<T>>
231where
232    T: Archive,
233    T::Archived: Deserialize<T, D>,
234    D: Fallible + ?Sized,
235{
236    #[inline]
237    fn deserialize(&self, deserializer: &mut D) -> Result<RangeToInclusive<T>, D::Error> {
238        Ok(RangeToInclusive {
239            end: self.end.deserialize(deserializer)?,
240        })
241    }
242}
243
244impl<T, U: PartialEq<T>> PartialEq<RangeToInclusive<T>> for ArchivedRangeToInclusive<U> {
245    #[inline]
246    fn eq(&self, other: &RangeToInclusive<T>) -> bool {
247        self.end.eq(&other.end)
248    }
249}
rkyv_test/impls/core/ops.rs

rkyv_test/impls/core/
ops.rs
