1use std::fmt;
2
3struct DeserializeWrapper<T>(T);
4
5impl<'de, T> serde::de::DeserializeSeed<'de> for DeserializeWrapper<T>
6where
7 T: serde::de::DeserializeSeed<'de>,
8{
9 type Value = T::Value;
10
11 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
12 where
13 D: serde::Deserializer<'de>,
14 {
15 self.0.deserialize(DeserializerWrapper::new(deserializer))
16 }
17}
18
19pub struct DeserializerWrapper<D> {
20 deserializer: D,
21}
22
23impl<D> DeserializerWrapper<D> {
24 pub fn new(deserializer: D) -> Self {
25 Self { deserializer }
26 }
27}
28
29struct WrappedVisitor<V> {
30 visitor: V,
31}
32
33impl<V> WrappedVisitor<V> {
34 fn new(visitor: V) -> Self {
35 Self { visitor }
36 }
37}
38
39struct SeqAccessWrapper<A> {
40 access: A,
41}
42
43impl<'de, A> serde::de::SeqAccess<'de> for SeqAccessWrapper<A>
44where
45 A: serde::de::SeqAccess<'de>,
46{
47 type Error = A::Error;
48
49 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
50 where
51 T: serde::de::DeserializeSeed<'de>,
52 {
53 self.access.next_element_seed(DeserializeWrapper(seed))
54 }
55
56 fn size_hint(&self) -> Option<usize> {
57 self.access.size_hint()
58 }
59}
60
61impl<A> SeqAccessWrapper<A> {
62 fn new(access: A) -> Self {
63 Self { access }
64 }
65}
66
67enum State {
68 Key,
69 Value,
70 Finished,
71}
72
73struct MapAccessWrapper<A> {
74 access: A,
75 state: State,
76}
77
78impl<'de, A> serde::de::MapAccess<'de> for &mut MapAccessWrapper<A>
79where
80 A: serde::de::MapAccess<'de>,
81{
82 type Error = A::Error;
83
84 #[inline]
85 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
86 where
87 K: serde::de::DeserializeSeed<'de>,
88 {
89 match self.state {
90 State::Key => {
91 let value = self.access.next_key_seed(DeserializeWrapper(seed));
92 if value.as_ref().is_ok_and(|v| v.is_none()) {
93 self.state = State::Finished;
94 } else {
95 self.state = State::Value;
96 }
97 value
98 }
99 State::Value => Err(serde::de::Error::custom("invalid call to next_key_seed")),
100 State::Finished => Ok(None),
101 }
102 }
103
104 #[inline]
105 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
106 where
107 V: serde::de::DeserializeSeed<'de>,
108 {
109 match self.state {
110 State::Key | State::Finished => Err(serde::de::Error::custom("invalid call to next_value_seed")),
111 State::Value => {
112 self.state = State::Key;
113 self.access.next_value_seed(DeserializeWrapper(seed))
114 }
115 }
116 }
117
118 #[inline]
119 fn size_hint(&self) -> Option<usize> {
120 self.access.size_hint()
121 }
122}
123
124impl<A> MapAccessWrapper<A> {
125 #[inline]
126 fn new(access: A) -> Self {
127 Self {
128 access,
129 state: State::Key,
130 }
131 }
132}
133
134impl<'de, V> serde::de::Visitor<'de> for WrappedVisitor<V>
135where
136 V: serde::de::Visitor<'de>,
137{
138 type Value = V::Value;
139
140 #[inline]
141 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
142 self.visitor.expecting(formatter)
143 }
144
145 fn visit_map<A>(self, access: A) -> Result<Self::Value, A::Error>
146 where
147 A: serde::de::MapAccess<'de>,
148 {
149 let mut access = MapAccessWrapper::new(access);
150 let result = self.visitor.visit_map(&mut access);
151 if matches!(access.state, State::Value) && access.access.next_value::<serde::de::IgnoredAny>().is_err() {
152 return result;
153 }
154
155 serde::de::IgnoredAny.visit_map(access.access).ok();
156
157 result
158 }
159
160 #[inline]
161 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
162 where
163 E: serde::de::Error,
164 {
165 self.visitor.visit_bool(v)
166 }
167
168 #[inline]
169 fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
170 where
171 E: serde::de::Error,
172 {
173 self.visitor.visit_borrowed_bytes(v)
174 }
175
176 #[inline]
177 fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
178 where
179 E: serde::de::Error,
180 {
181 self.visitor.visit_borrowed_str(v)
182 }
183
184 #[inline]
185 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
186 where
187 E: serde::de::Error,
188 {
189 self.visitor.visit_byte_buf(v)
190 }
191
192 #[inline]
193 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
194 where
195 E: serde::de::Error,
196 {
197 self.visitor.visit_bytes(v)
198 }
199
200 #[inline]
201 fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
202 where
203 E: serde::de::Error,
204 {
205 self.visitor.visit_char(v)
206 }
207
208 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
209 where
210 A: serde::de::EnumAccess<'de>,
211 {
212 self.visitor.visit_enum(EnumAccessWrapper::new(data))
213 }
214
215 #[inline]
216 fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
217 where
218 E: serde::de::Error,
219 {
220 self.visitor.visit_f32(v)
221 }
222
223 #[inline]
224 fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
225 where
226 E: serde::de::Error,
227 {
228 self.visitor.visit_f64(v)
229 }
230
231 #[inline]
232 fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
233 where
234 E: serde::de::Error,
235 {
236 self.visitor.visit_i128(v)
237 }
238
239 #[inline]
240 fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
241 where
242 E: serde::de::Error,
243 {
244 self.visitor.visit_i16(v)
245 }
246
247 #[inline]
248 fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
249 where
250 E: serde::de::Error,
251 {
252 self.visitor.visit_i32(v)
253 }
254
255 #[inline]
256 fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
257 where
258 E: serde::de::Error,
259 {
260 self.visitor.visit_i64(v)
261 }
262
263 #[inline]
264 fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
265 where
266 E: serde::de::Error,
267 {
268 self.visitor.visit_i8(v)
269 }
270
271 #[inline]
272 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
273 where
274 D: serde::Deserializer<'de>,
275 {
276 self.visitor.visit_newtype_struct(DeserializerWrapper::new(deserializer))
277 }
278
279 #[inline]
280 fn visit_none<E>(self) -> Result<Self::Value, E>
281 where
282 E: serde::de::Error,
283 {
284 self.visitor.visit_none()
285 }
286
287 fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
288 where
289 A: serde::de::SeqAccess<'de>,
290 {
291 let mut seq = SeqAccessWrapper::new(seq);
292 let result = self.visitor.visit_seq(&mut seq);
293 serde::de::IgnoredAny.visit_seq(seq.access).ok();
294 result
295 }
296
297 #[inline]
298 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
299 where
300 D: serde::Deserializer<'de>,
301 {
302 self.visitor.visit_some(DeserializerWrapper::new(deserializer))
303 }
304
305 #[inline]
306 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
307 where
308 E: serde::de::Error,
309 {
310 self.visitor.visit_str(v)
311 }
312
313 #[inline]
314 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
315 where
316 E: serde::de::Error,
317 {
318 self.visitor.visit_string(v)
319 }
320
321 #[inline]
322 fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
323 where
324 E: serde::de::Error,
325 {
326 self.visitor.visit_u128(v)
327 }
328
329 #[inline]
330 fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
331 where
332 E: serde::de::Error,
333 {
334 self.visitor.visit_u16(v)
335 }
336
337 #[inline]
338 fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
339 where
340 E: serde::de::Error,
341 {
342 self.visitor.visit_u32(v)
343 }
344
345 #[inline]
346 fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
347 where
348 E: serde::de::Error,
349 {
350 self.visitor.visit_u64(v)
351 }
352
353 #[inline]
354 fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
355 where
356 E: serde::de::Error,
357 {
358 self.visitor.visit_u8(v)
359 }
360
361 #[inline]
362 fn visit_unit<E>(self) -> Result<Self::Value, E>
363 where
364 E: serde::de::Error,
365 {
366 self.visitor.visit_unit()
367 }
368}
369
370struct EnumAccessWrapper<A> {
371 access: A,
372}
373
374impl<A> EnumAccessWrapper<A> {
375 fn new(access: A) -> Self {
376 Self { access }
377 }
378}
379
380impl<'de, A> serde::de::EnumAccess<'de> for EnumAccessWrapper<A>
381where
382 A: serde::de::EnumAccess<'de>,
383{
384 type Error = A::Error;
385 type Variant = A::Variant;
386
387 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
388 where
389 V: serde::de::DeserializeSeed<'de>,
390 {
391 self.access.variant_seed(DeserializeWrapper(seed))
392 }
393}
394
395impl<'de, D> serde::Deserializer<'de> for DeserializerWrapper<D>
396where
397 D: serde::Deserializer<'de>,
398{
399 type Error = D::Error;
400
401 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
402 where
403 V: serde::de::Visitor<'de>,
404 {
405 self.deserializer.deserialize_any(WrappedVisitor::new(visitor))
406 }
407
408 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
409 where
410 V: serde::de::Visitor<'de>,
411 {
412 self.deserializer.deserialize_bool(WrappedVisitor::new(visitor))
413 }
414
415 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
416 where
417 V: serde::de::Visitor<'de>,
418 {
419 self.deserializer.deserialize_byte_buf(WrappedVisitor::new(visitor))
420 }
421
422 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
423 where
424 V: serde::de::Visitor<'de>,
425 {
426 self.deserializer.deserialize_bytes(WrappedVisitor::new(visitor))
427 }
428
429 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
430 where
431 V: serde::de::Visitor<'de>,
432 {
433 self.deserializer.deserialize_char(WrappedVisitor::new(visitor))
434 }
435
436 fn deserialize_enum<V>(
437 self,
438 name: &'static str,
439 variants: &'static [&'static str],
440 visitor: V,
441 ) -> Result<V::Value, Self::Error>
442 where
443 V: serde::de::Visitor<'de>,
444 {
445 self.deserializer
446 .deserialize_enum(name, variants, WrappedVisitor::new(visitor))
447 }
448
449 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
450 where
451 V: serde::de::Visitor<'de>,
452 {
453 self.deserializer.deserialize_f32(WrappedVisitor::new(visitor))
454 }
455
456 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
457 where
458 V: serde::de::Visitor<'de>,
459 {
460 self.deserializer.deserialize_f64(WrappedVisitor::new(visitor))
461 }
462
463 fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
464 where
465 V: serde::de::Visitor<'de>,
466 {
467 self.deserializer.deserialize_i128(WrappedVisitor::new(visitor))
468 }
469
470 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
471 where
472 V: serde::de::Visitor<'de>,
473 {
474 self.deserializer.deserialize_i16(WrappedVisitor::new(visitor))
475 }
476
477 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
478 where
479 V: serde::de::Visitor<'de>,
480 {
481 self.deserializer.deserialize_i32(WrappedVisitor::new(visitor))
482 }
483
484 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
485 where
486 V: serde::de::Visitor<'de>,
487 {
488 self.deserializer.deserialize_i64(WrappedVisitor::new(visitor))
489 }
490
491 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
492 where
493 V: serde::de::Visitor<'de>,
494 {
495 self.deserializer.deserialize_i8(WrappedVisitor::new(visitor))
496 }
497
498 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
499 where
500 V: serde::de::Visitor<'de>,
501 {
502 self.deserializer.deserialize_identifier(WrappedVisitor::new(visitor))
503 }
504
505 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
506 where
507 V: serde::de::Visitor<'de>,
508 {
509 self.deserializer.deserialize_ignored_any(WrappedVisitor::new(visitor))
510 }
511
512 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
513 where
514 V: serde::de::Visitor<'de>,
515 {
516 self.deserializer.deserialize_map(WrappedVisitor::new(visitor))
517 }
518
519 fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
520 where
521 V: serde::de::Visitor<'de>,
522 {
523 self.deserializer
524 .deserialize_newtype_struct(name, WrappedVisitor::new(visitor))
525 }
526
527 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
528 where
529 V: serde::de::Visitor<'de>,
530 {
531 self.deserializer.deserialize_option(WrappedVisitor::new(visitor))
532 }
533
534 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
535 where
536 V: serde::de::Visitor<'de>,
537 {
538 self.deserializer.deserialize_seq(WrappedVisitor::new(visitor))
539 }
540
541 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
542 where
543 V: serde::de::Visitor<'de>,
544 {
545 self.deserializer.deserialize_str(WrappedVisitor::new(visitor))
546 }
547
548 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
549 where
550 V: serde::de::Visitor<'de>,
551 {
552 self.deserializer.deserialize_string(WrappedVisitor::new(visitor))
553 }
554
555 fn deserialize_struct<V>(
556 self,
557 name: &'static str,
558 fields: &'static [&'static str],
559 visitor: V,
560 ) -> Result<V::Value, Self::Error>
561 where
562 V: serde::de::Visitor<'de>,
563 {
564 self.deserializer
565 .deserialize_struct(name, fields, WrappedVisitor::new(visitor))
566 }
567
568 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
569 where
570 V: serde::de::Visitor<'de>,
571 {
572 self.deserializer.deserialize_tuple(len, WrappedVisitor::new(visitor))
573 }
574
575 fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize, visitor: V) -> Result<V::Value, Self::Error>
576 where
577 V: serde::de::Visitor<'de>,
578 {
579 self.deserializer
580 .deserialize_tuple_struct(name, len, WrappedVisitor::new(visitor))
581 }
582
583 fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
584 where
585 V: serde::de::Visitor<'de>,
586 {
587 self.deserializer.deserialize_u128(WrappedVisitor::new(visitor))
588 }
589
590 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
591 where
592 V: serde::de::Visitor<'de>,
593 {
594 self.deserializer.deserialize_u16(WrappedVisitor::new(visitor))
595 }
596
597 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
598 where
599 V: serde::de::Visitor<'de>,
600 {
601 self.deserializer.deserialize_u32(WrappedVisitor::new(visitor))
602 }
603
604 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
605 where
606 V: serde::de::Visitor<'de>,
607 {
608 self.deserializer.deserialize_u64(WrappedVisitor::new(visitor))
609 }
610
611 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
612 where
613 V: serde::de::Visitor<'de>,
614 {
615 self.deserializer.deserialize_u8(WrappedVisitor::new(visitor))
616 }
617
618 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
619 where
620 V: serde::de::Visitor<'de>,
621 {
622 self.deserializer.deserialize_unit(WrappedVisitor::new(visitor))
623 }
624
625 fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
626 where
627 V: serde::de::Visitor<'de>,
628 {
629 self.deserializer.deserialize_unit_struct(name, WrappedVisitor::new(visitor))
630 }
631
632 fn is_human_readable(&self) -> bool {
633 self.deserializer.is_human_readable()
634 }
635}