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| {
68                    let ptr = alloc::alloc(layout);
69                    if ptr.is_null() {
70                        alloc::handle_alloc_error(layout);
71                    }
72                    ptr
73                })?;
74            let metadata = self.as_slice().deserialize_metadata(deserializer)?;
75            let ptr = ptr_meta::from_raw_parts_mut(data_address, metadata);
76            let vec: Vec<T> = Box::<[T]>::from_raw(ptr).into();
77            Ok(vec.into())
78        }
79    }
80}
81
82#[cfg(test)]
83mod tests {
84    use std::collections::VecDeque;
85
86    use crate::{archived_root, ser::Serializer, Deserialize, Infallible};
87
88    #[test]
89    fn vecdeque() {
90        use crate::ser::serializers::CoreSerializer;
91
92        for n in 2..10 {
93            for k in 1..n {
94                // Construct `deque` as containing `0..n` split across two
95                // slices `0..k` and `k..n`.
96                //
97                // This might not work with some possible implementations of
98                // `VecDeque`.  Imagine one, for example, where it fills the
99                // deque starting from the middle.  However, the [documentation
100                // example for `VecDeque::as_slice`][1] implies that we can do
101                // this, so we might as well.
102                //
103                // [1]: https://doc.rust-lang.org/stable/std/collections/struct.VecDeque.html#method.as_slices
104                let mut deque = VecDeque::with_capacity(n as usize + 1);
105                for x in k..n {
106                    deque.push_back(x);
107                }
108                for x in (0..k).rev() {
109                    deque.push_front(x);
110                }
111                assert!(deque.iter().copied().eq(0..n));
112
113                let (a, b) = deque.as_slices();
114                assert!(a.iter().copied().eq(0..k));
115                assert!(b.iter().copied().eq(k..n));
116
117                // Now serialize and deserialize and verify that the
118                // deserialized version contains `0..n`.
119                let mut serializer = CoreSerializer::<256, 256>::default();
120                serializer.serialize_value(&deque).unwrap();
121                let end = serializer.pos();
122                let result = serializer.into_serializer().into_inner();
123                let archived = unsafe { archived_root::<VecDeque<i32>>(&result[0..end]) };
124                assert!(archived.iter().copied().eq(0..n));
125
126                let deserialized: VecDeque<i32> = archived.deserialize(&mut Infallible).unwrap();
127                assert_eq!(deque, deserialized);
128            }
129        }
130    }
131}
rkyv/impls/std/collections/vecdeque.rs

rkyv/impls/std/collections/
vecdeque.rs
