rkyv/impls/alloc/collections/
vec_deque.rs1use 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 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}