1use serde::de;
2use std::error::Error;
3use std::fmt;
4use std::marker::PhantomData;
5
6use crate::*;
7
8#[derive(Debug)]
9pub enum Unexpected {
10 Bool(bool),
11 Unsigned(u64),
12 Signed(i64),
13 Float(f64),
14 Char(char),
15 Str(String),
16 Bytes(Vec<u8>),
17 Unit,
18 Option,
19 NewtypeStruct,
20 Seq,
21 Map,
22 Enum,
23 UnitVariant,
24 NewtypeVariant,
25 TupleVariant,
26 StructVariant,
27 Other(String),
28}
29
30impl<'a> From<de::Unexpected<'a>> for Unexpected {
31 fn from(unexp: de::Unexpected) -> Unexpected {
32 match unexp {
33 de::Unexpected::Bool(v) => Unexpected::Bool(v),
34 de::Unexpected::Unsigned(v) => Unexpected::Unsigned(v),
35 de::Unexpected::Signed(v) => Unexpected::Signed(v),
36 de::Unexpected::Float(v) => Unexpected::Float(v),
37 de::Unexpected::Char(v) => Unexpected::Char(v),
38 de::Unexpected::Str(v) => Unexpected::Str(v.to_owned()),
39 de::Unexpected::Bytes(v) => Unexpected::Bytes(v.to_owned()),
40 de::Unexpected::Unit => Unexpected::Unit,
41 de::Unexpected::Option => Unexpected::Option,
42 de::Unexpected::NewtypeStruct => Unexpected::NewtypeStruct,
43 de::Unexpected::Seq => Unexpected::Seq,
44 de::Unexpected::Map => Unexpected::Map,
45 de::Unexpected::Enum => Unexpected::Enum,
46 de::Unexpected::UnitVariant => Unexpected::UnitVariant,
47 de::Unexpected::NewtypeVariant => Unexpected::NewtypeVariant,
48 de::Unexpected::TupleVariant => Unexpected::TupleVariant,
49 de::Unexpected::StructVariant => Unexpected::StructVariant,
50 de::Unexpected::Other(v) => Unexpected::Other(v.to_owned()),
51 }
52 }
53}
54
55#[allow(clippy::needless_lifetimes)]
56impl Unexpected {
57 pub fn to_unexpected<'a>(&'a self) -> de::Unexpected<'a> {
58 match *self {
59 Unexpected::Bool(v) => de::Unexpected::Bool(v),
60 Unexpected::Unsigned(v) => de::Unexpected::Unsigned(v),
61 Unexpected::Signed(v) => de::Unexpected::Signed(v),
62 Unexpected::Float(v) => de::Unexpected::Float(v),
63 Unexpected::Char(v) => de::Unexpected::Char(v),
64 Unexpected::Str(ref v) => de::Unexpected::Str(v),
65 Unexpected::Bytes(ref v) => de::Unexpected::Bytes(v),
66 Unexpected::Unit => de::Unexpected::Unit,
67 Unexpected::Option => de::Unexpected::Option,
68 Unexpected::NewtypeStruct => de::Unexpected::NewtypeStruct,
69 Unexpected::Seq => de::Unexpected::Seq,
70 Unexpected::Map => de::Unexpected::Map,
71 Unexpected::Enum => de::Unexpected::Enum,
72 Unexpected::UnitVariant => de::Unexpected::UnitVariant,
73 Unexpected::NewtypeVariant => de::Unexpected::NewtypeVariant,
74 Unexpected::TupleVariant => de::Unexpected::TupleVariant,
75 Unexpected::StructVariant => de::Unexpected::StructVariant,
76 Unexpected::Other(ref v) => de::Unexpected::Other(v),
77 }
78 }
79}
80
81#[derive(Debug)]
82pub enum DeserializerError {
83 Custom(String),
84 InvalidType(Unexpected, String),
85 InvalidValue(Unexpected, String),
86 InvalidLength(usize, String),
87 UnknownVariant(String, &'static [&'static str]),
88 UnknownField(String, &'static [&'static str]),
89 MissingField(&'static str),
90 DuplicateField(&'static str),
91}
92
93impl de::Error for DeserializerError {
94 fn custom<T: fmt::Display>(msg: T) -> Self {
95 DeserializerError::Custom(msg.to_string())
96 }
97
98 fn invalid_type(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self {
99 DeserializerError::InvalidType(unexp.into(), exp.to_string())
100 }
101
102 fn invalid_value(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self {
103 DeserializerError::InvalidValue(unexp.into(), exp.to_string())
104 }
105
106 fn invalid_length(len: usize, exp: &dyn de::Expected) -> Self {
107 DeserializerError::InvalidLength(len, exp.to_string())
108 }
109
110 fn unknown_variant(field: &str, expected: &'static [&'static str]) -> Self {
111 DeserializerError::UnknownVariant(field.into(), expected)
112 }
113
114 fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
115 DeserializerError::UnknownField(field.into(), expected)
116 }
117
118 fn missing_field(field: &'static str) -> Self {
119 DeserializerError::MissingField(field)
120 }
121
122 fn duplicate_field(field: &'static str) -> Self {
123 DeserializerError::DuplicateField(field)
124 }
125}
126
127impl DeserializerError {
128 pub fn to_error<E: de::Error>(&self) -> E {
129 match *self {
130 DeserializerError::Custom(ref msg) => E::custom(msg.clone()),
131 DeserializerError::InvalidType(ref unexp, ref exp) => {
132 E::invalid_type(unexp.to_unexpected(), &&**exp)
133 }
134 DeserializerError::InvalidValue(ref unexp, ref exp) => {
135 E::invalid_value(unexp.to_unexpected(), &&**exp)
136 }
137 DeserializerError::InvalidLength(len, ref exp) => E::invalid_length(len, &&**exp),
138 DeserializerError::UnknownVariant(ref field, exp) => E::unknown_variant(field, exp),
139 DeserializerError::UnknownField(ref field, exp) => E::unknown_field(field, exp),
140 DeserializerError::MissingField(field) => E::missing_field(field),
141 DeserializerError::DuplicateField(field) => E::missing_field(field),
142 }
143 }
144
145 pub fn into_error<E: de::Error>(self) -> E {
146 self.to_error()
147 }
148}
149
150impl Error for DeserializerError {
151 fn description(&self) -> &str {
152 "Document deserializer error"
153 }
154}
155
156impl fmt::Display for DeserializerError {
157 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
158 match *self {
159 DeserializerError::Custom(ref msg) => write!(f, "{}", msg),
160 DeserializerError::InvalidType(ref unexp, ref exp) => write!(
161 f,
162 "Invalid type {}. Expected {}",
163 unexp.to_unexpected(),
164 exp
165 ),
166 DeserializerError::InvalidValue(ref unexp, ref exp) => write!(
167 f,
168 "Invalid Value {}. Expected {}",
169 unexp.to_unexpected(),
170 exp
171 ),
172 DeserializerError::InvalidLength(len, ref exp) => {
173 write!(f, "Invalid length {}. Expected {}", len, exp)
174 }
175 DeserializerError::UnknownVariant(ref field, exp) => write!(
176 f,
177 "Unknown variant {}. Expected one of {}",
178 field,
179 exp.join(", ")
180 ),
181 DeserializerError::UnknownField(ref field, exp) => write!(
182 f,
183 "Unknown field {}. Expected one of {}",
184 field,
185 exp.join(", ")
186 ),
187 DeserializerError::MissingField(field) => write!(f, "Missing field {}", field),
188 DeserializerError::DuplicateField(field) => write!(f, "Duplicate field {}", field),
189 }
190 }
191}
192
193impl From<de::value::Error> for DeserializerError {
194 fn from(e: de::value::Error) -> DeserializerError {
195 DeserializerError::Custom(e.to_string())
196 }
197}
198
199pub struct DocumentVisitor<T: UnstructuredDataTrait>(std::marker::PhantomData<T>);
200
201impl<'de, T: UnstructuredDataTrait> de::Visitor<'de> for DocumentVisitor<T> {
202 type Value = Unstructured<T>;
203
204 fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
205 fmt.write_str("any value")
206 }
207
208 fn visit_bool<E>(self, value: bool) -> Result<Unstructured<T>, E> {
209 Ok(Unstructured::<T>::Bool(value))
210 }
211
212 fn visit_i8<E>(self, value: i8) -> Result<Unstructured<T>, E> {
213 Ok(Unstructured::<T>::Number(Number::I8(value)))
214 }
215
216 fn visit_i16<E>(self, value: i16) -> Result<Unstructured<T>, E> {
217 Ok(Unstructured::<T>::Number(Number::I16(value)))
218 }
219
220 fn visit_i32<E>(self, value: i32) -> Result<Unstructured<T>, E> {
221 Ok(Unstructured::<T>::Number(Number::I32(value)))
222 }
223
224 fn visit_i64<E>(self, value: i64) -> Result<Unstructured<T>, E> {
225 Ok(Unstructured::<T>::Number(Number::I64(value)))
226 }
227
228 fn visit_i128<E>(self, value: i128) -> Result<Unstructured<T>, E> {
229 Ok(Unstructured::<T>::Number(Number::I128(value)))
230 }
231
232 fn visit_u8<E>(self, value: u8) -> Result<Unstructured<T>, E> {
233 Ok(Unstructured::<T>::Number(Number::U8(value)))
234 }
235
236 fn visit_u16<E>(self, value: u16) -> Result<Unstructured<T>, E> {
237 Ok(Unstructured::<T>::Number(Number::U16(value)))
238 }
239
240 fn visit_u32<E>(self, value: u32) -> Result<Unstructured<T>, E> {
241 Ok(Unstructured::<T>::Number(Number::U32(value)))
242 }
243
244 fn visit_u64<E>(self, value: u64) -> Result<Unstructured<T>, E> {
245 Ok(Unstructured::<T>::Number(Number::U64(value)))
246 }
247
248 fn visit_u128<E>(self, value: u128) -> Result<Unstructured<T>, E> {
249 Ok(Unstructured::<T>::Number(Number::U128(value)))
250 }
251
252 fn visit_f32<E>(self, value: f32) -> Result<Unstructured<T>, E> {
253 Ok(Unstructured::<T>::Number(Number::F32(value)))
254 }
255
256 fn visit_f64<E>(self, value: f64) -> Result<Unstructured<T>, E> {
257 Ok(Unstructured::<T>::Number(Number::F64(value)))
258 }
259
260 fn visit_char<E>(self, value: char) -> Result<Unstructured<T>, E> {
261 Ok(Unstructured::<T>::Char(value))
262 }
263
264 fn visit_str<E>(self, value: &str) -> Result<Unstructured<T>, E> {
265 Ok(Unstructured::<T>::String(value.into()))
266 }
267
268 fn visit_string<E>(self, value: String) -> Result<Unstructured<T>, E> {
269 Ok(Unstructured::<T>::String(value))
270 }
271
272 fn visit_unit<E>(self) -> Result<Unstructured<T>, E> {
273 Ok(Unstructured::<T>::Null)
274 }
275
276 fn visit_none<E>(self) -> Result<Unstructured<T>, E> {
277 Ok(Unstructured::<T>::Option(None))
278 }
279
280 fn visit_some<D: de::Deserializer<'de>>(self, d: D) -> Result<Unstructured<T>, D::Error> {
281 d.deserialize_any(DocumentVisitor::<T>(PhantomData))
282 .map(|v| Unstructured::<T>::Option(Some(Box::new(v))))
283 }
284
285 fn visit_newtype_struct<D: de::Deserializer<'de>>(
286 self,
287 d: D,
288 ) -> Result<Unstructured<T>, D::Error> {
289 d.deserialize_any(DocumentVisitor::<T>(PhantomData))
290 .map(|v| Unstructured::<T>::Newtype(Box::new(v)))
291 }
292
293 fn visit_seq<V: de::SeqAccess<'de>>(self, mut visitor: V) -> Result<Unstructured<T>, V::Error> {
294 let mut documents = Vec::new();
295 while let Some(elem) = visitor.next_element()? {
296 documents.push(elem);
297 }
298 Ok(Unstructured::<T>::Seq(documents))
299 }
300
301 fn visit_map<V: de::MapAccess<'de>>(self, mut visitor: V) -> Result<Unstructured<T>, V::Error> {
302 let mut documents = Mapping::new();
303 while let Some((key, document)) = visitor.next_entry()? {
304 documents.insert(key, document);
305 }
306 Ok(Unstructured::<T>::Map(documents))
307 }
308
309 fn visit_bytes<E>(self, v: &[u8]) -> Result<Unstructured<T>, E> {
310 Ok(Unstructured::<T>::Bytes(v.into()))
311 }
312
313 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Unstructured<T>, E> {
314 Ok(Unstructured::<T>::Bytes(v))
315 }
316}
317
318impl<'de, T: UnstructuredDataTrait> de::Deserialize<'de> for Unstructured<T> {
319 fn deserialize<D: de::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
320 d.deserialize_any(DocumentVisitor::<T>(PhantomData))
321 }
322}
323
324impl<'de, T: UnstructuredDataTrait> de::IntoDeserializer<'de, DeserializerError>
325 for Unstructured<T>
326{
327 type Deserializer = Unstructured<T>;
328
329 fn into_deserializer(self) -> Unstructured<T> {
330 self
331 }
332}
333
334pub struct DocumentDeserializer<E, T: UnstructuredDataTrait> {
335 document: Unstructured<T>,
336 error: PhantomData<fn() -> E>,
337}
338
339impl<E, T: UnstructuredDataTrait> DocumentDeserializer<E, T> {
340 pub fn new(document: Unstructured<T>) -> Self {
341 DocumentDeserializer {
342 document,
343 error: Default::default(),
344 }
345 }
346}
347
348impl<'de, E, T: UnstructuredDataTrait> de::Deserializer<'de> for DocumentDeserializer<E, T>
349where
350 E: de::Error,
351{
352 type Error = E;
353
354 fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
355 match self.document {
356 Unstructured::<T>::Bool(v) => visitor.visit_bool(v),
357 Unstructured::<T>::Number(v) => Ok(v.deserialize_any(visitor).unwrap()),
358 Unstructured::<T>::Char(v) => visitor.visit_char(v),
359 Unstructured::<T>::String(v) => visitor.visit_string(v),
360 Unstructured::<T>::Null => visitor.visit_unit(),
361 Unstructured::<T>::Option(None) => visitor.visit_none(),
362 Unstructured::<T>::Option(Some(v)) => visitor.visit_some(DocumentDeserializer::new(*v)),
363 Unstructured::<T>::Newtype(v) => {
364 visitor.visit_newtype_struct(DocumentDeserializer::new(*v))
365 }
366 Unstructured::<T>::Seq(v) => visitor.visit_seq(de::value::SeqDeserializer::new(
367 v.into_iter().map(DocumentDeserializer::new),
368 )),
369 Unstructured::<T>::Map(v) => visitor
370 .visit_map(de::value::MapDeserializer::new(v.into_iter().map(
371 |(k, v)| (DocumentDeserializer::new(k), DocumentDeserializer::new(v)),
372 ))),
373 Unstructured::<T>::Bytes(v) => visitor.visit_byte_buf(v),
374 Unstructured::<T>::Unassigned => visitor.visit_unit(),
375 Unstructured::<T>::Err(e) => {
376 Err(DeserializerError::Custom(format!("{}", e)).to_error())
377 }
378 Unstructured::<T>::Other(..) => {
379 Err(DeserializerError::Custom("other".into()).to_error())
380 }
381 }
382 }
383
384 fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
385 match self.document {
386 Unstructured::<T>::Option(..) => self.deserialize_any(visitor),
387 Unstructured::<T>::Null => visitor.visit_unit(),
388 _ => visitor.visit_some(self),
389 }
390 }
391
392 fn deserialize_enum<V: de::Visitor<'de>>(
393 self,
394 _name: &'static str,
395 _variants: &'static [&'static str],
396 visitor: V,
397 ) -> Result<V::Value, Self::Error> {
398 let (variant, document) = match self.document {
399 Unstructured::<T>::Map(document) => {
400 let mut iter = document.into_iter();
401 let (variant, document) = match iter.next() {
402 Some(v) => v,
403 None => {
404 return Err(de::Error::invalid_value(
405 de::Unexpected::Map,
406 &"map with a single key",
407 ));
408 }
409 };
410 if iter.next().is_some() {
412 return Err(de::Error::invalid_value(
413 de::Unexpected::Map,
414 &"map with a single key",
415 ));
416 }
417 (variant, Some(document))
418 }
419 Unstructured::<T>::String(variant) => (Unstructured::<T>::String(variant), None),
420 other => {
421 return Err(de::Error::invalid_type(
422 other.unexpected(),
423 &"string or map",
424 ));
425 }
426 };
427
428 let d = EnumDeserializer {
429 variant,
430 document,
431 error: Default::default(),
432 };
433 visitor.visit_enum(d)
434 }
435
436 fn deserialize_newtype_struct<V: de::Visitor<'de>>(
437 self,
438 _name: &'static str,
439 visitor: V,
440 ) -> Result<V::Value, Self::Error> {
441 match self.document {
442 Unstructured::<T>::Newtype(v) => {
443 visitor.visit_newtype_struct(DocumentDeserializer::new(*v))
444 }
445 _ => visitor.visit_newtype_struct(self),
446 }
447 }
448
449 forward_to_deserialize_any! {
450 bool u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 char str string unit
451 seq bytes byte_buf map unit_struct
452 tuple_struct struct tuple ignored_any identifier
453 }
454}
455
456impl<'de, E, T: UnstructuredDataTrait> de::IntoDeserializer<'de, E> for DocumentDeserializer<E, T>
457where
458 E: de::Error,
459{
460 type Deserializer = Self;
461
462 fn into_deserializer(self) -> Self::Deserializer {
463 self
464 }
465}
466
467impl<'de, T: UnstructuredDataTrait> de::Deserializer<'de> for Unstructured<T> {
468 type Error = DeserializerError;
469
470 fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
471 DocumentDeserializer::new(self).deserialize_any(visitor)
472 }
473
474 fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
475 DocumentDeserializer::new(self).deserialize_option(visitor)
476 }
477
478 fn deserialize_enum<V: de::Visitor<'de>>(
479 self,
480 name: &'static str,
481 variants: &'static [&'static str],
482 visitor: V,
483 ) -> Result<V::Value, Self::Error> {
484 DocumentDeserializer::new(self).deserialize_enum(name, variants, visitor)
485 }
486
487 fn deserialize_newtype_struct<V: de::Visitor<'de>>(
488 self,
489 name: &'static str,
490 visitor: V,
491 ) -> Result<V::Value, Self::Error> {
492 DocumentDeserializer::new(self).deserialize_newtype_struct(name, visitor)
493 }
494
495 forward_to_deserialize_any! {
496 bool u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 char str string unit
497 seq bytes byte_buf map unit_struct
498 tuple_struct struct tuple ignored_any identifier
499 }
500}
501
502struct EnumDeserializer<E, T: UnstructuredDataTrait> {
503 variant: Unstructured<T>,
504 document: Option<Unstructured<T>>,
505 error: PhantomData<fn() -> E>,
506}
507
508#[allow(clippy::type_complexity)]
509impl<'de, E, T: UnstructuredDataTrait> de::EnumAccess<'de> for EnumDeserializer<E, T>
510where
511 E: de::Error,
512{
513 type Error = E;
514 type Variant = VariantDeserializer<Self::Error, T>;
515
516 fn variant_seed<V>(
517 self,
518 seed: V,
519 ) -> Result<(V::Value, VariantDeserializer<Self::Error, T>), Self::Error>
520 where
521 V: de::DeserializeSeed<'de>,
522 {
523 let visitor = VariantDeserializer {
524 document: self.document,
525 error: Default::default(),
526 };
527 seed.deserialize(DocumentDeserializer::new(self.variant))
528 .map(|v| (v, visitor))
529 }
530}
531
532struct VariantDeserializer<E, T: UnstructuredDataTrait> {
533 document: Option<Unstructured<T>>,
534 error: PhantomData<fn() -> E>,
535}
536
537impl<'de, E, T: UnstructuredDataTrait> de::VariantAccess<'de> for VariantDeserializer<E, T>
538where
539 E: de::Error,
540{
541 type Error = E;
542
543 fn unit_variant(self) -> Result<(), Self::Error> {
544 match self.document {
545 Some(document) => de::Deserialize::deserialize(DocumentDeserializer::new(document)),
546 None => Ok(()),
547 }
548 }
549
550 fn newtype_variant_seed<Q>(self, seed: Q) -> Result<Q::Value, Self::Error>
551 where
552 Q: de::DeserializeSeed<'de>,
553 {
554 match self.document {
555 Some(document) => seed.deserialize(DocumentDeserializer::new(document)),
556 None => Err(de::Error::invalid_type(
557 de::Unexpected::UnitVariant,
558 &"newtype variant",
559 )),
560 }
561 }
562
563 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
564 where
565 V: de::Visitor<'de>,
566 {
567 match self.document {
568 Some(Unstructured::<T>::Seq(v)) => de::Deserializer::deserialize_any(
569 de::value::SeqDeserializer::new(v.into_iter().map(DocumentDeserializer::new)),
570 visitor,
571 ),
572 Some(other) => Err(de::Error::invalid_type(
573 other.unexpected(),
574 &"tuple variant",
575 )),
576 None => Err(de::Error::invalid_type(
577 de::Unexpected::UnitVariant,
578 &"tuple variant",
579 )),
580 }
581 }
582
583 fn struct_variant<V>(
584 self,
585 _fields: &'static [&'static str],
586 visitor: V,
587 ) -> Result<V::Value, Self::Error>
588 where
589 V: de::Visitor<'de>,
590 {
591 match self.document {
592 Some(Unstructured::<T>::Map(v)) => de::Deserializer::deserialize_any(
593 de::value::MapDeserializer::new(
594 v.into_iter()
595 .map(|(k, v)| (DocumentDeserializer::new(k), DocumentDeserializer::new(v))),
596 ),
597 visitor,
598 ),
599 Some(other) => Err(de::Error::invalid_type(
600 other.unexpected(),
601 &"struct variant",
602 )),
603 None => Err(de::Error::invalid_type(
604 de::Unexpected::UnitVariant,
605 &"struct variant",
606 )),
607 }
608 }
609}