alkahest/
vec.rs

1use alloc::vec::Vec;
2
3use crate::{
4    buffer::Buffer,
5    bytes::Bytes,
6    deserialize::{Deserialize, DeserializeError, Deserializer},
7    formula::{reference_size, Formula},
8    iter::{deserialize_extend_iter, owned_iter_fast_sizes, ref_iter_fast_sizes},
9    reference::Ref,
10    serialize::{write_bytes, write_ref, write_reference, write_slice, Serialize, Sizes},
11};
12
13impl<F> Formula for Vec<F>
14where
15    F: Formula,
16{
17    const MAX_STACK_SIZE: Option<usize> = <Ref<[F]> as Formula>::MAX_STACK_SIZE;
18    const EXACT_SIZE: bool = <Ref<[F]> as Formula>::EXACT_SIZE;
19    const HEAPLESS: bool = <Ref<[F]> as Formula>::HEAPLESS;
20}
21
22impl<F, T> Serialize<Vec<F>> for T
23where
24    F: Formula,
25    T: Serialize<[F]>,
26{
27    #[inline(always)]
28    fn serialize<B>(self, sizes: &mut Sizes, mut buffer: B) -> Result<(), B::Error>
29    where
30        B: Buffer,
31    {
32        let size = write_ref::<[F], T, _>(self, sizes, buffer.reborrow())?;
33        write_reference::<[F], B>(size, sizes.heap, sizes.heap, sizes.stack, buffer)?;
34        sizes.stack += reference_size::<[F]>();
35        Ok(())
36    }
37
38    #[inline(always)]
39    fn size_hint(&self) -> Option<Sizes> {
40        let mut sizes = <Self as Serialize<[F]>>::size_hint(self)?;
41        sizes.to_heap(0);
42        sizes.add_stack(reference_size::<[F]>());
43        Some(sizes)
44    }
45}
46
47impl<'de, F, T> Deserialize<'de, Vec<F>> for T
48where
49    F: Formula,
50    T: Deserialize<'de, [F]>,
51{
52    #[inline(always)]
53    fn deserialize(de: Deserializer<'de>) -> Result<T, DeserializeError> {
54        let de = de.deref::<[F]>()?;
55        <T as Deserialize<[F]>>::deserialize(de)
56    }
57
58    #[inline(always)]
59    fn deserialize_in_place(&mut self, de: Deserializer<'de>) -> Result<(), DeserializeError> {
60        let de = de.deref::<[F]>()?;
61        <T as Deserialize<[F]>>::deserialize_in_place(self, de)
62    }
63}
64
65impl<F, T> Serialize<[F]> for Vec<T>
66where
67    F: Formula,
68    T: Serialize<F>,
69{
70    #[inline(always)]
71    fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>
72    where
73        B: Buffer,
74    {
75        write_slice(self.into_iter(), sizes, buffer)
76    }
77
78    #[inline(always)]
79    fn size_hint(&self) -> Option<Sizes> {
80        ref_iter_fast_sizes::<F, _, _>(self.iter())
81    }
82}
83
84impl<'ser, F, T> Serialize<[F]> for &'ser Vec<T>
85where
86    F: Formula,
87    &'ser T: Serialize<F>,
88{
89    #[inline(always)]
90    fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>
91    where
92        B: Buffer,
93    {
94        write_slice(self.iter(), sizes, buffer)
95    }
96
97    #[inline(always)]
98    fn size_hint(&self) -> Option<Sizes> {
99        owned_iter_fast_sizes::<F, _, _>(self.iter())
100    }
101}
102
103impl<'de, F, T> Deserialize<'de, [F]> for Vec<T>
104where
105    F: Formula,
106    T: Deserialize<'de, F>,
107{
108    #[inline(always)]
109    fn deserialize(de: Deserializer<'de>) -> Result<Self, DeserializeError> {
110        let iter = de.into_unsized_iter();
111        let (lower, _) = Iterator::size_hint(&iter);
112        let mut vec = Vec::with_capacity(lower);
113        deserialize_extend_iter(&mut vec, iter)?;
114        Ok(vec)
115    }
116
117    #[inline(always)]
118    fn deserialize_in_place(&mut self, de: Deserializer<'de>) -> Result<(), DeserializeError> {
119        self.clear();
120        let iter = de.into_unsized_iter();
121        let (lower, _) = Iterator::size_hint(&iter);
122        self.reserve(lower);
123        deserialize_extend_iter(self, iter)
124    }
125}
126
127impl<'de, F, T, const N: usize> Deserialize<'de, [F; N]> for Vec<T>
128where
129    F: Formula,
130    T: Deserialize<'de, F>,
131{
132    #[inline(always)]
133    fn deserialize(de: Deserializer<'de>) -> Result<Self, DeserializeError> {
134        let mut vec = Vec::with_capacity(N);
135        deserialize_extend_iter(&mut vec, de.into_unsized_array_iter(N))?;
136        Ok(vec)
137    }
138
139    #[inline(always)]
140    fn deserialize_in_place(&mut self, de: Deserializer<'de>) -> Result<(), DeserializeError> {
141        self.clear();
142        self.reserve(N);
143        deserialize_extend_iter(self, de.into_unsized_array_iter(N))
144    }
145}
146
147impl Serialize<Bytes> for Vec<u8> {
148    #[inline(always)]
149    fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>
150    where
151        B: Buffer,
152    {
153        write_bytes(self.as_slice(), sizes, buffer)
154    }
155
156    #[inline(always)]
157    fn size_hint(&self) -> Option<Sizes> {
158        Some(Sizes::with_stack(self.len()))
159    }
160}
161
162impl Serialize<Bytes> for &Vec<u8> {
163    #[inline(always)]
164    fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>
165    where
166        B: Buffer,
167    {
168        write_bytes(self.as_slice(), sizes, buffer)
169    }
170
171    #[inline(always)]
172    fn size_hint(&self) -> Option<Sizes> {
173        Some(Sizes::with_stack(self.len()))
174    }
175}
176
177impl<'de> Deserialize<'de, Bytes> for Vec<u8> {
178    #[inline(always)]
179    fn deserialize(de: Deserializer) -> Result<Self, DeserializeError> {
180        let mut vec = Vec::new();
181        vec.extend_from_slice(de.read_all_bytes());
182        Ok(vec)
183    }
184
185    #[inline(always)]
186    fn deserialize_in_place(&mut self, de: Deserializer) -> Result<(), DeserializeError> {
187        self.clear();
188        self.extend_from_slice(de.read_all_bytes());
189        Ok(())
190    }
191}
alkahest/vec.rs

alkahest/
vec.rs
