Skip to main content

rkyv/impls/alloc/collections/
vec_deque.rs

1use core::cmp::Ordering;
2
3use rancor::{Fallible, ResultExt, Source};
4
5use crate::{
6    alloc::{
7        alloc::{alloc, handle_alloc_error},
8        boxed::Box,
9        collections::VecDeque,
10        vec::Vec,
11    },
12    ser::{Allocator, Writer},
13    traits::LayoutRaw,
14    vec::{ArchivedVec, VecResolver},
15    Archive, Deserialize, DeserializeUnsized, Place, Serialize,
16};
17
18impl<T: Archive> Archive for VecDeque<T> {
19    type Archived = ArchivedVec<T::Archived>;
20    type Resolver = VecResolver;
21
22    fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>) {
23        ArchivedVec::resolve_from_len(self.len(), resolver, out);
24    }
25}
26
27impl<T, S> Serialize<S> for VecDeque<T>
28where
29    T: Serialize<S>,
30    S: Fallible + Allocator + Writer + ?Sized,
31{
32    fn serialize(
33        &self,
34        serializer: &mut S,
35    ) -> Result<Self::Resolver, S::Error> {
36        let (a, b) = self.as_slices();
37        if b.is_empty() {
38            ArchivedVec::<T::Archived>::serialize_from_slice(a, serializer)
39        } else if a.is_empty() {
40            ArchivedVec::<T::Archived>::serialize_from_slice(b, serializer)
41        } else {
42            ArchivedVec::<T::Archived>::serialize_from_iter::<T, _, _>(
43                self.iter(),
44                serializer,
45            )
46        }
47    }
48}
49
50impl<T, D> Deserialize<VecDeque<T>, D> for ArchivedVec<T::Archived>
51where
52    T: Archive,
53    [T::Archived]: DeserializeUnsized<[T], D>,
54    D: Fallible + ?Sized,
55    D::Error: Source,
56{
57    fn deserialize(
58        &self,
59        deserializer: &mut D,
60    ) -> Result<VecDeque<T>, D::Error> {
61        let metadata = self.as_slice().deserialize_metadata();
62        let layout = <[T] as LayoutRaw>::layout_raw(metadata).into_error()?;
63        let data_address = if layout.size() > 0 {
64            let ptr = unsafe { alloc(layout) };
65            if ptr.is_null() {
66                handle_alloc_error(layout);
67            }
68            ptr
69        } else {
70            crate::polyfill::dangling(&layout).as_ptr()
71        };
72        let out = ptr_meta::from_raw_parts_mut(data_address.cast(), metadata);
73        unsafe {
74            self.as_slice().deserialize_unsized(deserializer, out)?;
75        }
76        let boxed = unsafe { Box::<[T]>::from_raw(out) };
77        Ok(VecDeque::from(Vec::from(boxed)))
78    }
79}
80
81impl<T: PartialEq<U>, U> PartialEq<VecDeque<U>> for ArchivedVec<T> {
82    fn eq(&self, other: &VecDeque<U>) -> bool {
83        self.len() == other.len() && self.iter().eq(other.iter())
84    }
85}
86
87impl<T: PartialOrd> PartialOrd<VecDeque<T>> for ArchivedVec<T> {
88    fn partial_cmp(&self, other: &VecDeque<T>) -> Option<Ordering> {
89        self.iter().partial_cmp(other.iter())
90    }
91}
92
93#[cfg(test)]
94mod tests {
95    use crate::{
96        access_unchecked, alloc::collections::VecDeque, api::test::deserialize,
97        rancor::Error, to_bytes, vec::ArchivedVec, Archived,
98    };
99
100    #[test]
101    fn vecdeque() {
102        for n in 2..10 {
103            for k in 1..n {
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                // Now serialize and deserialize and verify that the
114                // deserialized version contains `0..n`.
115                let bytes = to_bytes::<Error>(&deque).unwrap();
116                let archived = unsafe {
117                    access_unchecked::<ArchivedVec<Archived<i32>>>(&bytes)
118                };
119                assert!(archived.iter().copied().eq(0..n));
120
121                let deserialized = deserialize::<VecDeque<i32>>(archived);
122                assert_eq!(deque, deserialized);
123            }
124        }
125    }
126}