1use core::marker::PhantomData;
2use std::fmt;
3
4use thiserror::Error;
5use serde::de::{
6 self, DeserializeSeed, SeqAccess, Visitor,
7};
8
9use atm_parser_helper::Error;
10
11pub struct BytesAsSeq<E> {
12 b: Vec<u8>,
13 i: usize,
14 err_position: usize,
15 e_bounds: E,
16 e_int: E,
17}
18
19impl<E: Clone> BytesAsSeq<E> {
20 pub fn new(b: Vec<u8>, err_position: usize, e_bounds: E, e_int: E) -> Self {
21 BytesAsSeq { b, i: 0, err_position, e_bounds, e_int }
22 }
23}
24
25impl<'de, E: Clone + serde::de::Error> SeqAccess<'de> for BytesAsSeq<E> {
26 type Error = Error<E>;
27
28 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
29 where
30 T: DeserializeSeed<'de>,
31 {
32 match self.b.get(self.i) {
33 Some(b) => {
34 self.i += 1;
35 return seed.deserialize(IntFromByte {
36 b: *b,
37 err_position: self.err_position,
38 e_bounds: self.e_bounds.clone(),
39 e_int: self.e_int.clone(),
40 }).map(|yay| Some(yay));
41 }
42 None => Ok(None),
43 }
44 }
45}
46
47struct IntFromByte<E> {
48 b: u8,
49 err_position: usize,
50 e_bounds: E,
51 e_int: E,
52}
53
54impl<'de, E: serde::de::Error + Clone> de::Deserializer<'de> for IntFromByte<E> {
55 type Error = Error<E>;
56
57 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
58 where
59 V: Visitor<'de>,
60 {
61 self.deserialize_i64(visitor)
62 }
63
64 fn deserialize_bool<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
65 where
66 V: Visitor<'de>,
67 {
68 Err(Error::new(self.err_position, self.e_int.clone()))
69 }
70
71 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
72 where
73 V: Visitor<'de>,
74 {
75 if self.b <= (i8::MAX as u8) {
76 visitor.visit_i8(self.b as i8)
77 } else {
78 Err(Error::new(self.err_position, self.e_bounds.clone()))
79 }
80 }
81
82 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
83 where
84 V: Visitor<'de>,
85 {
86 visitor.visit_i16(self.b.into())
87 }
88
89 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
90 where
91 V: Visitor<'de>,
92 {
93 visitor.visit_i32(self.b.into())
94 }
95
96 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
97 where
98 V: Visitor<'de>,
99 {
100 visitor.visit_i64(self.b.into())
101 }
102
103 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
104 where
105 V: Visitor<'de>,
106 {
107 visitor.visit_u8(self.b.into())
108 }
109
110 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
111 where
112 V: Visitor<'de>,
113 {
114 visitor.visit_u16(self.b.into())
115 }
116
117 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
118 where
119 V: Visitor<'de>,
120 {
121 visitor.visit_u32(self.b.into())
122 }
123
124 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
125 where
126 V: Visitor<'de>,
127 {
128 visitor.visit_u64(self.b.into())
129 }
130
131 fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
132 where
133 V: Visitor<'de>,
134 {
135 Err(Error::new(self.err_position, self.e_int.clone()))
136 }
137
138 fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
139 where
140 V: Visitor<'de>,
141 {
142 Err(Error::new(self.err_position, self.e_int.clone()))
143 }
144
145 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
146 where
147 V: Visitor<'de>,
148 {
149 visitor.visit_char(self.b.into())
150 }
151
152 fn deserialize_str<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
153 where
154 V: Visitor<'de>,
155 {
156 Err(Error::new(self.err_position, self.e_int.clone()))
157 }
158
159 fn deserialize_string<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
160 where
161 V: Visitor<'de>,
162 {
163 Err(Error::new(self.err_position, self.e_int.clone()))
164 }
165
166 fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
167 where
168 V: Visitor<'de>,
169 {
170 Err(Error::new(self.err_position, self.e_int.clone()))
171 }
172
173 fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
174 where
175 V: Visitor<'de>,
176 {
177 Err(Error::new(self.err_position, self.e_int.clone()))
178 }
179
180 fn deserialize_option<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
181 where
182 V: Visitor<'de>,
183 {
184 Err(Error::new(self.err_position, self.e_int.clone()))
185 }
186
187 fn deserialize_unit<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
188 where
189 V: Visitor<'de>,
190 {
191 Err(Error::new(self.err_position, self.e_int.clone()))
192 }
193
194 fn deserialize_unit_struct<V>(
195 self,
196 _name: &'static str,
197 _visitor: V,
198 ) -> Result<V::Value, Self::Error>
199 where
200 V: Visitor<'de>,
201 {
202 Err(Error::new(self.err_position, self.e_int.clone()))
203 }
204
205 fn deserialize_newtype_struct<V>(
206 self,
207 _name: &'static str,
208 _visitor: V,
209 ) -> Result<V::Value, Self::Error>
210 where
211 V: Visitor<'de>,
212 {
213 Err(Error::new(self.err_position, self.e_int.clone()))
214 }
215
216 fn deserialize_seq<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
217 where
218 V: Visitor<'de>,
219 {
220 Err(Error::new(self.err_position, self.e_int.clone()))
221 }
222
223 fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
224 where
225 V: Visitor<'de>,
226 {
227 Err(Error::new(self.err_position, self.e_int.clone()))
228 }
229
230 fn deserialize_tuple_struct<V>(
231 self,
232 _name: &'static str,
233 _len: usize,
234 _visitor: V,
235 ) -> Result<V::Value, Self::Error>
236 where
237 V: Visitor<'de>,
238 {
239 Err(Error::new(self.err_position, self.e_int.clone()))
240 }
241
242 fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
243 where
244 V: Visitor<'de>,
245 {
246 Err(Error::new(self.err_position, self.e_int.clone()))
247 }
248
249 fn deserialize_struct<V>(
250 self,
251 _name: &'static str,
252 _fields: &'static [&'static str],
253 _visitor: V,
254 ) -> Result<V::Value, Self::Error>
255 where
256 V: Visitor<'de>,
257 {
258 Err(Error::new(self.err_position, self.e_int.clone()))
259 }
260
261 fn deserialize_enum<V>(
262 self,
263 _name: &'static str,
264 _variants: &'static [&'static str],
265 _visitor: V,
266 ) -> Result<V::Value, Self::Error>
267 where
268 V: Visitor<'de>,
269 {
270 Err(Error::new(self.err_position, self.e_int.clone()))
271 }
272
273 fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
274 where
275 V: Visitor<'de>,
276 {
277 Err(Error::new(self.err_position, self.e_int.clone()))
278 }
279
280 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
281 where
282 V: Visitor<'de>,
283 {
284 self.deserialize_any(visitor)
285 }
286
287 fn is_human_readable(&self) -> bool {
288 false
289 }
290}
291
292#[derive(Error, Debug)]
293#[error("can only decode a set where a map that maps all keys to nil would be valid")]
294pub struct AlwaysNilError;
295
296impl de::Error for AlwaysNilError {
297 fn custom<T: fmt::Display>(_msg: T) -> Self {
298 AlwaysNilError
299 }
300}
301
302pub struct AlwaysNil<'de>(PhantomData<&'de ()>);
303
304impl<'de> AlwaysNil<'de> {
305 pub fn new() -> Self {
306 AlwaysNil(PhantomData)
307 }
308}
309
310impl<'a, 'de> de::Deserializer<'de> for AlwaysNil<'de> {
311 type Error = AlwaysNilError;
312
313 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
314 where
315 V: Visitor<'de>,
316 {
317 self.deserialize_unit(visitor)
318 }
319
320 fn deserialize_bool<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
321 where
322 V: Visitor<'de>,
323 {
324 Err(AlwaysNilError)
325 }
326
327 fn deserialize_i8<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
328 where
329 V: Visitor<'de>,
330 {
331 Err(AlwaysNilError)
332 }
333
334 fn deserialize_i16<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
335 where
336 V: Visitor<'de>,
337 {
338 Err(AlwaysNilError)
339 }
340
341 fn deserialize_i32<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
342 where
343 V: Visitor<'de>,
344 {
345 Err(AlwaysNilError)
346 }
347
348 fn deserialize_i64<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
349 where
350 V: Visitor<'de>,
351 {
352 Err(AlwaysNilError)
353 }
354
355 fn deserialize_u8<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
356 where
357 V: Visitor<'de>,
358 {
359 Err(AlwaysNilError)
360 }
361
362 fn deserialize_u16<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
363 where
364 V: Visitor<'de>,
365 {
366 Err(AlwaysNilError)
367 }
368
369 fn deserialize_u32<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
370 where
371 V: Visitor<'de>,
372 {
373 Err(AlwaysNilError)
374 }
375
376 fn deserialize_u64<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
377 where
378 V: Visitor<'de>,
379 {
380 Err(AlwaysNilError)
381 }
382
383 fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
384 where
385 V: Visitor<'de>,
386 {
387 Err(AlwaysNilError)
388 }
389
390 fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
391 where
392 V: Visitor<'de>,
393 {
394 Err(AlwaysNilError)
395 }
396
397 fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
398 where
399 V: Visitor<'de>,
400 {
401 Err(AlwaysNilError)
402 }
403
404 fn deserialize_str<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
405 where
406 V: Visitor<'de>,
407 {
408 Err(AlwaysNilError)
409 }
410
411 fn deserialize_string<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
412 where
413 V: Visitor<'de>,
414 {
415 Err(AlwaysNilError)
416 }
417
418 fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
419 where
420 V: Visitor<'de>,
421 {
422 Err(AlwaysNilError)
423 }
424
425 fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
426 where
427 V: Visitor<'de>,
428 {
429 Err(AlwaysNilError)
430 }
431
432 fn deserialize_option<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
433 where
434 V: Visitor<'de>,
435 {
436 Err(AlwaysNilError)
437 }
438
439 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
440 where
441 V: Visitor<'de>,
442 {
443 visitor.visit_unit()
444 }
445
446 fn deserialize_unit_struct<V>(
447 self,
448 _name: &'static str,
449 visitor: V,
450 ) -> Result<V::Value, Self::Error>
451 where
452 V: Visitor<'de>,
453 {
454 self.deserialize_unit(visitor)
455 }
456
457 fn deserialize_newtype_struct<V>(
458 self,
459 _name: &'static str,
460 visitor: V,
461 ) -> Result<V::Value, Self::Error>
462 where
463 V: Visitor<'de>,
464 {
465 visitor.visit_newtype_struct(self)
466 }
467
468 fn deserialize_seq<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
469 where
470 V: Visitor<'de>,
471 {
472 Err(AlwaysNilError)
473 }
474
475 fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
476 where
477 V: Visitor<'de>,
478 {
479 Err(AlwaysNilError)
480 }
481
482 fn deserialize_tuple_struct<V>(
483 self,
484 _name: &'static str,
485 _len: usize,
486 _visitor: V,
487 ) -> Result<V::Value, Self::Error>
488 where
489 V: Visitor<'de>,
490 {
491 Err(AlwaysNilError)
492 }
493
494 fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
495 where
496 V: Visitor<'de>,
497 {
498 Err(AlwaysNilError)
499 }
500
501 fn deserialize_struct<V>(
502 self,
503 _name: &'static str,
504 _fields: &'static [&'static str],
505 _visitor: V,
506 ) -> Result<V::Value, Self::Error>
507 where
508 V: Visitor<'de>,
509 {
510 Err(AlwaysNilError)
511 }
512
513 fn deserialize_enum<V>(
514 self,
515 _name: &'static str,
516 _variants: &'static [&'static str],
517 _visitor: V,
518 ) -> Result<V::Value, Self::Error>
519 where
520 V: Visitor<'de>,
521 {
522 Err(AlwaysNilError)
523 }
524
525 fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
526 where
527 V: Visitor<'de>,
528 {
529 Err(AlwaysNilError)
530 }
531
532 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
533 where
534 V: Visitor<'de>,
535 {
536 self.deserialize_any(visitor)
537 }
538
539 fn is_human_readable(&self) -> bool {
540 false
541 }
542}