aldrin_core/impls/
vec.rs

1#[cfg(feature = "introspection")]
2use crate::introspection::{ir, Introspectable, LexicalId, References};
3use crate::tags::{self, PrimaryTag, Tag};
4use crate::{Deserialize, DeserializeError, Deserializer, Serialize, SerializeError, Serializer};
5use std::collections::{LinkedList, VecDeque};
6use std::mem::MaybeUninit;
7
8macro_rules! impl_vec {
9    { $ty:ident } => {
10        impl<T: PrimaryTag> PrimaryTag for $ty<T> {
11            type Tag = tags::Vec<T::Tag>;
12        }
13
14        impl<T: Tag, U: Serialize<T>> Serialize<tags::Vec<T>> for $ty<U> {
15            fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
16                serializer.serialize_vec2_iter(self)
17            }
18        }
19
20        impl<'a, T, U> Serialize<tags::Vec<T>> for &'a $ty<U>
21        where
22            T: Tag,
23            &'a U: Serialize<T>,
24        {
25            fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
26                serializer.serialize_vec2_iter(self)
27            }
28        }
29
30        impl<T: Tag, U: Deserialize<T>> Deserialize<tags::Vec<T>> for $ty<U> {
31            fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
32                deserializer.deserialize_vec_extend_new()
33            }
34        }
35
36        #[cfg(feature = "introspection")]
37        impl<T: Introspectable> Introspectable for $ty<T> {
38            fn layout() -> ir::LayoutIr {
39                ir::BuiltInTypeIr::Vec(T::lexical_id()).into()
40            }
41
42            fn lexical_id() -> LexicalId {
43                LexicalId::vec(T::lexical_id())
44            }
45
46            fn add_references(references: &mut References) {
47                references.add::<T>();
48            }
49        }
50    }
51}
52
53impl_vec!(Vec);
54impl_vec!(VecDeque);
55impl_vec!(LinkedList);
56
57impl<T: PrimaryTag> PrimaryTag for &[T] {
58    type Tag = tags::Vec<T::Tag>;
59}
60
61impl<'a, T, U> Serialize<tags::Vec<T>> for &'a [U]
62where
63    T: Tag,
64    &'a U: Serialize<T>,
65{
66    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
67        serializer.serialize_vec2_iter(self)
68    }
69}
70
71#[cfg(feature = "introspection")]
72impl<T: Introspectable> Introspectable for [T] {
73    fn layout() -> ir::LayoutIr {
74        ir::BuiltInTypeIr::Vec(T::lexical_id()).into()
75    }
76
77    fn lexical_id() -> LexicalId {
78        LexicalId::vec(T::lexical_id())
79    }
80
81    fn add_references(references: &mut References) {
82        references.add::<T>();
83    }
84}
85
86impl<T: PrimaryTag, const N: usize> PrimaryTag for [T; N] {
87    type Tag = tags::Vec<T::Tag>;
88}
89
90impl<T: Tag, U: Serialize<T>, const N: usize> Serialize<tags::Vec<T>> for [U; N] {
91    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
92        serializer.serialize_vec2_iter(self)
93    }
94}
95
96impl<'a, T, U, const N: usize> Serialize<tags::Vec<T>> for &'a [U; N]
97where
98    T: Tag,
99    &'a U: Serialize<T>,
100{
101    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
102        serializer.serialize_vec2_iter(self)
103    }
104}
105
106impl<T: Tag, U: Deserialize<T>, const N: usize> Deserialize<tags::Vec<T>> for [U; N] {
107    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
108        let mut deserializer = deserializer.deserialize_vec()?;
109
110        // SAFETY: This creates an array of MaybeUninit<U>, which doesn't require initialization.
111        let mut arr: [MaybeUninit<U>; N] = unsafe { MaybeUninit::uninit().assume_init() };
112
113        let mut num = 0;
114        let mut err = None;
115
116        for elem in &mut arr {
117            match deserializer.deserialize() {
118                Ok(Some(value)) => {
119                    elem.write(value);
120                    num += 1;
121                }
122
123                Ok(None) => {
124                    err = Some(DeserializeError::NoMoreElements);
125                    break;
126                }
127
128                Err(e) => {
129                    err = Some(e);
130                    break;
131                }
132            }
133        }
134
135        // err is Some, iff num < N. And when that's the case, num is the number of elements in arr
136        // that have ben initialized.
137        if let Some(err) = err {
138            for elem in &mut arr[..num] {
139                // SAFETY: The first num elements have been initialized.
140                unsafe {
141                    elem.assume_init_drop();
142                }
143            }
144
145            return Err(err);
146        }
147
148        // SAFETY: Exactly num elements have been initialized and num equals N.
149        //
150        // It's currently impossible to transmute [MaybeUninit<U>; N] to [U; N] when U is a generic
151        // or N a const generic. See https://github.com/rust-lang/rust/issues/61956.
152        let value = unsafe {
153            (*(&MaybeUninit::new(arr) as *const _ as *const MaybeUninit<[U; N]>)).assume_init_read()
154        };
155
156        deserializer.finish(value)
157    }
158}
159
160#[cfg(feature = "introspection")]
161impl<T: Introspectable, const N: usize> Introspectable for [T; N] {
162    fn layout() -> ir::LayoutIr {
163        ir::BuiltInTypeIr::Array(ir::ArrayTypeIr::new(T::lexical_id(), N as u32)).into()
164    }
165
166    fn lexical_id() -> LexicalId {
167        LexicalId::array(T::lexical_id(), N as u32)
168    }
169
170    fn add_references(references: &mut References) {
171        references.add::<T>();
172    }
173}
174
175impl<T> Serialize<tags::Vec<T>> for bytes::Bytes
176where
177    T: Tag,
178    u8: Serialize<T>,
179{
180    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
181        serializer.serialize_vec2_iter(self)
182    }
183}
184
185impl<T> Serialize<tags::Vec<T>> for &bytes::Bytes
186where
187    T: Tag,
188    u8: Serialize<T>,
189{
190    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
191        serializer.serialize_vec2_iter(self.iter().copied())
192    }
193}
194
195impl<T> Deserialize<tags::Vec<T>> for bytes::Bytes
196where
197    T: Tag,
198    u8: Deserialize<T>,
199{
200    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
201        deserializer
202            .deserialize_vec_extend_new::<T, u8, Vec<u8>>()
203            .map(Self::from)
204    }
205}
206
207impl<T> Serialize<tags::Vec<T>> for bytes::BytesMut
208where
209    T: Tag,
210    u8: Serialize<T>,
211{
212    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
213        serializer.serialize_vec2_iter(self)
214    }
215}
216
217impl<T> Serialize<tags::Vec<T>> for &bytes::BytesMut
218where
219    T: Tag,
220    u8: Serialize<T>,
221{
222    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
223        serializer.serialize_vec2_iter(self.iter().copied())
224    }
225}
226
227impl<T> Deserialize<tags::Vec<T>> for bytes::BytesMut
228where
229    T: Tag,
230    u8: Deserialize<T>,
231{
232    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
233        deserializer.deserialize_vec_extend_new::<T, u8, _>()
234    }
235}
236
237impl<T: Tag> Serialize<tags::Vec<T>> for () {
238    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
239        serializer.serialize_vec2()?.finish()
240    }
241}
242
243impl<T: Tag> Serialize<tags::Vec<T>> for &() {
244    fn serialize(self, serializer: Serializer) -> Result<(), SerializeError> {
245        serializer.serialize_vec2()?.finish()
246    }
247}
248
249impl<T: Tag> Deserialize<tags::Vec<T>> for () {
250    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
251        deserializer.deserialize_vec()?.finish(())
252    }
253}
aldrin_core/impls/vec.rs

aldrin_core/impls/
vec.rs
