1use std::fmt::Formatter;
2use std::marker::PhantomData;
3use std::mem;
4use serde::de::{DeserializeSeed, Error, MapAccess, SeqAccess, Visitor};
5use serde::{Deserializer, forward_to_deserialize_any};
6use crate::node::BucketNode;
7
8pub struct BucketDeserializer<'de, E> where E: serde::de::Error {
9 pub(crate) buffer: &'de mut [BucketNode<'de>],
10 pub(crate) cursor: usize,
11 pub(crate) error: PhantomData<E>,
12 pub(crate) clone: bool,
13}
14
15
16impl<'x, 'de, E> Deserializer<'de> for &'x mut BucketDeserializer<'de, E> where E: serde::de::Error {
17 type Error = E;
18
19 fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
20 let node= &mut self.buffer[self.cursor];
21 self.cursor += 1;
22 match node {
23 BucketNode::Consumed => return Err(E::custom("value as already been consumed")),
24 BucketNode::Unsized => return Err(E::custom("invalid value - no size data")),
25
26 BucketNode::Unit => visitor.visit_unit(),
27 BucketNode::None => visitor.visit_none(),
28
29 BucketNode::Bool(val) => visitor.visit_bool(*val),
30 BucketNode::U8(val) => visitor.visit_u8(*val),
31 BucketNode::I8(val) => visitor.visit_i8(*val),
32 BucketNode::U16(val) => visitor.visit_u16(*val),
33 BucketNode::I16(val) => visitor.visit_i16(*val),
34 BucketNode::U32(val) => visitor.visit_u32(*val),
35 BucketNode::I32(val) => visitor.visit_i32(*val),
36 BucketNode::U64(val) => visitor.visit_u64(*val),
37 BucketNode::I64(val) => visitor.visit_i64(*val),
38 BucketNode::U128(val) => visitor.visit_u128(*val),
39 BucketNode::I128(val) => visitor.visit_i128(*val),
40 BucketNode::F32(val) => visitor.visit_f32(*val),
41 BucketNode::F64(val) => visitor.visit_f64(*val),
42 BucketNode::Char(val) => visitor.visit_char(*val),
43
44 BucketNode::Bytes(bytes) if self.clone => {
45 visitor.visit_byte_buf(bytes.clone())
46 },
47 val @ BucketNode::Bytes(_) => {
48 let mut drain = BucketNode::Consumed;
49 mem::swap(val, &mut drain);
50 let BucketNode::Bytes(bytes) = drain else {
51 unreachable!()
52 };
53 visitor.visit_byte_buf(bytes)
54 }
55 BucketNode::BytesRef(val) => visitor.visit_borrowed_bytes(val),
56
57 BucketNode::String(string) if self.clone => {
58 visitor.visit_string(string.clone())
59 },
60 val @ BucketNode::String(_) => {
61
62 let mut drain = BucketNode::Consumed;
63 mem::swap(val, &mut drain);
64 let BucketNode::String(string) = drain else {
65 unreachable!()
66 };
67
68 visitor.visit_string(string)
69 },
70 BucketNode::StringRef(val) => visitor.visit_borrowed_str(val),
71
72 BucketNode::Some => visitor.visit_some(self),
73
74 BucketNode::NewType => visitor.visit_newtype_struct(self),
75 BucketNode::Seq(size) => visitor.visit_seq(BucketSeqDeserializer {
76 size: *size,
77 bucket: self,
78 }),
79 BucketNode::Map(size) => visitor.visit_map(BucketMapDeserializer {
80 size: *size,
81 bucket: self,
82 pending: false,
83 })
84 }
85 }
86
87 forward_to_deserialize_any! {
88 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
89 bytes byte_buf unit unit_struct newtype_struct seq tuple
90 tuple_struct map struct enum identifier ignored_any
91 }
92
93 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
94 visitor.visit_some(self)
95 }
96}
97
98struct BucketSeqDeserializer<'x, 'de, E> where E: serde::de::Error {
99 bucket: &'x mut BucketDeserializer<'de, E>,
100 size: usize,
101}
102
103impl<'x, 'de, E> SeqAccess<'de> for BucketSeqDeserializer<'x, 'de, E> where E: serde::de::Error {
104 type Error = E;
105
106 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> where T: DeserializeSeed<'de> {
107 if self.size == 0 {
108 Ok(None)
109 } else {
110 self.size -= 1;
111 seed.deserialize(&mut *self.bucket)
112 .map(Some)
113 }
114 }
115}
116
117struct BucketMapDeserializer<'x, 'de, E> where E: serde::de::Error {
118 bucket: &'x mut BucketDeserializer<'de, E>,
119 size: usize,
120 pending: bool,
121}
122
123impl<'x, 'de, E> MapAccess<'de> for BucketMapDeserializer<'x, 'de, E> where E: serde::de::Error {
124 type Error = E;
125
126 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error> where K: DeserializeSeed<'de> {
127 if self.pending {
128 return Err(E::custom("out-of-order access - no value for previous key"));
129 }
130 if self.size == 0 {
131 return Ok(None)
132 }
133 self.pending = true;
134 seed.deserialize(&mut *self.bucket).map(Some)
135 }
136
137 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error> where V: DeserializeSeed<'de> {
138 if !self.pending {
139 return Err(E::custom("out-of-order access - no key for this value"));
140 }
141 self.pending = false;
142 self.size -= 1;
143 seed.deserialize(&mut *self.bucket)
144 }
145}
146
147pub struct BucketVisitor<'t, 'de> {
148 pub(crate) target: &'t mut Vec<BucketNode<'de>>,
149 pub(crate) owned: bool,
150}
151
152impl<'x, 't, 'de> Visitor<'de> for &'x mut BucketVisitor<'t, 'de> {
153 type Value = ();
154
155 fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
156 formatter.write_str("valid bucket value/type")
157 }
158
159 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E> where E: Error {
160 self.target.push(BucketNode::Bool(v));
161 Ok(())
162 }
163
164 fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where E: Error {
165 self.target.push(BucketNode::I8(v));
166 Ok(())
167 }
168
169 fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E> where E: Error {
170 self.target.push(BucketNode::I16(v));
171 Ok(())
172 }
173
174 fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E> where E: Error {
175 self.target.push(BucketNode::I32(v));
176 Ok(())
177 }
178
179 fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E> where E: Error {
180 self.target.push(BucketNode::I64(v));
181 Ok(())
182 }
183
184 fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E> where E: Error {
185 self.target.push(BucketNode::I128(v));
186 Ok(())
187 }
188
189 fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> where E: Error {
190 self.target.push(BucketNode::U8(v));
191 Ok(())
192 }
193
194 fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E> where E: Error {
195 self.target.push(BucketNode::U16(v));
196 Ok(())
197 }
198
199 fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E> where E: Error {
200 self.target.push(BucketNode::U32(v));
201 Ok(())
202 }
203
204 fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> where E: Error {
205 self.target.push(BucketNode::U64(v));
206 Ok(())
207 }
208
209 fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E> where E: Error {
210 self.target.push(BucketNode::U128(v));
211 Ok(())
212 }
213
214 fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E> where E: Error {
215 self.target.push(BucketNode::F32(v));
216 Ok(())
217 }
218
219 fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E> where E: Error {
220 self.target.push(BucketNode::F64(v));
221 Ok(())
222 }
223
224 fn visit_char<E>(self, v: char) -> Result<Self::Value, E> where E: Error {
225 self.target.push(BucketNode::Char(v));
226 Ok(())
227 }
228
229 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: Error {
230 self.target.push(BucketNode::String(v.to_owned()));
231 Ok(())
232 }
233
234 fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E> where E: Error {
235 if self.owned {
236 self.target.push(BucketNode::String(v.to_owned()));
237 } else {
238 self.target.push(BucketNode::StringRef(v));
239 }
240 Ok(())
241 }
242
243 fn visit_string<E>(self, v: String) -> Result<Self::Value, E> where E: Error {
244 self.target.push(BucketNode::String(v));
245 Ok(())
246 }
247
248 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> where E: Error {
249 self.target.push(BucketNode::Bytes(v.to_vec()));
250 Ok(())
251 }
252
253 fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E> where E: Error {
254 if self.owned {
255 self.target.push(BucketNode::Bytes(v.to_vec()));
256 } else {
257 self.target.push(BucketNode::BytesRef(v));
258 }
259 Ok(())
260 }
261
262 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> where E: Error {
263 self.target.push(BucketNode::Bytes(v));
264 Ok(())
265 }
266
267 fn visit_none<E>(self) -> Result<Self::Value, E> where E: Error {
268 self.target.push(BucketNode::None);
269 Ok(())
270 }
271
272 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de> {
273 self.target.push(BucketNode::Some);
274 deserializer.deserialize_any(self)
275 }
276
277 fn visit_unit<E>(self) -> Result<Self::Value, E> where E: Error {
278 self.target.push(BucketNode::Unit);
279 Ok(())
280 }
281
282 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de> {
283 self.target.push(BucketNode::NewType);
284 deserializer.deserialize_any(self)
285 }
286
287 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
288 let position = self.target.len();
289 let mut count = 0;
290 self.target.push(BucketNode::Unsized);
291
292 loop {
293 if seq.next_element_seed(&mut *self)?.is_some() {
294 count += 1;
295 } else {
296 break
297 }
298 }
299 self.target[position] = BucketNode::Seq(count);
300 Ok(())
301 }
302
303 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: MapAccess<'de> {
304 let position = self.target.len();
305 let mut count = 0;
306 self.target.push(BucketNode::Unsized);
307
308 while let Some(_) = map.next_key_seed(&mut *self)? {
309 let _ = map.next_value_seed(&mut *self)?;
310 count += 1;
311 }
312
313 self.target[position] = BucketNode::Map(count);
314 Ok(())
315 }
316}
317
318impl<'x, 't, 'de> DeserializeSeed<'de> for &'x mut BucketVisitor<'t, 'de> {
319 type Value = ();
320
321 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de> {
322 deserializer.deserialize_any(self)
323 }
324}