rkyv/impls/std/collections/
vecdeque.rs

1use std::{alloc, cmp, collections::VecDeque};
2
3use crate::{
4    ser::{ScratchSpace, Serializer},
5    vec::{ArchivedVec, VecResolver},
6    Archive, Deserialize, DeserializeUnsized, Fallible, Serialize,
7};
8
9impl<T: PartialEq<U>, U> PartialEq<VecDeque<U>> for ArchivedVec<T> {
10    #[inline]
11    fn eq(&self, other: &VecDeque<U>) -> bool {
12        self.len() == other.len() && self.iter().eq(other.iter())
13    }
14}
15impl<T: PartialEq<U>, U> PartialEq<ArchivedVec<U>> for VecDeque<T> {
16    #[inline]
17    fn eq(&self, other: &ArchivedVec<U>) -> bool {
18        self.len() == other.len() && self.iter().eq(other.iter())
19    }
20}
21impl<T: PartialOrd> PartialOrd<VecDeque<T>> for ArchivedVec<T> {
22    #[inline]
23    fn partial_cmp(&self, other: &VecDeque<T>) -> Option<cmp::Ordering> {
24        self.iter().partial_cmp(other.iter())
25    }
26}
27impl<T: PartialOrd> PartialOrd<ArchivedVec<T>> for VecDeque<T> {
28    #[inline]
29    fn partial_cmp(&self, other: &ArchivedVec<T>) -> Option<cmp::Ordering> {
30        self.iter().partial_cmp(other.iter())
31    }
32}
33
34impl<T: Archive> Archive for VecDeque<T> {
35    type Archived = ArchivedVec<T::Archived>;
36    type Resolver = VecResolver;
37
38    #[inline]
39    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
40        ArchivedVec::resolve_from_len(self.len(), pos, resolver, out);
41    }
42}
43
44impl<T: Serialize<S>, S: ScratchSpace + Serializer + ?Sized> Serialize<S> for VecDeque<T> {
45    #[inline]
46    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
47        let (a, b) = self.as_slices();
48        if b.is_empty() {
49            ArchivedVec::<T::Archived>::serialize_from_slice(a, serializer)
50        } else if a.is_empty() {
51            ArchivedVec::<T::Archived>::serialize_from_slice(b, serializer)
52        } else {
53            ArchivedVec::<T::Archived>::serialize_from_iter::<T, _, _, _>(self.iter(), serializer)
54        }
55    }
56}
57
58impl<T: Archive, D: Fallible + ?Sized> Deserialize<VecDeque<T>, D> for ArchivedVec<T::Archived>
59where
60    [T::Archived]: DeserializeUnsized<[T], D>,
61{
62    #[inline]
63    fn deserialize(&self, deserializer: &mut D) -> Result<VecDeque<T>, D::Error> {
64        unsafe {
65            let data_address = self
66                .as_slice()
67                .deserialize_unsized(deserializer, |layout| alloc::alloc(layout))?;
68            let metadata = self.as_slice().deserialize_metadata(deserializer)?;
69            let ptr = ptr_meta::from_raw_parts_mut(data_address, metadata);
70            let vec: Vec<T> = Box::<[T]>::from_raw(ptr).into();
71            Ok(vec.into())
72        }
73    }
74}
75
76#[cfg(test)]
77mod tests {
78    use std::collections::VecDeque;
79
80    use crate::{archived_root, ser::Serializer, Deserialize, Infallible};
81
82    #[test]
83    fn vecdeque() {
84        use crate::ser::serializers::CoreSerializer;
85
86        for n in 2..10 {
87            for k in 1..n {
88                // Construct `deque` as containing `0..n` split across two
89                // slices `0..k` and `k..n`.
90                //
91                // This might not work with some possible implementations of
92                // `VecDeque`.  Imagine one, for example, where it fills the
93                // deque starting from the middle.  However, the [documentation
94                // example for `VecDeque::as_slice`][1] implies that we can do
95                // this, so we might as well.
96                //
97                // [1]: https://doc.rust-lang.org/stable/std/collections/struct.VecDeque.html#method.as_slices
98                let mut deque = VecDeque::with_capacity(n as usize + 1);
99                for x in k..n {
100                    deque.push_back(x);
101                }
102                for x in (0..k).rev() {
103                    deque.push_front(x);
104                }
105                assert!(deque.iter().copied().eq(0..n));
106
107                let (a, b) = deque.as_slices();
108                assert!(a.iter().copied().eq(0..k));
109                assert!(b.iter().copied().eq(k..n));
110
111                // Now serialize and deserialize and verify that the
112                // deserialized version contains `0..n`.
113                let mut serializer = CoreSerializer::<256, 256>::default();
114                serializer.serialize_value(&deque).unwrap();
115                let end = serializer.pos();
116                let result = serializer.into_serializer().into_inner();
117                let archived = unsafe { archived_root::<VecDeque<i32>>(&result[0..end]) };
118                assert!(archived.iter().copied().eq(0..n));
119
120                let deserialized: VecDeque<i32> = archived.deserialize(&mut Infallible).unwrap();
121                assert_eq!(deque, deserialized);
122            }
123        }
124    }
125}
rkyv/impls/std/collections/vecdeque.rs

rkyv/impls/std/collections/
vecdeque.rs
