1#[derive(Debug, Clone, Eq, PartialEq)]
2pub struct Schema {
3 pub target_namespace: Option<String>,
4 pub version: Option<String>,
5 pub final_default: FullDerivationSetType,
6 pub block_default: BlockSetType,
7 pub attribute_form_default: FormChoiceType,
8 pub element_form_default: FormChoiceType,
9 pub default_attributes: Option<QName>,
10 pub xpath_default_namespace: XpathDefaultNamespaceType,
11 pub id: Option<String>,
12 pub lang: Option<String>,
13 pub content: Vec<SchemaContent>,
14}
15#[derive(Debug, Clone, Eq, PartialEq)]
16pub enum SchemaContent {
17 Include(Include),
18 Import(Import),
19 Redefine(Redefine),
20 Override(Override),
21 Annotation(Annotation),
22 DefaultOpenContent(DefaultOpenContent),
23 SimpleType(SimpleBaseType),
24 ComplexType(ComplexBaseType),
25 Group(GroupType),
26 AttributeGroup(AttributeGroupType),
27 Element(ElementType),
28 Attribute(AttributeType),
29 Notation(Notation),
30}
31impl crate::WithNamespace for Schema {
32 fn prefix() -> Option<&'static str> {
33 Some("xs")
34 }
35 fn namespace() -> Option<&'static str> {
36 Some("http://www.w3.org/2001/XMLSchema")
37 }
38}
39impl Schema {
40 #[must_use]
41 pub fn default_final_default() -> FullDerivationSetType {
42 FullDerivationSetType::TypeDerivationControlList(TypeDerivationControlList(Vec::new()))
43 }
44 #[must_use]
45 pub fn default_block_default() -> BlockSetType {
46 BlockSetType::BlockSetItemList(BlockSetItemList(Vec::new()))
47 }
48 #[must_use]
49 pub fn default_attribute_form_default() -> FormChoiceType {
50 FormChoiceType::Unqualified
51 }
52 #[must_use]
53 pub fn default_element_form_default() -> FormChoiceType {
54 FormChoiceType::Unqualified
55 }
56 #[must_use]
57 pub fn default_xpath_default_namespace() -> XpathDefaultNamespaceType {
58 XpathDefaultNamespaceType::String(String::from("##local"))
59 }
60}
61impl crate::quick_xml::WithDeserializer for Schema {
62 type Deserializer = quick_xml_deserialize::SchemaDeserializer;
63}
64#[derive(Debug, Clone, Eq, PartialEq)]
65pub struct Include {
66 pub id: Option<String>,
67 pub schema_location: String,
68 pub annotation: Option<Annotation>,
69}
70impl crate::WithNamespace for Include {
71 fn prefix() -> Option<&'static str> {
72 Some("xs")
73 }
74 fn namespace() -> Option<&'static str> {
75 Some("http://www.w3.org/2001/XMLSchema")
76 }
77}
78impl crate::quick_xml::WithDeserializer for Include {
79 type Deserializer = quick_xml_deserialize::IncludeDeserializer;
80}
81#[derive(Debug, Clone, Eq, PartialEq)]
82pub struct Import {
83 pub id: Option<String>,
84 pub namespace: Option<String>,
85 pub schema_location: Option<String>,
86 pub annotation: Option<Annotation>,
87}
88impl crate::WithNamespace for Import {
89 fn prefix() -> Option<&'static str> {
90 Some("xs")
91 }
92 fn namespace() -> Option<&'static str> {
93 Some("http://www.w3.org/2001/XMLSchema")
94 }
95}
96impl crate::quick_xml::WithDeserializer for Import {
97 type Deserializer = quick_xml_deserialize::ImportDeserializer;
98}
99#[derive(Debug, Clone, Eq, PartialEq)]
100pub struct Redefine {
101 pub schema_location: String,
102 pub id: Option<String>,
103 pub content: Vec<RedefineContent>,
104}
105#[derive(Debug, Clone, Eq, PartialEq)]
106pub enum RedefineContent {
107 Annotation(Annotation),
108 SimpleType(SimpleBaseType),
109 ComplexType(ComplexBaseType),
110 Group(GroupType),
111 AttributeGroup(AttributeGroupType),
112}
113impl crate::WithNamespace for Redefine {
114 fn prefix() -> Option<&'static str> {
115 Some("xs")
116 }
117 fn namespace() -> Option<&'static str> {
118 Some("http://www.w3.org/2001/XMLSchema")
119 }
120}
121impl crate::quick_xml::WithDeserializer for Redefine {
122 type Deserializer = quick_xml_deserialize::RedefineDeserializer;
123}
124#[derive(Debug, Clone, Eq, PartialEq)]
125pub struct Override {
126 pub schema_location: String,
127 pub id: Option<String>,
128 pub content: Vec<OverrideContent>,
129}
130#[derive(Debug, Clone, Eq, PartialEq)]
131pub enum OverrideContent {
132 Annotation(Annotation),
133 SimpleType(SimpleBaseType),
134 ComplexType(ComplexBaseType),
135 Group(GroupType),
136 AttributeGroup(AttributeGroupType),
137 Element(ElementType),
138 Attribute(AttributeType),
139 Notation(Notation),
140}
141impl crate::WithNamespace for Override {
142 fn prefix() -> Option<&'static str> {
143 Some("xs")
144 }
145 fn namespace() -> Option<&'static str> {
146 Some("http://www.w3.org/2001/XMLSchema")
147 }
148}
149impl crate::quick_xml::WithDeserializer for Override {
150 type Deserializer = quick_xml_deserialize::OverrideDeserializer;
151}
152#[derive(Debug, Clone, Eq, PartialEq)]
153pub struct Annotation {
154 pub id: Option<String>,
155 pub content: Vec<AnnotationContent>,
156}
157#[derive(Debug, Clone, Eq, PartialEq)]
158pub enum AnnotationContent {
159 Appinfo(Appinfo),
160 Documentation(Documentation),
161}
162impl crate::WithNamespace for Annotation {
163 fn prefix() -> Option<&'static str> {
164 Some("xs")
165 }
166 fn namespace() -> Option<&'static str> {
167 Some("http://www.w3.org/2001/XMLSchema")
168 }
169}
170impl crate::quick_xml::WithDeserializer for Annotation {
171 type Deserializer = quick_xml_deserialize::AnnotationDeserializer;
172}
173#[derive(Debug, Clone, Eq, PartialEq)]
174pub struct DefaultOpenContent {
175 pub id: Option<String>,
176 pub applies_to_empty: bool,
177 pub mode: DefaultOpenContentModeType,
178 pub annotation: Option<Annotation>,
179 pub any: WildcardType,
180}
181impl crate::WithNamespace for DefaultOpenContent {
182 fn prefix() -> Option<&'static str> {
183 Some("xs")
184 }
185 fn namespace() -> Option<&'static str> {
186 Some("http://www.w3.org/2001/XMLSchema")
187 }
188}
189impl DefaultOpenContent {
190 #[must_use]
191 pub fn default_applies_to_empty() -> bool {
192 false
193 }
194 #[must_use]
195 pub fn default_mode() -> DefaultOpenContentModeType {
196 DefaultOpenContentModeType::Interleave
197 }
198}
199impl crate::quick_xml::WithDeserializer for DefaultOpenContent {
200 type Deserializer = quick_xml_deserialize::DefaultOpenContentDeserializer;
201}
202#[derive(Debug, Clone, Eq, PartialEq)]
203pub struct SimpleBaseType {
204 pub id: Option<String>,
205 pub final_: Option<SimpleDerivationSetType>,
206 pub name: Option<String>,
207 pub content: Vec<SimpleBaseTypeContent>,
208}
209#[derive(Debug, Clone, Eq, PartialEq)]
210pub enum SimpleBaseTypeContent {
211 Annotation(Annotation),
212 Restriction(Restriction),
213 List(List),
214 Union(Union),
215}
216impl crate::WithNamespace for SimpleBaseType {
217 fn prefix() -> Option<&'static str> {
218 Some("xs")
219 }
220 fn namespace() -> Option<&'static str> {
221 Some("http://www.w3.org/2001/XMLSchema")
222 }
223}
224impl crate::quick_xml::WithDeserializer for SimpleBaseType {
225 type Deserializer = quick_xml_deserialize::SimpleBaseTypeDeserializer;
226}
227#[derive(Debug, Clone, Eq, PartialEq)]
228pub struct ComplexBaseType {
229 pub id: Option<String>,
230 pub name: Option<String>,
231 pub mixed: Option<bool>,
232 pub abstract_: bool,
233 pub final_: Option<DerivationSetType>,
234 pub block: Option<DerivationSetType>,
235 pub default_attributes_apply: bool,
236 pub content: Vec<ComplexBaseTypeContent>,
237}
238#[derive(Debug, Clone, Eq, PartialEq)]
239pub enum ComplexBaseTypeContent {
240 Annotation(Annotation),
241 SimpleContent(SimpleContent),
242 ComplexContent(ComplexContent),
243 OpenContent(OpenContent),
244 Group(GroupType),
245 All(GroupType),
246 Choice(GroupType),
247 Sequence(GroupType),
248 Attribute(AttributeType),
249 AttributeGroup(AttributeGroupType),
250 AnyAttribute(AnyAttribute),
251 Assert(AssertionType),
252}
253impl crate::WithNamespace for ComplexBaseType {
254 fn prefix() -> Option<&'static str> {
255 Some("xs")
256 }
257 fn namespace() -> Option<&'static str> {
258 Some("http://www.w3.org/2001/XMLSchema")
259 }
260}
261impl ComplexBaseType {
262 #[must_use]
263 pub fn default_abstract_() -> bool {
264 false
265 }
266 #[must_use]
267 pub fn default_default_attributes_apply() -> bool {
268 true
269 }
270}
271impl crate::quick_xml::WithDeserializer for ComplexBaseType {
272 type Deserializer = quick_xml_deserialize::ComplexBaseTypeDeserializer;
273}
274#[derive(Debug, Clone, Eq, PartialEq)]
275pub struct GroupType {
276 pub id: Option<String>,
277 pub name: Option<String>,
278 pub ref_: Option<QName>,
279 pub min_occurs: usize,
280 pub max_occurs: MaxOccurs,
281 pub content: Vec<GroupTypeContent>,
282}
283#[derive(Debug, Clone, Eq, PartialEq)]
284pub enum GroupTypeContent {
285 Annotation(Annotation),
286 Element(ElementType),
287 Group(GroupType),
288 All(GroupType),
289 Choice(GroupType),
290 Sequence(GroupType),
291 Any(Any),
292}
293impl crate::WithNamespace for GroupType {
294 fn prefix() -> Option<&'static str> {
295 Some("xs")
296 }
297 fn namespace() -> Option<&'static str> {
298 Some("http://www.w3.org/2001/XMLSchema")
299 }
300}
301impl GroupType {
302 #[must_use]
303 pub fn default_min_occurs() -> usize {
304 1usize
305 }
306 #[must_use]
307 pub fn default_max_occurs() -> MaxOccurs {
308 MaxOccurs::Bounded(1usize)
309 }
310}
311impl crate::quick_xml::WithDeserializer for GroupType {
312 type Deserializer = quick_xml_deserialize::GroupTypeDeserializer;
313}
314#[derive(Debug, Clone, Eq, PartialEq)]
315pub struct AttributeGroupType {
316 pub id: Option<String>,
317 pub name: Option<String>,
318 pub ref_: Option<QName>,
319 pub content: Vec<AttributeGroupTypeContent>,
320}
321#[derive(Debug, Clone, Eq, PartialEq)]
322pub enum AttributeGroupTypeContent {
323 Annotation(Annotation),
324 Attribute(AttributeType),
325 AttributeGroup(AttributeGroupType),
326 AnyAttribute(AnyAttribute),
327}
328impl crate::WithNamespace for AttributeGroupType {
329 fn prefix() -> Option<&'static str> {
330 Some("xs")
331 }
332 fn namespace() -> Option<&'static str> {
333 Some("http://www.w3.org/2001/XMLSchema")
334 }
335}
336impl crate::quick_xml::WithDeserializer for AttributeGroupType {
337 type Deserializer = quick_xml_deserialize::AttributeGroupTypeDeserializer;
338}
339#[derive(Debug, Clone, Eq, PartialEq)]
340pub struct ElementType {
341 pub id: Option<String>,
342 pub name: Option<String>,
343 pub ref_: Option<QName>,
344 pub type_: Option<QName>,
345 pub substitution_group: Option<ElementSubstitutionGroupType>,
346 pub min_occurs: usize,
347 pub max_occurs: MaxOccurs,
348 pub default: Option<String>,
349 pub fixed: Option<String>,
350 pub nillable: Option<bool>,
351 pub abstract_: bool,
352 pub final_: Option<DerivationSetType>,
353 pub block: Option<BlockSetType>,
354 pub form: Option<FormChoiceType>,
355 pub target_namespace: Option<String>,
356 pub content: Vec<ElementTypeContent>,
357}
358#[derive(Debug, Clone, Eq, PartialEq)]
359pub enum ElementTypeContent {
360 Annotation(Annotation),
361 SimpleType(SimpleBaseType),
362 ComplexType(ComplexBaseType),
363 Alternative(AltType),
364 Unique(KeybaseType),
365 Key(KeybaseType),
366 Keyref(Keyref),
367}
368impl crate::WithNamespace for ElementType {
369 fn prefix() -> Option<&'static str> {
370 Some("xs")
371 }
372 fn namespace() -> Option<&'static str> {
373 Some("http://www.w3.org/2001/XMLSchema")
374 }
375}
376impl ElementType {
377 #[must_use]
378 pub fn default_min_occurs() -> usize {
379 1usize
380 }
381 #[must_use]
382 pub fn default_max_occurs() -> MaxOccurs {
383 MaxOccurs::Bounded(1usize)
384 }
385 #[must_use]
386 pub fn default_abstract_() -> bool {
387 false
388 }
389}
390impl crate::quick_xml::WithDeserializer for ElementType {
391 type Deserializer = quick_xml_deserialize::ElementTypeDeserializer;
392}
393#[derive(Debug, Clone, Eq, PartialEq)]
394pub struct AttributeType {
395 pub id: Option<String>,
396 pub name: Option<String>,
397 pub ref_: Option<QName>,
398 pub type_: Option<QName>,
399 pub use_: AttributeUseType,
400 pub default: Option<String>,
401 pub fixed: Option<String>,
402 pub form: Option<FormChoiceType>,
403 pub target_namespace: Option<String>,
404 pub inheritable: Option<bool>,
405 pub annotation: Option<Annotation>,
406 pub simple_type: Option<SimpleBaseType>,
407}
408impl crate::WithNamespace for AttributeType {
409 fn prefix() -> Option<&'static str> {
410 Some("xs")
411 }
412 fn namespace() -> Option<&'static str> {
413 Some("http://www.w3.org/2001/XMLSchema")
414 }
415}
416impl AttributeType {
417 #[must_use]
418 pub fn default_use_() -> AttributeUseType {
419 AttributeUseType::Optional
420 }
421}
422impl crate::quick_xml::WithDeserializer for AttributeType {
423 type Deserializer = quick_xml_deserialize::AttributeTypeDeserializer;
424}
425#[derive(Debug, Clone, Eq, PartialEq)]
426pub struct Notation {
427 pub id: Option<String>,
428 pub name: String,
429 pub public: Option<String>,
430 pub system: Option<String>,
431 pub annotation: Option<Annotation>,
432}
433impl crate::WithNamespace for Notation {
434 fn prefix() -> Option<&'static str> {
435 Some("xs")
436 }
437 fn namespace() -> Option<&'static str> {
438 Some("http://www.w3.org/2001/XMLSchema")
439 }
440}
441impl crate::quick_xml::WithDeserializer for Notation {
442 type Deserializer = quick_xml_deserialize::NotationDeserializer;
443}
444#[derive(Debug, Clone, Eq, PartialEq)]
445pub enum FullDerivationSetType {
446 All,
447 TypeDerivationControlList(TypeDerivationControlList),
448}
449impl crate::WithNamespace for FullDerivationSetType {
450 fn prefix() -> Option<&'static str> {
451 Some("xs")
452 }
453 fn namespace() -> Option<&'static str> {
454 Some("http://www.w3.org/2001/XMLSchema")
455 }
456}
457impl crate::quick_xml::DeserializeBytes for FullDerivationSetType {
458 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
459 where
460 R: crate::quick_xml::XmlReader,
461 {
462 match bytes {
463 b"#all" => Ok(Self::All),
464 x => Ok(Self::TypeDerivationControlList(
465 TypeDerivationControlList::deserialize_bytes(reader, x)?,
466 )),
467 }
468 }
469}
470#[derive(Debug, Clone, Eq, PartialEq, Default)]
471pub struct TypeDerivationControlList(pub Vec<TypeDerivationControlType>);
472impl crate::WithNamespace for TypeDerivationControlList {
473 fn prefix() -> Option<&'static str> {
474 Some("xs")
475 }
476 fn namespace() -> Option<&'static str> {
477 Some("http://www.w3.org/2001/XMLSchema")
478 }
479}
480impl crate::quick_xml::DeserializeBytes for TypeDerivationControlList {
481 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
482 where
483 R: crate::quick_xml::XmlReader,
484 {
485 Ok(Self(
486 bytes
487 .split(|b| *b == b' ' || *b == b'|' || *b == b',' || *b == b';')
488 .map(|bytes| TypeDerivationControlType::deserialize_bytes(reader, bytes))
489 .collect::<Result<Vec<_>, _>>()?,
490 ))
491 }
492}
493#[derive(Debug, Clone, Eq, PartialEq)]
494pub enum BlockSetType {
495 All,
496 BlockSetItemList(BlockSetItemList),
497}
498impl crate::WithNamespace for BlockSetType {
499 fn prefix() -> Option<&'static str> {
500 Some("xs")
501 }
502 fn namespace() -> Option<&'static str> {
503 Some("http://www.w3.org/2001/XMLSchema")
504 }
505}
506impl crate::quick_xml::DeserializeBytes for BlockSetType {
507 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
508 where
509 R: crate::quick_xml::XmlReader,
510 {
511 match bytes {
512 b"#all" => Ok(Self::All),
513 x => Ok(Self::BlockSetItemList(BlockSetItemList::deserialize_bytes(
514 reader, x,
515 )?)),
516 }
517 }
518}
519#[derive(Debug, Clone, Eq, PartialEq, Default)]
520pub struct BlockSetItemList(pub Vec<BlockSetItemType>);
521impl crate::WithNamespace for BlockSetItemList {
522 fn prefix() -> Option<&'static str> {
523 Some("xs")
524 }
525 fn namespace() -> Option<&'static str> {
526 Some("http://www.w3.org/2001/XMLSchema")
527 }
528}
529impl crate::quick_xml::DeserializeBytes for BlockSetItemList {
530 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
531 where
532 R: crate::quick_xml::XmlReader,
533 {
534 Ok(Self(
535 bytes
536 .split(|b| *b == b' ' || *b == b'|' || *b == b',' || *b == b';')
537 .map(|bytes| BlockSetItemType::deserialize_bytes(reader, bytes))
538 .collect::<Result<Vec<_>, _>>()?,
539 ))
540 }
541}
542#[derive(Debug, Clone, Eq, PartialEq)]
543pub enum FormChoiceType {
544 Qualified,
545 Unqualified,
546}
547impl crate::WithNamespace for FormChoiceType {
548 fn prefix() -> Option<&'static str> {
549 Some("xs")
550 }
551 fn namespace() -> Option<&'static str> {
552 Some("http://www.w3.org/2001/XMLSchema")
553 }
554}
555impl crate::quick_xml::DeserializeBytes for FormChoiceType {
556 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
557 where
558 R: crate::quick_xml::XmlReader,
559 {
560 match bytes {
561 b"qualified" => Ok(Self::Qualified),
562 b"unqualified" => Ok(Self::Unqualified),
563 x => {
564 use crate::quick_xml::{ErrorKind, RawByteStr};
565 Err(reader.map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
566 }
567 }
568 }
569}
570#[derive(Debug, Clone, Eq, PartialEq)]
571pub enum XpathDefaultNamespaceType {
572 String(String),
573 DefaultNamespace,
574 TargetNamespace,
575 Local,
576}
577impl crate::WithNamespace for XpathDefaultNamespaceType {
578 fn prefix() -> Option<&'static str> {
579 Some("xs")
580 }
581 fn namespace() -> Option<&'static str> {
582 Some("http://www.w3.org/2001/XMLSchema")
583 }
584}
585impl crate::quick_xml::DeserializeBytes for XpathDefaultNamespaceType {
586 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
587 where
588 R: crate::quick_xml::XmlReader,
589 {
590 match bytes {
591 b"##defaultNamespace" => Ok(Self::DefaultNamespace),
592 b"##targetNamespace" => Ok(Self::TargetNamespace),
593 b"##local" => Ok(Self::Local),
594 x => Ok(Self::String(String::deserialize_bytes(reader, x)?)),
595 }
596 }
597}
598#[derive(Debug, Clone, Eq, PartialEq)]
599pub struct Appinfo {
600 pub source: Option<String>,
601}
602impl crate::WithNamespace for Appinfo {
603 fn prefix() -> Option<&'static str> {
604 Some("xs")
605 }
606 fn namespace() -> Option<&'static str> {
607 Some("http://www.w3.org/2001/XMLSchema")
608 }
609}
610impl crate::quick_xml::WithDeserializer for Appinfo {
611 type Deserializer = quick_xml_deserialize::AppinfoDeserializer;
612}
613#[derive(Debug, Clone, Eq, PartialEq)]
614pub struct Documentation {
615 pub source: Option<String>,
616 pub lang: Option<String>,
617}
618impl crate::WithNamespace for Documentation {
619 fn prefix() -> Option<&'static str> {
620 Some("xs")
621 }
622 fn namespace() -> Option<&'static str> {
623 Some("http://www.w3.org/2001/XMLSchema")
624 }
625}
626impl crate::quick_xml::WithDeserializer for Documentation {
627 type Deserializer = quick_xml_deserialize::DocumentationDeserializer;
628}
629#[derive(Debug, Clone, Eq, PartialEq)]
630pub struct WildcardType {
631 pub id: Option<String>,
632 pub namespace: Option<NamespaceListType>,
633 pub not_namespace: Option<NotNamespaceType>,
634 pub process_contents: ProcessContentsType,
635 pub annotation: Option<Annotation>,
636}
637impl crate::WithNamespace for WildcardType {
638 fn prefix() -> Option<&'static str> {
639 Some("xs")
640 }
641 fn namespace() -> Option<&'static str> {
642 Some("http://www.w3.org/2001/XMLSchema")
643 }
644}
645impl WildcardType {
646 #[must_use]
647 pub fn default_process_contents() -> ProcessContentsType {
648 ProcessContentsType::Strict
649 }
650}
651impl crate::quick_xml::WithDeserializer for WildcardType {
652 type Deserializer = quick_xml_deserialize::WildcardTypeDeserializer;
653}
654#[derive(Debug, Clone, Eq, PartialEq)]
655pub enum DefaultOpenContentModeType {
656 Interleave,
657 Suffix,
658}
659impl crate::WithNamespace for DefaultOpenContentModeType {
660 fn prefix() -> Option<&'static str> {
661 Some("xs")
662 }
663 fn namespace() -> Option<&'static str> {
664 Some("http://www.w3.org/2001/XMLSchema")
665 }
666}
667impl crate::quick_xml::DeserializeBytes for DefaultOpenContentModeType {
668 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
669 where
670 R: crate::quick_xml::XmlReader,
671 {
672 match bytes {
673 b"interleave" => Ok(Self::Interleave),
674 b"suffix" => Ok(Self::Suffix),
675 x => {
676 use crate::quick_xml::{ErrorKind, RawByteStr};
677 Err(reader.map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
678 }
679 }
680 }
681}
682#[derive(Debug, Clone, Eq, PartialEq)]
683pub struct Restriction {
684 pub id: Option<String>,
685 pub base: Option<QName>,
686 pub content: Vec<RestrictionContent>,
687}
688#[derive(Debug, Clone, Eq, PartialEq)]
689pub enum RestrictionContent {
690 Annotation(Annotation),
691 SimpleType(SimpleBaseType),
692 Facet(Facet),
693}
694impl crate::WithNamespace for Restriction {
695 fn prefix() -> Option<&'static str> {
696 Some("xs")
697 }
698 fn namespace() -> Option<&'static str> {
699 Some("http://www.w3.org/2001/XMLSchema")
700 }
701}
702impl crate::quick_xml::WithDeserializer for Restriction {
703 type Deserializer = quick_xml_deserialize::RestrictionDeserializer;
704}
705#[derive(Debug, Clone, Eq, PartialEq)]
706pub struct List {
707 pub id: Option<String>,
708 pub item_type: Option<QName>,
709 pub annotation: Option<Annotation>,
710 pub simple_type: Option<SimpleBaseType>,
711}
712impl crate::WithNamespace for List {
713 fn prefix() -> Option<&'static str> {
714 Some("xs")
715 }
716 fn namespace() -> Option<&'static str> {
717 Some("http://www.w3.org/2001/XMLSchema")
718 }
719}
720impl crate::quick_xml::WithDeserializer for List {
721 type Deserializer = quick_xml_deserialize::ListDeserializer;
722}
723#[derive(Debug, Clone, Eq, PartialEq)]
724pub struct Union {
725 pub id: Option<String>,
726 pub member_types: Option<UnionMemberTypesType>,
727 pub annotation: Option<Annotation>,
728 pub simple_type: Vec<SimpleBaseType>,
729}
730impl crate::WithNamespace for Union {
731 fn prefix() -> Option<&'static str> {
732 Some("xs")
733 }
734 fn namespace() -> Option<&'static str> {
735 Some("http://www.w3.org/2001/XMLSchema")
736 }
737}
738impl crate::quick_xml::WithDeserializer for Union {
739 type Deserializer = quick_xml_deserialize::UnionDeserializer;
740}
741#[derive(Debug, Clone, Eq, PartialEq)]
742pub enum SimpleDerivationSetType {
743 All,
744 SimpleDerivationSetItemList(SimpleDerivationSetItemList),
745}
746impl crate::WithNamespace for SimpleDerivationSetType {
747 fn prefix() -> Option<&'static str> {
748 Some("xs")
749 }
750 fn namespace() -> Option<&'static str> {
751 Some("http://www.w3.org/2001/XMLSchema")
752 }
753}
754impl crate::quick_xml::DeserializeBytes for SimpleDerivationSetType {
755 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
756 where
757 R: crate::quick_xml::XmlReader,
758 {
759 match bytes {
760 b"#all" => Ok(Self::All),
761 x => Ok(Self::SimpleDerivationSetItemList(
762 SimpleDerivationSetItemList::deserialize_bytes(reader, x)?,
763 )),
764 }
765 }
766}
767#[derive(Debug, Clone, Eq, PartialEq)]
768pub struct SimpleContent {
769 pub id: Option<String>,
770 pub content: Vec<SimpleContentContent>,
771}
772#[derive(Debug, Clone, Eq, PartialEq)]
773pub enum SimpleContentContent {
774 Annotation(Annotation),
775 Restriction(RestrictionType),
776 Extension(ExtensionType),
777}
778impl crate::WithNamespace for SimpleContent {
779 fn prefix() -> Option<&'static str> {
780 Some("xs")
781 }
782 fn namespace() -> Option<&'static str> {
783 Some("http://www.w3.org/2001/XMLSchema")
784 }
785}
786impl crate::quick_xml::WithDeserializer for SimpleContent {
787 type Deserializer = quick_xml_deserialize::SimpleContentDeserializer;
788}
789#[derive(Debug, Clone, Eq, PartialEq)]
790pub struct ComplexContent {
791 pub id: Option<String>,
792 pub mixed: Option<bool>,
793 pub content: Vec<ComplexContentContent>,
794}
795#[derive(Debug, Clone, Eq, PartialEq)]
796pub enum ComplexContentContent {
797 Annotation(Annotation),
798 Restriction(RestrictionType),
799 Extension(ExtensionType),
800}
801impl crate::WithNamespace for ComplexContent {
802 fn prefix() -> Option<&'static str> {
803 Some("xs")
804 }
805 fn namespace() -> Option<&'static str> {
806 Some("http://www.w3.org/2001/XMLSchema")
807 }
808}
809impl crate::quick_xml::WithDeserializer for ComplexContent {
810 type Deserializer = quick_xml_deserialize::ComplexContentDeserializer;
811}
812#[derive(Debug, Clone, Eq, PartialEq)]
813pub struct OpenContent {
814 pub id: Option<String>,
815 pub mode: OpenContentModeType,
816 pub annotation: Option<Annotation>,
817 pub any: Option<WildcardType>,
818}
819impl crate::WithNamespace for OpenContent {
820 fn prefix() -> Option<&'static str> {
821 Some("xs")
822 }
823 fn namespace() -> Option<&'static str> {
824 Some("http://www.w3.org/2001/XMLSchema")
825 }
826}
827impl OpenContent {
828 #[must_use]
829 pub fn default_mode() -> OpenContentModeType {
830 OpenContentModeType::Interleave
831 }
832}
833impl crate::quick_xml::WithDeserializer for OpenContent {
834 type Deserializer = quick_xml_deserialize::OpenContentDeserializer;
835}
836#[derive(Debug, Clone, Eq, PartialEq)]
837pub struct AnyAttribute {
838 pub id: Option<String>,
839 pub namespace: Option<NamespaceListType>,
840 pub not_namespace: Option<NotNamespaceType>,
841 pub process_contents: ProcessContentsType,
842 pub not_q_name: Option<QnameListAType>,
843 pub annotation: Option<Annotation>,
844}
845impl crate::WithNamespace for AnyAttribute {
846 fn prefix() -> Option<&'static str> {
847 Some("xs")
848 }
849 fn namespace() -> Option<&'static str> {
850 Some("http://www.w3.org/2001/XMLSchema")
851 }
852}
853impl AnyAttribute {
854 #[must_use]
855 pub fn default_process_contents() -> ProcessContentsType {
856 ProcessContentsType::Strict
857 }
858}
859impl crate::quick_xml::WithDeserializer for AnyAttribute {
860 type Deserializer = quick_xml_deserialize::AnyAttributeDeserializer;
861}
862#[derive(Debug, Clone, Eq, PartialEq)]
863pub struct AssertionType {
864 pub id: Option<String>,
865 pub test: Option<String>,
866 pub xpath_default_namespace: Option<XpathDefaultNamespaceType>,
867 pub annotation: Option<Annotation>,
868}
869impl crate::WithNamespace for AssertionType {
870 fn prefix() -> Option<&'static str> {
871 Some("xs")
872 }
873 fn namespace() -> Option<&'static str> {
874 Some("http://www.w3.org/2001/XMLSchema")
875 }
876}
877impl crate::quick_xml::WithDeserializer for AssertionType {
878 type Deserializer = quick_xml_deserialize::AssertionTypeDeserializer;
879}
880#[derive(Debug, Clone, Eq, PartialEq)]
881pub enum DerivationSetType {
882 All,
883 ReducedDerivationControlList(ReducedDerivationControlList),
884}
885impl crate::WithNamespace for DerivationSetType {
886 fn prefix() -> Option<&'static str> {
887 Some("xs")
888 }
889 fn namespace() -> Option<&'static str> {
890 Some("http://www.w3.org/2001/XMLSchema")
891 }
892}
893impl crate::quick_xml::DeserializeBytes for DerivationSetType {
894 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
895 where
896 R: crate::quick_xml::XmlReader,
897 {
898 match bytes {
899 b"#all" => Ok(Self::All),
900 x => Ok(Self::ReducedDerivationControlList(
901 ReducedDerivationControlList::deserialize_bytes(reader, x)?,
902 )),
903 }
904 }
905}
906#[derive(Debug, Clone, Eq, PartialEq)]
907pub struct Any {
908 pub id: Option<String>,
909 pub namespace: Option<NamespaceListType>,
910 pub not_namespace: Option<NotNamespaceType>,
911 pub process_contents: ProcessContentsType,
912 pub not_q_name: Option<QnameListType>,
913 pub min_occurs: usize,
914 pub max_occurs: MaxOccurs,
915 pub annotation: Option<Annotation>,
916}
917impl crate::WithNamespace for Any {
918 fn prefix() -> Option<&'static str> {
919 Some("xs")
920 }
921 fn namespace() -> Option<&'static str> {
922 Some("http://www.w3.org/2001/XMLSchema")
923 }
924}
925impl Any {
926 #[must_use]
927 pub fn default_process_contents() -> ProcessContentsType {
928 ProcessContentsType::Strict
929 }
930 #[must_use]
931 pub fn default_min_occurs() -> usize {
932 1usize
933 }
934 #[must_use]
935 pub fn default_max_occurs() -> MaxOccurs {
936 MaxOccurs::Bounded(1usize)
937 }
938}
939impl crate::quick_xml::WithDeserializer for Any {
940 type Deserializer = quick_xml_deserialize::AnyDeserializer;
941}
942#[derive(Debug, Clone, Eq, PartialEq)]
943pub struct AltType {
944 pub id: Option<String>,
945 pub test: Option<String>,
946 pub type_: Option<QName>,
947 pub xpath_default_namespace: Option<XpathDefaultNamespaceType>,
948 pub content: Vec<AltTypeContent>,
949}
950#[derive(Debug, Clone, Eq, PartialEq)]
951pub enum AltTypeContent {
952 Annotation(Annotation),
953 SimpleType(SimpleBaseType),
954 ComplexType(ComplexBaseType),
955}
956impl crate::WithNamespace for AltType {
957 fn prefix() -> Option<&'static str> {
958 Some("xs")
959 }
960 fn namespace() -> Option<&'static str> {
961 Some("http://www.w3.org/2001/XMLSchema")
962 }
963}
964impl crate::quick_xml::WithDeserializer for AltType {
965 type Deserializer = quick_xml_deserialize::AltTypeDeserializer;
966}
967#[derive(Debug, Clone, Eq, PartialEq)]
968pub struct KeybaseType {
969 pub id: Option<String>,
970 pub name: Option<String>,
971 pub ref_: Option<QName>,
972 pub annotation: Option<Annotation>,
973 pub selector: Field,
974 pub field: Vec<Field>,
975}
976impl crate::WithNamespace for KeybaseType {
977 fn prefix() -> Option<&'static str> {
978 Some("xs")
979 }
980 fn namespace() -> Option<&'static str> {
981 Some("http://www.w3.org/2001/XMLSchema")
982 }
983}
984impl crate::quick_xml::WithDeserializer for KeybaseType {
985 type Deserializer = quick_xml_deserialize::KeybaseTypeDeserializer;
986}
987#[derive(Debug, Clone, Eq, PartialEq)]
988pub struct Keyref {
989 pub id: Option<String>,
990 pub name: Option<String>,
991 pub ref_: Option<QName>,
992 pub refer: Option<QName>,
993 pub annotation: Option<Annotation>,
994 pub selector: Field,
995 pub field: Vec<Field>,
996}
997impl crate::WithNamespace for Keyref {
998 fn prefix() -> Option<&'static str> {
999 Some("xs")
1000 }
1001 fn namespace() -> Option<&'static str> {
1002 Some("http://www.w3.org/2001/XMLSchema")
1003 }
1004}
1005impl crate::quick_xml::WithDeserializer for Keyref {
1006 type Deserializer = quick_xml_deserialize::KeyrefDeserializer;
1007}
1008#[derive(Debug, Clone, Eq, PartialEq, Default)]
1009pub struct ElementSubstitutionGroupType(pub Vec<QName>);
1010impl crate::WithNamespace for ElementSubstitutionGroupType {
1011 fn prefix() -> Option<&'static str> {
1012 Some("xs")
1013 }
1014 fn namespace() -> Option<&'static str> {
1015 Some("http://www.w3.org/2001/XMLSchema")
1016 }
1017}
1018impl crate::quick_xml::DeserializeBytes for ElementSubstitutionGroupType {
1019 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1020 where
1021 R: crate::quick_xml::XmlReader,
1022 {
1023 Ok(Self(
1024 bytes
1025 .split(|b| *b == b' ' || *b == b'|' || *b == b',' || *b == b';')
1026 .map(|bytes| QName::deserialize_bytes(reader, bytes))
1027 .collect::<Result<Vec<_>, _>>()?,
1028 ))
1029 }
1030}
1031#[derive(Debug, Clone, Eq, PartialEq)]
1032pub enum AttributeUseType {
1033 Prohibited,
1034 Optional,
1035 Required,
1036}
1037impl crate::WithNamespace for AttributeUseType {
1038 fn prefix() -> Option<&'static str> {
1039 Some("xs")
1040 }
1041 fn namespace() -> Option<&'static str> {
1042 Some("http://www.w3.org/2001/XMLSchema")
1043 }
1044}
1045impl crate::quick_xml::DeserializeBytes for AttributeUseType {
1046 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1047 where
1048 R: crate::quick_xml::XmlReader,
1049 {
1050 match bytes {
1051 b"prohibited" => Ok(Self::Prohibited),
1052 b"optional" => Ok(Self::Optional),
1053 b"required" => Ok(Self::Required),
1054 x => {
1055 use crate::quick_xml::{ErrorKind, RawByteStr};
1056 Err(reader.map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
1057 }
1058 }
1059 }
1060}
1061pub type TypeDerivationControlType = DerivationControlType;
1062pub type BlockSetItemType = DerivationControlType;
1063#[derive(Debug, Clone, Eq, PartialEq)]
1064pub enum NamespaceListType {
1065 Any,
1066 Other,
1067 BasicNamespaceList(BasicNamespaceListType),
1068}
1069impl crate::WithNamespace for NamespaceListType {
1070 fn prefix() -> Option<&'static str> {
1071 Some("xs")
1072 }
1073 fn namespace() -> Option<&'static str> {
1074 Some("http://www.w3.org/2001/XMLSchema")
1075 }
1076}
1077impl crate::quick_xml::DeserializeBytes for NamespaceListType {
1078 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1079 where
1080 R: crate::quick_xml::XmlReader,
1081 {
1082 match bytes {
1083 b"##any" => Ok(Self::Any),
1084 b"##other" => Ok(Self::Other),
1085 x => Ok(Self::BasicNamespaceList(
1086 BasicNamespaceListType::deserialize_bytes(reader, x)?,
1087 )),
1088 }
1089 }
1090}
1091#[derive(Debug, Clone, Eq, PartialEq, Default)]
1092pub struct NotNamespaceType(pub Vec<BasicNamespaceListItemType>);
1093impl crate::WithNamespace for NotNamespaceType {
1094 fn prefix() -> Option<&'static str> {
1095 Some("xs")
1096 }
1097 fn namespace() -> Option<&'static str> {
1098 Some("http://www.w3.org/2001/XMLSchema")
1099 }
1100}
1101impl crate::quick_xml::DeserializeBytes for NotNamespaceType {
1102 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1103 where
1104 R: crate::quick_xml::XmlReader,
1105 {
1106 Ok(Self(
1107 bytes
1108 .split(|b| *b == b' ' || *b == b'|' || *b == b',' || *b == b';')
1109 .map(|bytes| BasicNamespaceListItemType::deserialize_bytes(reader, bytes))
1110 .collect::<Result<Vec<_>, _>>()?,
1111 ))
1112 }
1113}
1114#[derive(Debug, Clone, Eq, PartialEq)]
1115pub enum ProcessContentsType {
1116 Skip,
1117 Lax,
1118 Strict,
1119}
1120impl crate::WithNamespace for ProcessContentsType {
1121 fn prefix() -> Option<&'static str> {
1122 Some("xs")
1123 }
1124 fn namespace() -> Option<&'static str> {
1125 Some("http://www.w3.org/2001/XMLSchema")
1126 }
1127}
1128impl crate::quick_xml::DeserializeBytes for ProcessContentsType {
1129 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1130 where
1131 R: crate::quick_xml::XmlReader,
1132 {
1133 match bytes {
1134 b"skip" => Ok(Self::Skip),
1135 b"lax" => Ok(Self::Lax),
1136 b"strict" => Ok(Self::Strict),
1137 x => {
1138 use crate::quick_xml::{ErrorKind, RawByteStr};
1139 Err(reader.map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
1140 }
1141 }
1142 }
1143}
1144#[derive(Debug, Clone, Eq, PartialEq)]
1145pub enum Facet {
1146 MinExclusive(FacetType),
1147 MinInclusive(FacetType),
1148 MaxExclusive(FacetType),
1149 MaxInclusive(FacetType),
1150 TotalDigits(FacetType),
1151 FractionDigits(FacetType),
1152 Length(FacetType),
1153 MinLength(FacetType),
1154 MaxLength(FacetType),
1155 Enumeration(FacetType),
1156 WhiteSpace(FacetType),
1157 Pattern(FacetType),
1158 Assertion(AssertionType),
1159 ExplicitTimezone(FacetType),
1160}
1161impl crate::WithNamespace for Facet {
1162 fn prefix() -> Option<&'static str> {
1163 Some("xs")
1164 }
1165 fn namespace() -> Option<&'static str> {
1166 Some("http://www.w3.org/2001/XMLSchema")
1167 }
1168}
1169impl crate::quick_xml::WithDeserializer for Facet {
1170 type Deserializer = quick_xml_deserialize::FacetDeserializer;
1171}
1172#[derive(Debug, Clone, Eq, PartialEq, Default)]
1173pub struct UnionMemberTypesType(pub Vec<QName>);
1174impl crate::WithNamespace for UnionMemberTypesType {
1175 fn prefix() -> Option<&'static str> {
1176 Some("xs")
1177 }
1178 fn namespace() -> Option<&'static str> {
1179 Some("http://www.w3.org/2001/XMLSchema")
1180 }
1181}
1182impl crate::quick_xml::DeserializeBytes for UnionMemberTypesType {
1183 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1184 where
1185 R: crate::quick_xml::XmlReader,
1186 {
1187 Ok(Self(
1188 bytes
1189 .split(|b| *b == b' ' || *b == b'|' || *b == b',' || *b == b';')
1190 .map(|bytes| QName::deserialize_bytes(reader, bytes))
1191 .collect::<Result<Vec<_>, _>>()?,
1192 ))
1193 }
1194}
1195#[derive(Debug, Clone, Eq, PartialEq, Default)]
1196pub struct SimpleDerivationSetItemList(pub Vec<SimpleDerivationSetItemType>);
1197impl crate::WithNamespace for SimpleDerivationSetItemList {
1198 fn prefix() -> Option<&'static str> {
1199 Some("xs")
1200 }
1201 fn namespace() -> Option<&'static str> {
1202 Some("http://www.w3.org/2001/XMLSchema")
1203 }
1204}
1205impl crate::quick_xml::DeserializeBytes for SimpleDerivationSetItemList {
1206 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1207 where
1208 R: crate::quick_xml::XmlReader,
1209 {
1210 Ok(Self(
1211 bytes
1212 .split(|b| *b == b' ' || *b == b'|' || *b == b',' || *b == b';')
1213 .map(|bytes| SimpleDerivationSetItemType::deserialize_bytes(reader, bytes))
1214 .collect::<Result<Vec<_>, _>>()?,
1215 ))
1216 }
1217}
1218#[derive(Debug, Clone, Eq, PartialEq)]
1219pub struct RestrictionType {
1220 pub id: Option<String>,
1221 pub base: QName,
1222 pub content: Vec<RestrictionTypeContent>,
1223}
1224#[derive(Debug, Clone, Eq, PartialEq)]
1225pub enum RestrictionTypeContent {
1226 Annotation(Annotation),
1227 OpenContent(OpenContent),
1228 Group(GroupType),
1229 All(GroupType),
1230 Choice(GroupType),
1231 Sequence(GroupType),
1232 SimpleType(SimpleBaseType),
1233 Facet(Facet),
1234 Attribute(AttributeType),
1235 AttributeGroup(AttributeGroupType),
1236 AnyAttribute(AnyAttribute),
1237 Assert(AssertionType),
1238}
1239impl crate::WithNamespace for RestrictionType {
1240 fn prefix() -> Option<&'static str> {
1241 Some("xs")
1242 }
1243 fn namespace() -> Option<&'static str> {
1244 Some("http://www.w3.org/2001/XMLSchema")
1245 }
1246}
1247impl crate::quick_xml::WithDeserializer for RestrictionType {
1248 type Deserializer = quick_xml_deserialize::RestrictionTypeDeserializer;
1249}
1250#[derive(Debug, Clone, Eq, PartialEq)]
1251pub struct ExtensionType {
1252 pub id: Option<String>,
1253 pub base: QName,
1254 pub content: Vec<ExtensionTypeContent>,
1255}
1256#[derive(Debug, Clone, Eq, PartialEq)]
1257pub enum ExtensionTypeContent {
1258 Annotation(Annotation),
1259 OpenContent(OpenContent),
1260 Group(GroupType),
1261 All(GroupType),
1262 Choice(GroupType),
1263 Sequence(GroupType),
1264 Attribute(AttributeType),
1265 AttributeGroup(AttributeGroupType),
1266 AnyAttribute(AnyAttribute),
1267 Assert(AssertionType),
1268}
1269impl crate::WithNamespace for ExtensionType {
1270 fn prefix() -> Option<&'static str> {
1271 Some("xs")
1272 }
1273 fn namespace() -> Option<&'static str> {
1274 Some("http://www.w3.org/2001/XMLSchema")
1275 }
1276}
1277impl crate::quick_xml::WithDeserializer for ExtensionType {
1278 type Deserializer = quick_xml_deserialize::ExtensionTypeDeserializer;
1279}
1280#[derive(Debug, Clone, Eq, PartialEq)]
1281pub enum OpenContentModeType {
1282 None,
1283 Interleave,
1284 Suffix,
1285}
1286impl crate::WithNamespace for OpenContentModeType {
1287 fn prefix() -> Option<&'static str> {
1288 Some("xs")
1289 }
1290 fn namespace() -> Option<&'static str> {
1291 Some("http://www.w3.org/2001/XMLSchema")
1292 }
1293}
1294impl crate::quick_xml::DeserializeBytes for OpenContentModeType {
1295 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1296 where
1297 R: crate::quick_xml::XmlReader,
1298 {
1299 match bytes {
1300 b"none" => Ok(Self::None),
1301 b"interleave" => Ok(Self::Interleave),
1302 b"suffix" => Ok(Self::Suffix),
1303 x => {
1304 use crate::quick_xml::{ErrorKind, RawByteStr};
1305 Err(reader.map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
1306 }
1307 }
1308 }
1309}
1310#[derive(Debug, Clone, Eq, PartialEq, Default)]
1311pub struct QnameListAType(pub Vec<QnameListAItemType>);
1312impl crate::WithNamespace for QnameListAType {
1313 fn prefix() -> Option<&'static str> {
1314 Some("xs")
1315 }
1316 fn namespace() -> Option<&'static str> {
1317 Some("http://www.w3.org/2001/XMLSchema")
1318 }
1319}
1320impl crate::quick_xml::DeserializeBytes for QnameListAType {
1321 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1322 where
1323 R: crate::quick_xml::XmlReader,
1324 {
1325 Ok(Self(
1326 bytes
1327 .split(|b| *b == b' ' || *b == b'|' || *b == b',' || *b == b';')
1328 .map(|bytes| QnameListAItemType::deserialize_bytes(reader, bytes))
1329 .collect::<Result<Vec<_>, _>>()?,
1330 ))
1331 }
1332}
1333#[derive(Debug, Clone, Eq, PartialEq, Default)]
1334pub struct ReducedDerivationControlList(pub Vec<ReducedDerivationControlType>);
1335impl crate::WithNamespace for ReducedDerivationControlList {
1336 fn prefix() -> Option<&'static str> {
1337 Some("xs")
1338 }
1339 fn namespace() -> Option<&'static str> {
1340 Some("http://www.w3.org/2001/XMLSchema")
1341 }
1342}
1343impl crate::quick_xml::DeserializeBytes for ReducedDerivationControlList {
1344 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1345 where
1346 R: crate::quick_xml::XmlReader,
1347 {
1348 Ok(Self(
1349 bytes
1350 .split(|b| *b == b' ' || *b == b'|' || *b == b',' || *b == b';')
1351 .map(|bytes| ReducedDerivationControlType::deserialize_bytes(reader, bytes))
1352 .collect::<Result<Vec<_>, _>>()?,
1353 ))
1354 }
1355}
1356#[derive(Debug, Clone, Eq, PartialEq, Default)]
1357pub struct QnameListType(pub Vec<QnameListItemType>);
1358impl crate::WithNamespace for QnameListType {
1359 fn prefix() -> Option<&'static str> {
1360 Some("xs")
1361 }
1362 fn namespace() -> Option<&'static str> {
1363 Some("http://www.w3.org/2001/XMLSchema")
1364 }
1365}
1366impl crate::quick_xml::DeserializeBytes for QnameListType {
1367 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1368 where
1369 R: crate::quick_xml::XmlReader,
1370 {
1371 Ok(Self(
1372 bytes
1373 .split(|b| *b == b' ' || *b == b'|' || *b == b',' || *b == b';')
1374 .map(|bytes| QnameListItemType::deserialize_bytes(reader, bytes))
1375 .collect::<Result<Vec<_>, _>>()?,
1376 ))
1377 }
1378}
1379#[derive(Debug, Clone, Eq, PartialEq)]
1380pub struct Field {
1381 pub id: Option<String>,
1382 pub xpath: String,
1383 pub xpath_default_namespace: Option<XpathDefaultNamespaceType>,
1384 pub annotation: Option<Annotation>,
1385}
1386impl crate::WithNamespace for Field {
1387 fn prefix() -> Option<&'static str> {
1388 Some("xs")
1389 }
1390 fn namespace() -> Option<&'static str> {
1391 Some("http://www.w3.org/2001/XMLSchema")
1392 }
1393}
1394impl crate::quick_xml::WithDeserializer for Field {
1395 type Deserializer = quick_xml_deserialize::FieldDeserializer;
1396}
1397#[derive(Debug, Clone, Eq, PartialEq)]
1398pub enum DerivationControlType {
1399 Substitution,
1400 Extension,
1401 Restriction,
1402 List,
1403 Union,
1404}
1405impl crate::WithNamespace for DerivationControlType {
1406 fn prefix() -> Option<&'static str> {
1407 Some("xs")
1408 }
1409 fn namespace() -> Option<&'static str> {
1410 Some("http://www.w3.org/2001/XMLSchema")
1411 }
1412}
1413impl crate::quick_xml::DeserializeBytes for DerivationControlType {
1414 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1415 where
1416 R: crate::quick_xml::XmlReader,
1417 {
1418 match bytes {
1419 b"substitution" => Ok(Self::Substitution),
1420 b"extension" => Ok(Self::Extension),
1421 b"restriction" => Ok(Self::Restriction),
1422 b"list" => Ok(Self::List),
1423 b"union" => Ok(Self::Union),
1424 x => {
1425 use crate::quick_xml::{ErrorKind, RawByteStr};
1426 Err(reader.map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x))))
1427 }
1428 }
1429 }
1430}
1431#[derive(Debug, Clone, Eq, PartialEq, Default)]
1432pub struct BasicNamespaceListType(pub Vec<BasicNamespaceListItemType>);
1433impl crate::WithNamespace for BasicNamespaceListType {
1434 fn prefix() -> Option<&'static str> {
1435 Some("xs")
1436 }
1437 fn namespace() -> Option<&'static str> {
1438 Some("http://www.w3.org/2001/XMLSchema")
1439 }
1440}
1441impl crate::quick_xml::DeserializeBytes for BasicNamespaceListType {
1442 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1443 where
1444 R: crate::quick_xml::XmlReader,
1445 {
1446 Ok(Self(
1447 bytes
1448 .split(|b| *b == b' ' || *b == b'|' || *b == b',' || *b == b';')
1449 .map(|bytes| BasicNamespaceListItemType::deserialize_bytes(reader, bytes))
1450 .collect::<Result<Vec<_>, _>>()?,
1451 ))
1452 }
1453}
1454#[derive(Debug, Clone, Eq, PartialEq)]
1455pub enum BasicNamespaceListItemType {
1456 String(String),
1457 TargetNamespace,
1458 Local,
1459}
1460impl crate::WithNamespace for BasicNamespaceListItemType {
1461 fn prefix() -> Option<&'static str> {
1462 Some("xs")
1463 }
1464 fn namespace() -> Option<&'static str> {
1465 Some("http://www.w3.org/2001/XMLSchema")
1466 }
1467}
1468impl crate::quick_xml::DeserializeBytes for BasicNamespaceListItemType {
1469 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1470 where
1471 R: crate::quick_xml::XmlReader,
1472 {
1473 match bytes {
1474 b"##targetNamespace" => Ok(Self::TargetNamespace),
1475 b"##local" => Ok(Self::Local),
1476 x => Ok(Self::String(String::deserialize_bytes(reader, x)?)),
1477 }
1478 }
1479}
1480#[derive(Debug, Clone, Eq, PartialEq)]
1481pub struct FacetType {
1482 pub id: Option<String>,
1483 pub value: String,
1484 pub fixed: bool,
1485 pub annotation: Option<Annotation>,
1486}
1487impl crate::WithNamespace for FacetType {
1488 fn prefix() -> Option<&'static str> {
1489 Some("xs")
1490 }
1491 fn namespace() -> Option<&'static str> {
1492 Some("http://www.w3.org/2001/XMLSchema")
1493 }
1494}
1495impl FacetType {
1496 #[must_use]
1497 pub fn default_fixed() -> bool {
1498 false
1499 }
1500}
1501impl crate::quick_xml::WithDeserializer for FacetType {
1502 type Deserializer = quick_xml_deserialize::FacetTypeDeserializer;
1503}
1504pub type SimpleDerivationSetItemType = DerivationControlType;
1505#[derive(Debug, Clone, Eq, PartialEq)]
1506pub enum QnameListAItemType {
1507 Qname(QName),
1508 Defined,
1509}
1510impl crate::WithNamespace for QnameListAItemType {
1511 fn prefix() -> Option<&'static str> {
1512 Some("xs")
1513 }
1514 fn namespace() -> Option<&'static str> {
1515 Some("http://www.w3.org/2001/XMLSchema")
1516 }
1517}
1518impl crate::quick_xml::DeserializeBytes for QnameListAItemType {
1519 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1520 where
1521 R: crate::quick_xml::XmlReader,
1522 {
1523 match bytes {
1524 b"##defined" => Ok(Self::Defined),
1525 x => Ok(Self::Qname(QName::deserialize_bytes(reader, x)?)),
1526 }
1527 }
1528}
1529pub type ReducedDerivationControlType = DerivationControlType;
1530#[derive(Debug, Clone, Eq, PartialEq)]
1531pub enum QnameListItemType {
1532 Qname(QName),
1533 Defined,
1534 DefinedSibling,
1535}
1536impl crate::WithNamespace for QnameListItemType {
1537 fn prefix() -> Option<&'static str> {
1538 Some("xs")
1539 }
1540 fn namespace() -> Option<&'static str> {
1541 Some("http://www.w3.org/2001/XMLSchema")
1542 }
1543}
1544impl crate::quick_xml::DeserializeBytes for QnameListItemType {
1545 fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, crate::quick_xml::Error>
1546 where
1547 R: crate::quick_xml::XmlReader,
1548 {
1549 match bytes {
1550 b"##defined" => Ok(Self::Defined),
1551 b"##definedSibling" => Ok(Self::DefinedSibling),
1552 x => Ok(Self::Qname(QName::deserialize_bytes(reader, x)?)),
1553 }
1554 }
1555}
1556pub mod quick_xml_deserialize {
1557 use super::*;
1558 #[derive(Debug)]
1559 pub struct SchemaDeserializer {
1560 target_namespace: Option<String>,
1561 version: Option<String>,
1562 final_default: super::FullDerivationSetType,
1563 block_default: super::BlockSetType,
1564 attribute_form_default: super::FormChoiceType,
1565 element_form_default: super::FormChoiceType,
1566 default_attributes: Option<super::QName>,
1567 xpath_default_namespace: super::XpathDefaultNamespaceType,
1568 id: Option<String>,
1569 lang: Option<String>,
1570 content: Vec<super::SchemaContent>,
1571 state: Box<SchemaDeserializerState>,
1572 }
1573 #[derive(Debug)]
1574 enum SchemaDeserializerState {
1575 Next__,
1576 Include(<Include as crate::quick_xml::WithDeserializer>::Deserializer),
1577 Import(<Import as crate::quick_xml::WithDeserializer>::Deserializer),
1578 Redefine(<Redefine as crate::quick_xml::WithDeserializer>::Deserializer),
1579 Override(<Override as crate::quick_xml::WithDeserializer>::Deserializer),
1580 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
1581 DefaultOpenContent(
1582 <DefaultOpenContent as crate::quick_xml::WithDeserializer>::Deserializer,
1583 ),
1584 SimpleType(<SimpleBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
1585 ComplexType(<ComplexBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
1586 Group(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
1587 AttributeGroup(<AttributeGroupType as crate::quick_xml::WithDeserializer>::Deserializer),
1588 Element(<ElementType as crate::quick_xml::WithDeserializer>::Deserializer),
1589 Attribute(<AttributeType as crate::quick_xml::WithDeserializer>::Deserializer),
1590 Notation(<Notation as crate::quick_xml::WithDeserializer>::Deserializer),
1591 }
1592 impl SchemaDeserializer {
1593 fn from_bytes_start<R>(
1594 reader: &R,
1595 bytes_start: &crate::quick_xml::BytesStart<'_>,
1596 ) -> Result<Self, crate::quick_xml::Error>
1597 where
1598 R: crate::quick_xml::XmlReader,
1599 {
1600 use crate::quick_xml::ErrorKind;
1601 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
1602 const NS_XML: &[u8] = b"http://www.w3.org/XML/1998/namespace";
1603 let mut target_namespace: Option<String> = None;
1604 let mut version: Option<String> = None;
1605 let mut final_default: Option<FullDerivationSetType> = None;
1606 let mut block_default: Option<BlockSetType> = None;
1607 let mut attribute_form_default: Option<FormChoiceType> = None;
1608 let mut element_form_default: Option<FormChoiceType> = None;
1609 let mut default_attributes: Option<QName> = None;
1610 let mut xpath_default_namespace: Option<XpathDefaultNamespaceType> = None;
1611 let mut id: Option<String> = None;
1612 let mut lang: Option<String> = None;
1613 for attrib in bytes_start.attributes() {
1614 let attrib = attrib?;
1615 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
1616 continue;
1617 }
1618 if matches!(
1619 reader.resolve_local_name(attrib.key, NS_XS),
1620 Some(b"targetNamespace")
1621 ) {
1622 reader.read_attrib(&mut target_namespace, b"targetNamespace", &attrib.value)?;
1623 } else if matches!(
1624 reader.resolve_local_name(attrib.key, NS_XS),
1625 Some(b"version")
1626 ) {
1627 reader.read_attrib(&mut version, b"version", &attrib.value)?;
1628 } else if matches!(
1629 reader.resolve_local_name(attrib.key, NS_XS),
1630 Some(b"finalDefault")
1631 ) {
1632 reader.read_attrib(&mut final_default, b"finalDefault", &attrib.value)?;
1633 } else if matches!(
1634 reader.resolve_local_name(attrib.key, NS_XS),
1635 Some(b"blockDefault")
1636 ) {
1637 reader.read_attrib(&mut block_default, b"blockDefault", &attrib.value)?;
1638 } else if matches!(
1639 reader.resolve_local_name(attrib.key, NS_XS),
1640 Some(b"attributeFormDefault")
1641 ) {
1642 reader.read_attrib(
1643 &mut attribute_form_default,
1644 b"attributeFormDefault",
1645 &attrib.value,
1646 )?;
1647 } else if matches!(
1648 reader.resolve_local_name(attrib.key, NS_XS),
1649 Some(b"elementFormDefault")
1650 ) {
1651 reader.read_attrib(
1652 &mut element_form_default,
1653 b"elementFormDefault",
1654 &attrib.value,
1655 )?;
1656 } else if matches!(
1657 reader.resolve_local_name(attrib.key, NS_XS),
1658 Some(b"defaultAttributes")
1659 ) {
1660 reader.read_attrib(
1661 &mut default_attributes,
1662 b"defaultAttributes",
1663 &attrib.value,
1664 )?;
1665 } else if matches!(
1666 reader.resolve_local_name(attrib.key, NS_XS),
1667 Some(b"xpathDefaultNamespace")
1668 ) {
1669 reader.read_attrib(
1670 &mut xpath_default_namespace,
1671 b"xpathDefaultNamespace",
1672 &attrib.value,
1673 )?;
1674 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
1675 reader.read_attrib(&mut id, b"id", &attrib.value)?;
1676 } else if matches!(reader.resolve_local_name(attrib.key, NS_XML), Some(b"lang")) {
1677 reader.read_attrib(&mut lang, b"lang", &attrib.value)?;
1678 }
1679 }
1680 Ok(Self {
1681 target_namespace: target_namespace,
1682 version: version,
1683 final_default: final_default.unwrap_or_else(super::Schema::default_final_default),
1684 block_default: block_default.unwrap_or_else(super::Schema::default_block_default),
1685 attribute_form_default: attribute_form_default
1686 .unwrap_or_else(super::Schema::default_attribute_form_default),
1687 element_form_default: element_form_default
1688 .unwrap_or_else(super::Schema::default_element_form_default),
1689 default_attributes: default_attributes,
1690 xpath_default_namespace: xpath_default_namespace
1691 .unwrap_or_else(super::Schema::default_xpath_default_namespace),
1692 id: id,
1693 lang: lang,
1694 content: Vec::new(),
1695 state: Box::new(SchemaDeserializerState::Next__),
1696 })
1697 }
1698 }
1699 impl<'de> crate::quick_xml::Deserializer<'de, super::Schema> for SchemaDeserializer {
1700 fn init<R>(
1701 reader: &R,
1702 event: crate::quick_xml::Event<'de>,
1703 ) -> crate::quick_xml::DeserializerResult<'de, super::Schema, Self>
1704 where
1705 R: crate::quick_xml::XmlReader,
1706 {
1707 use crate::quick_xml::{DeserializerOutput, Event};
1708 match event {
1709 Event::Start(start) => {
1710 let deserializer = Self::from_bytes_start(reader, &start)?;
1711 Ok(DeserializerOutput {
1712 data: None,
1713 deserializer: Some(deserializer),
1714 event: None,
1715 allow_any: false,
1716 })
1717 }
1718 Event::Empty(start) => {
1719 let deserializer = Self::from_bytes_start(reader, &start)?;
1720 let data = deserializer.finish(reader)?;
1721 Ok(DeserializerOutput {
1722 data: Some(data),
1723 deserializer: None,
1724 event: None,
1725 allow_any: false,
1726 })
1727 }
1728 event => Ok(DeserializerOutput {
1729 data: None,
1730 deserializer: None,
1731 event: Some(event),
1732 allow_any: false,
1733 }),
1734 }
1735 }
1736 fn next<R>(
1737 mut self,
1738 reader: &R,
1739 event: crate::quick_xml::Event<'de>,
1740 ) -> crate::quick_xml::DeserializerResult<'de, super::Schema, Self>
1741 where
1742 R: crate::quick_xml::XmlReader,
1743 {
1744 use crate::quick_xml::{
1745 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
1746 };
1747 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
1748 match (
1749 core::mem::replace(&mut *self.state, SchemaDeserializerState::Next__),
1750 &event,
1751 ) {
1752 (SchemaDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
1753 if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"include")) {
1754 let DeserializerOutput {
1755 data,
1756 deserializer,
1757 event,
1758 allow_any,
1759 } = <Include as WithDeserializer>::Deserializer::init(reader, event)?;
1760 if let Some(data) = data {
1761 self.content.push(SchemaContent::Include(data));
1762 }
1763 if let Some(deserializer) = deserializer {
1764 *self.state = SchemaDeserializerState::Include(deserializer);
1765 }
1766 Ok(DeserializerOutput {
1767 data: None,
1768 deserializer: Some(self),
1769 event,
1770 allow_any,
1771 })
1772 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"import"))
1773 {
1774 let DeserializerOutput {
1775 data,
1776 deserializer,
1777 event,
1778 allow_any,
1779 } = <Import as WithDeserializer>::Deserializer::init(reader, event)?;
1780 if let Some(data) = data {
1781 self.content.push(SchemaContent::Import(data));
1782 }
1783 if let Some(deserializer) = deserializer {
1784 *self.state = SchemaDeserializerState::Import(deserializer);
1785 }
1786 Ok(DeserializerOutput {
1787 data: None,
1788 deserializer: Some(self),
1789 event,
1790 allow_any,
1791 })
1792 } else if matches!(
1793 reader.resolve_local_name(x.name(), NS_XS),
1794 Some(b"redefine")
1795 ) {
1796 let DeserializerOutput {
1797 data,
1798 deserializer,
1799 event,
1800 allow_any,
1801 } = <Redefine as WithDeserializer>::Deserializer::init(reader, event)?;
1802 if let Some(data) = data {
1803 self.content.push(SchemaContent::Redefine(data));
1804 }
1805 if let Some(deserializer) = deserializer {
1806 *self.state = SchemaDeserializerState::Redefine(deserializer);
1807 }
1808 Ok(DeserializerOutput {
1809 data: None,
1810 deserializer: Some(self),
1811 event,
1812 allow_any,
1813 })
1814 } else if matches!(
1815 reader.resolve_local_name(x.name(), NS_XS),
1816 Some(b"override")
1817 ) {
1818 let DeserializerOutput {
1819 data,
1820 deserializer,
1821 event,
1822 allow_any,
1823 } = <Override as WithDeserializer>::Deserializer::init(reader, event)?;
1824 if let Some(data) = data {
1825 self.content.push(SchemaContent::Override(data));
1826 }
1827 if let Some(deserializer) = deserializer {
1828 *self.state = SchemaDeserializerState::Override(deserializer);
1829 }
1830 Ok(DeserializerOutput {
1831 data: None,
1832 deserializer: Some(self),
1833 event,
1834 allow_any,
1835 })
1836 } else if matches!(
1837 reader.resolve_local_name(x.name(), NS_XS),
1838 Some(b"annotation")
1839 ) {
1840 let DeserializerOutput {
1841 data,
1842 deserializer,
1843 event,
1844 allow_any,
1845 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
1846 if let Some(data) = data {
1847 self.content.push(SchemaContent::Annotation(data));
1848 }
1849 if let Some(deserializer) = deserializer {
1850 *self.state = SchemaDeserializerState::Annotation(deserializer);
1851 }
1852 Ok(DeserializerOutput {
1853 data: None,
1854 deserializer: Some(self),
1855 event,
1856 allow_any,
1857 })
1858 } else if matches!(
1859 reader.resolve_local_name(x.name(), NS_XS),
1860 Some(b"defaultOpenContent")
1861 ) {
1862 let DeserializerOutput {
1863 data,
1864 deserializer,
1865 event,
1866 allow_any,
1867 } = <DefaultOpenContent as WithDeserializer>::Deserializer::init(
1868 reader, event,
1869 )?;
1870 if let Some(data) = data {
1871 self.content.push(SchemaContent::DefaultOpenContent(data));
1872 }
1873 if let Some(deserializer) = deserializer {
1874 *self.state = SchemaDeserializerState::DefaultOpenContent(deserializer);
1875 }
1876 Ok(DeserializerOutput {
1877 data: None,
1878 deserializer: Some(self),
1879 event,
1880 allow_any,
1881 })
1882 } else if matches!(
1883 reader.resolve_local_name(x.name(), NS_XS),
1884 Some(b"simpleType")
1885 ) {
1886 let DeserializerOutput {
1887 data,
1888 deserializer,
1889 event,
1890 allow_any,
1891 } = <SimpleBaseType as WithDeserializer>::Deserializer::init(
1892 reader, event,
1893 )?;
1894 if let Some(data) = data {
1895 self.content.push(SchemaContent::SimpleType(data));
1896 }
1897 if let Some(deserializer) = deserializer {
1898 *self.state = SchemaDeserializerState::SimpleType(deserializer);
1899 }
1900 Ok(DeserializerOutput {
1901 data: None,
1902 deserializer: Some(self),
1903 event,
1904 allow_any,
1905 })
1906 } else if matches!(
1907 reader.resolve_local_name(x.name(), NS_XS),
1908 Some(b"complexType")
1909 ) {
1910 let DeserializerOutput {
1911 data,
1912 deserializer,
1913 event,
1914 allow_any,
1915 } = <ComplexBaseType as WithDeserializer>::Deserializer::init(
1916 reader, event,
1917 )?;
1918 if let Some(data) = data {
1919 self.content.push(SchemaContent::ComplexType(data));
1920 }
1921 if let Some(deserializer) = deserializer {
1922 *self.state = SchemaDeserializerState::ComplexType(deserializer);
1923 }
1924 Ok(DeserializerOutput {
1925 data: None,
1926 deserializer: Some(self),
1927 event,
1928 allow_any,
1929 })
1930 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"group")) {
1931 let DeserializerOutput {
1932 data,
1933 deserializer,
1934 event,
1935 allow_any,
1936 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
1937 if let Some(data) = data {
1938 self.content.push(SchemaContent::Group(data));
1939 }
1940 if let Some(deserializer) = deserializer {
1941 *self.state = SchemaDeserializerState::Group(deserializer);
1942 }
1943 Ok(DeserializerOutput {
1944 data: None,
1945 deserializer: Some(self),
1946 event,
1947 allow_any,
1948 })
1949 } else if matches!(
1950 reader.resolve_local_name(x.name(), NS_XS),
1951 Some(b"attributeGroup")
1952 ) {
1953 let DeserializerOutput {
1954 data,
1955 deserializer,
1956 event,
1957 allow_any,
1958 } = <AttributeGroupType as WithDeserializer>::Deserializer::init(
1959 reader, event,
1960 )?;
1961 if let Some(data) = data {
1962 self.content.push(SchemaContent::AttributeGroup(data));
1963 }
1964 if let Some(deserializer) = deserializer {
1965 *self.state = SchemaDeserializerState::AttributeGroup(deserializer);
1966 }
1967 Ok(DeserializerOutput {
1968 data: None,
1969 deserializer: Some(self),
1970 event,
1971 allow_any,
1972 })
1973 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"element"))
1974 {
1975 let DeserializerOutput {
1976 data,
1977 deserializer,
1978 event,
1979 allow_any,
1980 } = <ElementType as WithDeserializer>::Deserializer::init(reader, event)?;
1981 if let Some(data) = data {
1982 self.content.push(SchemaContent::Element(data));
1983 }
1984 if let Some(deserializer) = deserializer {
1985 *self.state = SchemaDeserializerState::Element(deserializer);
1986 }
1987 Ok(DeserializerOutput {
1988 data: None,
1989 deserializer: Some(self),
1990 event,
1991 allow_any,
1992 })
1993 } else if matches!(
1994 reader.resolve_local_name(x.name(), NS_XS),
1995 Some(b"attribute")
1996 ) {
1997 let DeserializerOutput {
1998 data,
1999 deserializer,
2000 event,
2001 allow_any,
2002 } = <AttributeType as WithDeserializer>::Deserializer::init(reader, event)?;
2003 if let Some(data) = data {
2004 self.content.push(SchemaContent::Attribute(data));
2005 }
2006 if let Some(deserializer) = deserializer {
2007 *self.state = SchemaDeserializerState::Attribute(deserializer);
2008 }
2009 Ok(DeserializerOutput {
2010 data: None,
2011 deserializer: Some(self),
2012 event,
2013 allow_any,
2014 })
2015 } else if matches!(
2016 reader.resolve_local_name(x.name(), NS_XS),
2017 Some(b"notation")
2018 ) {
2019 let DeserializerOutput {
2020 data,
2021 deserializer,
2022 event,
2023 allow_any,
2024 } = <Notation as WithDeserializer>::Deserializer::init(reader, event)?;
2025 if let Some(data) = data {
2026 self.content.push(SchemaContent::Notation(data));
2027 }
2028 if let Some(deserializer) = deserializer {
2029 *self.state = SchemaDeserializerState::Notation(deserializer);
2030 }
2031 Ok(DeserializerOutput {
2032 data: None,
2033 deserializer: Some(self),
2034 event,
2035 allow_any,
2036 })
2037 } else {
2038 Ok(DeserializerOutput {
2039 data: None,
2040 deserializer: Some(self),
2041 event: Some(event),
2042 allow_any: false,
2043 })
2044 }
2045 }
2046 (SchemaDeserializerState::Next__, Event::End(_)) => {
2047 let data = self.finish(reader)?;
2048 Ok(DeserializerOutput {
2049 data: Some(data),
2050 deserializer: None,
2051 event: None,
2052 allow_any: false,
2053 })
2054 }
2055 (SchemaDeserializerState::Next__, _) => Ok(DeserializerOutput {
2056 data: None,
2057 deserializer: Some(self),
2058 event: None,
2059 allow_any: false,
2060 }),
2061 (SchemaDeserializerState::Include(deserializer), _) => {
2062 let DeserializerOutput {
2063 data,
2064 deserializer,
2065 event,
2066 allow_any,
2067 } = deserializer.next(reader, event)?;
2068 if let Some(data) = data {
2069 self.content.push(SchemaContent::Include(data));
2070 }
2071 if let Some(deserializer) = deserializer {
2072 *self.state = SchemaDeserializerState::Include(deserializer);
2073 }
2074 Ok(DeserializerOutput {
2075 data: None,
2076 deserializer: Some(self),
2077 event,
2078 allow_any,
2079 })
2080 }
2081 (SchemaDeserializerState::Import(deserializer), _) => {
2082 let DeserializerOutput {
2083 data,
2084 deserializer,
2085 event,
2086 allow_any,
2087 } = deserializer.next(reader, event)?;
2088 if let Some(data) = data {
2089 self.content.push(SchemaContent::Import(data));
2090 }
2091 if let Some(deserializer) = deserializer {
2092 *self.state = SchemaDeserializerState::Import(deserializer);
2093 }
2094 Ok(DeserializerOutput {
2095 data: None,
2096 deserializer: Some(self),
2097 event,
2098 allow_any,
2099 })
2100 }
2101 (SchemaDeserializerState::Redefine(deserializer), _) => {
2102 let DeserializerOutput {
2103 data,
2104 deserializer,
2105 event,
2106 allow_any,
2107 } = deserializer.next(reader, event)?;
2108 if let Some(data) = data {
2109 self.content.push(SchemaContent::Redefine(data));
2110 }
2111 if let Some(deserializer) = deserializer {
2112 *self.state = SchemaDeserializerState::Redefine(deserializer);
2113 }
2114 Ok(DeserializerOutput {
2115 data: None,
2116 deserializer: Some(self),
2117 event,
2118 allow_any,
2119 })
2120 }
2121 (SchemaDeserializerState::Override(deserializer), _) => {
2122 let DeserializerOutput {
2123 data,
2124 deserializer,
2125 event,
2126 allow_any,
2127 } = deserializer.next(reader, event)?;
2128 if let Some(data) = data {
2129 self.content.push(SchemaContent::Override(data));
2130 }
2131 if let Some(deserializer) = deserializer {
2132 *self.state = SchemaDeserializerState::Override(deserializer);
2133 }
2134 Ok(DeserializerOutput {
2135 data: None,
2136 deserializer: Some(self),
2137 event,
2138 allow_any,
2139 })
2140 }
2141 (SchemaDeserializerState::Annotation(deserializer), _) => {
2142 let DeserializerOutput {
2143 data,
2144 deserializer,
2145 event,
2146 allow_any,
2147 } = deserializer.next(reader, event)?;
2148 if let Some(data) = data {
2149 self.content.push(SchemaContent::Annotation(data));
2150 }
2151 if let Some(deserializer) = deserializer {
2152 *self.state = SchemaDeserializerState::Annotation(deserializer);
2153 }
2154 Ok(DeserializerOutput {
2155 data: None,
2156 deserializer: Some(self),
2157 event,
2158 allow_any,
2159 })
2160 }
2161 (SchemaDeserializerState::DefaultOpenContent(deserializer), _) => {
2162 let DeserializerOutput {
2163 data,
2164 deserializer,
2165 event,
2166 allow_any,
2167 } = deserializer.next(reader, event)?;
2168 if let Some(data) = data {
2169 self.content.push(SchemaContent::DefaultOpenContent(data));
2170 }
2171 if let Some(deserializer) = deserializer {
2172 *self.state = SchemaDeserializerState::DefaultOpenContent(deserializer);
2173 }
2174 Ok(DeserializerOutput {
2175 data: None,
2176 deserializer: Some(self),
2177 event,
2178 allow_any,
2179 })
2180 }
2181 (SchemaDeserializerState::SimpleType(deserializer), _) => {
2182 let DeserializerOutput {
2183 data,
2184 deserializer,
2185 event,
2186 allow_any,
2187 } = deserializer.next(reader, event)?;
2188 if let Some(data) = data {
2189 self.content.push(SchemaContent::SimpleType(data));
2190 }
2191 if let Some(deserializer) = deserializer {
2192 *self.state = SchemaDeserializerState::SimpleType(deserializer);
2193 }
2194 Ok(DeserializerOutput {
2195 data: None,
2196 deserializer: Some(self),
2197 event,
2198 allow_any,
2199 })
2200 }
2201 (SchemaDeserializerState::ComplexType(deserializer), _) => {
2202 let DeserializerOutput {
2203 data,
2204 deserializer,
2205 event,
2206 allow_any,
2207 } = deserializer.next(reader, event)?;
2208 if let Some(data) = data {
2209 self.content.push(SchemaContent::ComplexType(data));
2210 }
2211 if let Some(deserializer) = deserializer {
2212 *self.state = SchemaDeserializerState::ComplexType(deserializer);
2213 }
2214 Ok(DeserializerOutput {
2215 data: None,
2216 deserializer: Some(self),
2217 event,
2218 allow_any,
2219 })
2220 }
2221 (SchemaDeserializerState::Group(deserializer), _) => {
2222 let DeserializerOutput {
2223 data,
2224 deserializer,
2225 event,
2226 allow_any,
2227 } = deserializer.next(reader, event)?;
2228 if let Some(data) = data {
2229 self.content.push(SchemaContent::Group(data));
2230 }
2231 if let Some(deserializer) = deserializer {
2232 *self.state = SchemaDeserializerState::Group(deserializer);
2233 }
2234 Ok(DeserializerOutput {
2235 data: None,
2236 deserializer: Some(self),
2237 event,
2238 allow_any,
2239 })
2240 }
2241 (SchemaDeserializerState::AttributeGroup(deserializer), _) => {
2242 let DeserializerOutput {
2243 data,
2244 deserializer,
2245 event,
2246 allow_any,
2247 } = deserializer.next(reader, event)?;
2248 if let Some(data) = data {
2249 self.content.push(SchemaContent::AttributeGroup(data));
2250 }
2251 if let Some(deserializer) = deserializer {
2252 *self.state = SchemaDeserializerState::AttributeGroup(deserializer);
2253 }
2254 Ok(DeserializerOutput {
2255 data: None,
2256 deserializer: Some(self),
2257 event,
2258 allow_any,
2259 })
2260 }
2261 (SchemaDeserializerState::Element(deserializer), _) => {
2262 let DeserializerOutput {
2263 data,
2264 deserializer,
2265 event,
2266 allow_any,
2267 } = deserializer.next(reader, event)?;
2268 if let Some(data) = data {
2269 self.content.push(SchemaContent::Element(data));
2270 }
2271 if let Some(deserializer) = deserializer {
2272 *self.state = SchemaDeserializerState::Element(deserializer);
2273 }
2274 Ok(DeserializerOutput {
2275 data: None,
2276 deserializer: Some(self),
2277 event,
2278 allow_any,
2279 })
2280 }
2281 (SchemaDeserializerState::Attribute(deserializer), _) => {
2282 let DeserializerOutput {
2283 data,
2284 deserializer,
2285 event,
2286 allow_any,
2287 } = deserializer.next(reader, event)?;
2288 if let Some(data) = data {
2289 self.content.push(SchemaContent::Attribute(data));
2290 }
2291 if let Some(deserializer) = deserializer {
2292 *self.state = SchemaDeserializerState::Attribute(deserializer);
2293 }
2294 Ok(DeserializerOutput {
2295 data: None,
2296 deserializer: Some(self),
2297 event,
2298 allow_any,
2299 })
2300 }
2301 (SchemaDeserializerState::Notation(deserializer), _) => {
2302 let DeserializerOutput {
2303 data,
2304 deserializer,
2305 event,
2306 allow_any,
2307 } = deserializer.next(reader, event)?;
2308 if let Some(data) = data {
2309 self.content.push(SchemaContent::Notation(data));
2310 }
2311 if let Some(deserializer) = deserializer {
2312 *self.state = SchemaDeserializerState::Notation(deserializer);
2313 }
2314 Ok(DeserializerOutput {
2315 data: None,
2316 deserializer: Some(self),
2317 event,
2318 allow_any,
2319 })
2320 }
2321 }
2322 }
2323 fn finish<R>(self, _reader: &R) -> Result<super::Schema, crate::quick_xml::Error>
2324 where
2325 R: crate::quick_xml::XmlReader,
2326 {
2327 use crate::quick_xml::ErrorKind;
2328 Ok(super::Schema {
2329 target_namespace: self.target_namespace,
2330 version: self.version,
2331 final_default: self.final_default,
2332 block_default: self.block_default,
2333 attribute_form_default: self.attribute_form_default,
2334 element_form_default: self.element_form_default,
2335 default_attributes: self.default_attributes,
2336 xpath_default_namespace: self.xpath_default_namespace,
2337 id: self.id,
2338 lang: self.lang,
2339 content: self.content,
2340 })
2341 }
2342 }
2343 #[derive(Debug)]
2344 pub struct IncludeDeserializer {
2345 id: Option<String>,
2346 schema_location: String,
2347 annotation: Option<super::Annotation>,
2348 state: Box<IncludeDeserializerState>,
2349 }
2350 #[derive(Debug)]
2351 enum IncludeDeserializerState {
2352 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
2353 Done__,
2354 }
2355 impl IncludeDeserializer {
2356 fn from_bytes_start<R>(
2357 reader: &R,
2358 bytes_start: &crate::quick_xml::BytesStart<'_>,
2359 ) -> Result<Self, crate::quick_xml::Error>
2360 where
2361 R: crate::quick_xml::XmlReader,
2362 {
2363 use crate::quick_xml::ErrorKind;
2364 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
2365 let mut id: Option<String> = None;
2366 let mut schema_location: Option<String> = None;
2367 for attrib in bytes_start.attributes() {
2368 let attrib = attrib?;
2369 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
2370 continue;
2371 }
2372 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
2373 reader.read_attrib(&mut id, b"id", &attrib.value)?;
2374 } else if matches!(
2375 reader.resolve_local_name(attrib.key, NS_XS),
2376 Some(b"schemaLocation")
2377 ) {
2378 reader.read_attrib(&mut schema_location, b"schemaLocation", &attrib.value)?;
2379 }
2380 }
2381 Ok(Self {
2382 id: id,
2383 schema_location: schema_location
2384 .ok_or(ErrorKind::MissingAttribute("schemaLocation".into()))?,
2385 annotation: None,
2386 state: Box::new(IncludeDeserializerState::Annotation(None)),
2387 })
2388 }
2389 }
2390 impl<'de> crate::quick_xml::Deserializer<'de, super::Include> for IncludeDeserializer {
2391 fn init<R>(
2392 reader: &R,
2393 event: crate::quick_xml::Event<'de>,
2394 ) -> crate::quick_xml::DeserializerResult<'de, super::Include, Self>
2395 where
2396 R: crate::quick_xml::XmlReader,
2397 {
2398 use crate::quick_xml::{DeserializerOutput, Event};
2399 match event {
2400 Event::Start(start) => {
2401 let deserializer = Self::from_bytes_start(reader, &start)?;
2402 Ok(DeserializerOutput {
2403 data: None,
2404 deserializer: Some(deserializer),
2405 event: None,
2406 allow_any: false,
2407 })
2408 }
2409 Event::Empty(start) => {
2410 let deserializer = Self::from_bytes_start(reader, &start)?;
2411 let data = deserializer.finish(reader)?;
2412 Ok(DeserializerOutput {
2413 data: Some(data),
2414 deserializer: None,
2415 event: None,
2416 allow_any: false,
2417 })
2418 }
2419 event => Ok(DeserializerOutput {
2420 data: None,
2421 deserializer: None,
2422 event: Some(event),
2423 allow_any: false,
2424 }),
2425 }
2426 }
2427 fn next<R>(
2428 mut self,
2429 reader: &R,
2430 event: crate::quick_xml::Event<'de>,
2431 ) -> crate::quick_xml::DeserializerResult<'de, super::Include, Self>
2432 where
2433 R: crate::quick_xml::XmlReader,
2434 {
2435 use crate::quick_xml::{
2436 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
2437 };
2438 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
2439 let mut event = event;
2440 let mut allow_any_fallback = None;
2441 loop {
2442 event = match (
2443 core::mem::replace(&mut *self.state, IncludeDeserializerState::Done__),
2444 event,
2445 ) {
2446 (IncludeDeserializerState::Annotation(Some(deserializer)), event) => {
2447 let DeserializerOutput {
2448 data,
2449 deserializer,
2450 event,
2451 allow_any,
2452 } = deserializer.next(reader, event)?;
2453 if let Some(data) = data {
2454 if self.annotation.is_some() {
2455 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
2456 b"annotation",
2457 )))?;
2458 }
2459 self.annotation = Some(data);
2460 }
2461 let event = match event {
2462 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
2463 event
2464 }
2465 event => {
2466 *self.state = IncludeDeserializerState::Annotation(deserializer);
2467 return Ok(DeserializerOutput {
2468 data: None,
2469 deserializer: Some(self),
2470 event: event,
2471 allow_any: false,
2472 });
2473 }
2474 };
2475 if allow_any {
2476 allow_any_fallback
2477 .get_or_insert(IncludeDeserializerState::Annotation(deserializer));
2478 } else if let Some(deserializer) = deserializer {
2479 let data = deserializer.finish(reader)?;
2480 if self.annotation.is_some() {
2481 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
2482 b"annotation",
2483 )))?;
2484 }
2485 self.annotation = Some(data);
2486 }
2487 *self.state = IncludeDeserializerState::Annotation(None);
2488 event
2489 }
2490 (IncludeDeserializerState::Annotation(None), event) => match &event {
2491 Event::Start(x) | Event::Empty(x)
2492 if matches!(
2493 reader.resolve_local_name(x.name(), NS_XS),
2494 Some(b"annotation")
2495 ) =>
2496 {
2497 let DeserializerOutput {
2498 data,
2499 deserializer,
2500 event,
2501 allow_any,
2502 } = <Annotation as WithDeserializer>::Deserializer::init(
2503 reader, event,
2504 )?;
2505 if let Some(data) = data {
2506 if self.annotation.is_some() {
2507 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
2508 b"annotation",
2509 )))?;
2510 }
2511 self.annotation = Some(data);
2512 }
2513 *self.state = IncludeDeserializerState::Annotation(deserializer);
2514 match event {
2515 Some(event @ (Event::Start(_) | Event::End(_))) => {
2516 *self.state = IncludeDeserializerState::Done__;
2517 if allow_any {
2518 allow_any_fallback.get_or_insert(
2519 IncludeDeserializerState::Annotation(None),
2520 );
2521 }
2522 event
2523 }
2524 event @ (None | Some(_)) => {
2525 return Ok(DeserializerOutput {
2526 data: None,
2527 deserializer: Some(self),
2528 event,
2529 allow_any: false,
2530 })
2531 }
2532 }
2533 }
2534 Event::Start(_) | Event::Empty(_) => {
2535 *self.state = IncludeDeserializerState::Done__;
2536 allow_any_fallback
2537 .get_or_insert(IncludeDeserializerState::Annotation(None));
2538 event
2539 }
2540 Event::End(_) => {
2541 let data = self.finish(reader)?;
2542 return Ok(DeserializerOutput {
2543 data: Some(data),
2544 deserializer: None,
2545 event: None,
2546 allow_any: false,
2547 });
2548 }
2549 _ => {
2550 *self.state = IncludeDeserializerState::Annotation(None);
2551 return Ok(DeserializerOutput {
2552 data: None,
2553 deserializer: Some(self),
2554 event: Some(event),
2555 allow_any: false,
2556 });
2557 }
2558 },
2559 (IncludeDeserializerState::Done__, event) => {
2560 let allow_any = if let Some(fallback) = allow_any_fallback {
2561 *self.state = fallback;
2562 true
2563 } else {
2564 false
2565 };
2566 return Ok(DeserializerOutput {
2567 data: None,
2568 deserializer: Some(self),
2569 event: Some(event),
2570 allow_any,
2571 });
2572 }
2573 }
2574 }
2575 }
2576 fn finish<R>(self, _reader: &R) -> Result<super::Include, crate::quick_xml::Error>
2577 where
2578 R: crate::quick_xml::XmlReader,
2579 {
2580 use crate::quick_xml::ErrorKind;
2581 Ok(super::Include {
2582 id: self.id,
2583 schema_location: self.schema_location,
2584 annotation: self.annotation,
2585 })
2586 }
2587 }
2588 #[derive(Debug)]
2589 pub struct ImportDeserializer {
2590 id: Option<String>,
2591 namespace: Option<String>,
2592 schema_location: Option<String>,
2593 annotation: Option<super::Annotation>,
2594 state: Box<ImportDeserializerState>,
2595 }
2596 #[derive(Debug)]
2597 enum ImportDeserializerState {
2598 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
2599 Done__,
2600 }
2601 impl ImportDeserializer {
2602 fn from_bytes_start<R>(
2603 reader: &R,
2604 bytes_start: &crate::quick_xml::BytesStart<'_>,
2605 ) -> Result<Self, crate::quick_xml::Error>
2606 where
2607 R: crate::quick_xml::XmlReader,
2608 {
2609 use crate::quick_xml::ErrorKind;
2610 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
2611 let mut id: Option<String> = None;
2612 let mut namespace: Option<String> = None;
2613 let mut schema_location: Option<String> = None;
2614 for attrib in bytes_start.attributes() {
2615 let attrib = attrib?;
2616 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
2617 continue;
2618 }
2619 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
2620 reader.read_attrib(&mut id, b"id", &attrib.value)?;
2621 } else if matches!(
2622 reader.resolve_local_name(attrib.key, NS_XS),
2623 Some(b"namespace")
2624 ) {
2625 reader.read_attrib(&mut namespace, b"namespace", &attrib.value)?;
2626 } else if matches!(
2627 reader.resolve_local_name(attrib.key, NS_XS),
2628 Some(b"schemaLocation")
2629 ) {
2630 reader.read_attrib(&mut schema_location, b"schemaLocation", &attrib.value)?;
2631 }
2632 }
2633 Ok(Self {
2634 id: id,
2635 namespace: namespace,
2636 schema_location: schema_location,
2637 annotation: None,
2638 state: Box::new(ImportDeserializerState::Annotation(None)),
2639 })
2640 }
2641 }
2642 impl<'de> crate::quick_xml::Deserializer<'de, super::Import> for ImportDeserializer {
2643 fn init<R>(
2644 reader: &R,
2645 event: crate::quick_xml::Event<'de>,
2646 ) -> crate::quick_xml::DeserializerResult<'de, super::Import, Self>
2647 where
2648 R: crate::quick_xml::XmlReader,
2649 {
2650 use crate::quick_xml::{DeserializerOutput, Event};
2651 match event {
2652 Event::Start(start) => {
2653 let deserializer = Self::from_bytes_start(reader, &start)?;
2654 Ok(DeserializerOutput {
2655 data: None,
2656 deserializer: Some(deserializer),
2657 event: None,
2658 allow_any: false,
2659 })
2660 }
2661 Event::Empty(start) => {
2662 let deserializer = Self::from_bytes_start(reader, &start)?;
2663 let data = deserializer.finish(reader)?;
2664 Ok(DeserializerOutput {
2665 data: Some(data),
2666 deserializer: None,
2667 event: None,
2668 allow_any: false,
2669 })
2670 }
2671 event => Ok(DeserializerOutput {
2672 data: None,
2673 deserializer: None,
2674 event: Some(event),
2675 allow_any: false,
2676 }),
2677 }
2678 }
2679 fn next<R>(
2680 mut self,
2681 reader: &R,
2682 event: crate::quick_xml::Event<'de>,
2683 ) -> crate::quick_xml::DeserializerResult<'de, super::Import, Self>
2684 where
2685 R: crate::quick_xml::XmlReader,
2686 {
2687 use crate::quick_xml::{
2688 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
2689 };
2690 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
2691 let mut event = event;
2692 let mut allow_any_fallback = None;
2693 loop {
2694 event = match (
2695 core::mem::replace(&mut *self.state, ImportDeserializerState::Done__),
2696 event,
2697 ) {
2698 (ImportDeserializerState::Annotation(Some(deserializer)), event) => {
2699 let DeserializerOutput {
2700 data,
2701 deserializer,
2702 event,
2703 allow_any,
2704 } = deserializer.next(reader, event)?;
2705 if let Some(data) = data {
2706 if self.annotation.is_some() {
2707 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
2708 b"annotation",
2709 )))?;
2710 }
2711 self.annotation = Some(data);
2712 }
2713 let event = match event {
2714 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
2715 event
2716 }
2717 event => {
2718 *self.state = ImportDeserializerState::Annotation(deserializer);
2719 return Ok(DeserializerOutput {
2720 data: None,
2721 deserializer: Some(self),
2722 event: event,
2723 allow_any: false,
2724 });
2725 }
2726 };
2727 if allow_any {
2728 allow_any_fallback
2729 .get_or_insert(ImportDeserializerState::Annotation(deserializer));
2730 } else if let Some(deserializer) = deserializer {
2731 let data = deserializer.finish(reader)?;
2732 if self.annotation.is_some() {
2733 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
2734 b"annotation",
2735 )))?;
2736 }
2737 self.annotation = Some(data);
2738 }
2739 *self.state = ImportDeserializerState::Annotation(None);
2740 event
2741 }
2742 (ImportDeserializerState::Annotation(None), event) => match &event {
2743 Event::Start(x) | Event::Empty(x)
2744 if matches!(
2745 reader.resolve_local_name(x.name(), NS_XS),
2746 Some(b"annotation")
2747 ) =>
2748 {
2749 let DeserializerOutput {
2750 data,
2751 deserializer,
2752 event,
2753 allow_any,
2754 } = <Annotation as WithDeserializer>::Deserializer::init(
2755 reader, event,
2756 )?;
2757 if let Some(data) = data {
2758 if self.annotation.is_some() {
2759 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
2760 b"annotation",
2761 )))?;
2762 }
2763 self.annotation = Some(data);
2764 }
2765 *self.state = ImportDeserializerState::Annotation(deserializer);
2766 match event {
2767 Some(event @ (Event::Start(_) | Event::End(_))) => {
2768 *self.state = ImportDeserializerState::Done__;
2769 if allow_any {
2770 allow_any_fallback.get_or_insert(
2771 ImportDeserializerState::Annotation(None),
2772 );
2773 }
2774 event
2775 }
2776 event @ (None | Some(_)) => {
2777 return Ok(DeserializerOutput {
2778 data: None,
2779 deserializer: Some(self),
2780 event,
2781 allow_any: false,
2782 })
2783 }
2784 }
2785 }
2786 Event::Start(_) | Event::Empty(_) => {
2787 *self.state = ImportDeserializerState::Done__;
2788 allow_any_fallback
2789 .get_or_insert(ImportDeserializerState::Annotation(None));
2790 event
2791 }
2792 Event::End(_) => {
2793 let data = self.finish(reader)?;
2794 return Ok(DeserializerOutput {
2795 data: Some(data),
2796 deserializer: None,
2797 event: None,
2798 allow_any: false,
2799 });
2800 }
2801 _ => {
2802 *self.state = ImportDeserializerState::Annotation(None);
2803 return Ok(DeserializerOutput {
2804 data: None,
2805 deserializer: Some(self),
2806 event: Some(event),
2807 allow_any: false,
2808 });
2809 }
2810 },
2811 (ImportDeserializerState::Done__, event) => {
2812 let allow_any = if let Some(fallback) = allow_any_fallback {
2813 *self.state = fallback;
2814 true
2815 } else {
2816 false
2817 };
2818 return Ok(DeserializerOutput {
2819 data: None,
2820 deserializer: Some(self),
2821 event: Some(event),
2822 allow_any,
2823 });
2824 }
2825 }
2826 }
2827 }
2828 fn finish<R>(self, _reader: &R) -> Result<super::Import, crate::quick_xml::Error>
2829 where
2830 R: crate::quick_xml::XmlReader,
2831 {
2832 use crate::quick_xml::ErrorKind;
2833 Ok(super::Import {
2834 id: self.id,
2835 namespace: self.namespace,
2836 schema_location: self.schema_location,
2837 annotation: self.annotation,
2838 })
2839 }
2840 }
2841 #[derive(Debug)]
2842 pub struct RedefineDeserializer {
2843 schema_location: String,
2844 id: Option<String>,
2845 content: Vec<super::RedefineContent>,
2846 state: Box<RedefineDeserializerState>,
2847 }
2848 #[derive(Debug)]
2849 enum RedefineDeserializerState {
2850 Next__,
2851 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
2852 SimpleType(<SimpleBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
2853 ComplexType(<ComplexBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
2854 Group(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
2855 AttributeGroup(<AttributeGroupType as crate::quick_xml::WithDeserializer>::Deserializer),
2856 }
2857 impl RedefineDeserializer {
2858 fn from_bytes_start<R>(
2859 reader: &R,
2860 bytes_start: &crate::quick_xml::BytesStart<'_>,
2861 ) -> Result<Self, crate::quick_xml::Error>
2862 where
2863 R: crate::quick_xml::XmlReader,
2864 {
2865 use crate::quick_xml::ErrorKind;
2866 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
2867 let mut schema_location: Option<String> = None;
2868 let mut id: Option<String> = None;
2869 for attrib in bytes_start.attributes() {
2870 let attrib = attrib?;
2871 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
2872 continue;
2873 }
2874 if matches!(
2875 reader.resolve_local_name(attrib.key, NS_XS),
2876 Some(b"schemaLocation")
2877 ) {
2878 reader.read_attrib(&mut schema_location, b"schemaLocation", &attrib.value)?;
2879 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
2880 reader.read_attrib(&mut id, b"id", &attrib.value)?;
2881 }
2882 }
2883 Ok(Self {
2884 schema_location: schema_location
2885 .ok_or(ErrorKind::MissingAttribute("schemaLocation".into()))?,
2886 id: id,
2887 content: Vec::new(),
2888 state: Box::new(RedefineDeserializerState::Next__),
2889 })
2890 }
2891 }
2892 impl<'de> crate::quick_xml::Deserializer<'de, super::Redefine> for RedefineDeserializer {
2893 fn init<R>(
2894 reader: &R,
2895 event: crate::quick_xml::Event<'de>,
2896 ) -> crate::quick_xml::DeserializerResult<'de, super::Redefine, Self>
2897 where
2898 R: crate::quick_xml::XmlReader,
2899 {
2900 use crate::quick_xml::{DeserializerOutput, Event};
2901 match event {
2902 Event::Start(start) => {
2903 let deserializer = Self::from_bytes_start(reader, &start)?;
2904 Ok(DeserializerOutput {
2905 data: None,
2906 deserializer: Some(deserializer),
2907 event: None,
2908 allow_any: false,
2909 })
2910 }
2911 Event::Empty(start) => {
2912 let deserializer = Self::from_bytes_start(reader, &start)?;
2913 let data = deserializer.finish(reader)?;
2914 Ok(DeserializerOutput {
2915 data: Some(data),
2916 deserializer: None,
2917 event: None,
2918 allow_any: false,
2919 })
2920 }
2921 event => Ok(DeserializerOutput {
2922 data: None,
2923 deserializer: None,
2924 event: Some(event),
2925 allow_any: false,
2926 }),
2927 }
2928 }
2929 fn next<R>(
2930 mut self,
2931 reader: &R,
2932 event: crate::quick_xml::Event<'de>,
2933 ) -> crate::quick_xml::DeserializerResult<'de, super::Redefine, Self>
2934 where
2935 R: crate::quick_xml::XmlReader,
2936 {
2937 use crate::quick_xml::{
2938 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
2939 };
2940 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
2941 match (
2942 core::mem::replace(&mut *self.state, RedefineDeserializerState::Next__),
2943 &event,
2944 ) {
2945 (RedefineDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
2946 if matches!(
2947 reader.resolve_local_name(x.name(), NS_XS),
2948 Some(b"annotation")
2949 ) {
2950 let DeserializerOutput {
2951 data,
2952 deserializer,
2953 event,
2954 allow_any,
2955 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
2956 if let Some(data) = data {
2957 self.content.push(RedefineContent::Annotation(data));
2958 }
2959 if let Some(deserializer) = deserializer {
2960 *self.state = RedefineDeserializerState::Annotation(deserializer);
2961 }
2962 Ok(DeserializerOutput {
2963 data: None,
2964 deserializer: Some(self),
2965 event,
2966 allow_any,
2967 })
2968 } else if matches!(
2969 reader.resolve_local_name(x.name(), NS_XS),
2970 Some(b"simpleType")
2971 ) {
2972 let DeserializerOutput {
2973 data,
2974 deserializer,
2975 event,
2976 allow_any,
2977 } = <SimpleBaseType as WithDeserializer>::Deserializer::init(
2978 reader, event,
2979 )?;
2980 if let Some(data) = data {
2981 self.content.push(RedefineContent::SimpleType(data));
2982 }
2983 if let Some(deserializer) = deserializer {
2984 *self.state = RedefineDeserializerState::SimpleType(deserializer);
2985 }
2986 Ok(DeserializerOutput {
2987 data: None,
2988 deserializer: Some(self),
2989 event,
2990 allow_any,
2991 })
2992 } else if matches!(
2993 reader.resolve_local_name(x.name(), NS_XS),
2994 Some(b"complexType")
2995 ) {
2996 let DeserializerOutput {
2997 data,
2998 deserializer,
2999 event,
3000 allow_any,
3001 } = <ComplexBaseType as WithDeserializer>::Deserializer::init(
3002 reader, event,
3003 )?;
3004 if let Some(data) = data {
3005 self.content.push(RedefineContent::ComplexType(data));
3006 }
3007 if let Some(deserializer) = deserializer {
3008 *self.state = RedefineDeserializerState::ComplexType(deserializer);
3009 }
3010 Ok(DeserializerOutput {
3011 data: None,
3012 deserializer: Some(self),
3013 event,
3014 allow_any,
3015 })
3016 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"group")) {
3017 let DeserializerOutput {
3018 data,
3019 deserializer,
3020 event,
3021 allow_any,
3022 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
3023 if let Some(data) = data {
3024 self.content.push(RedefineContent::Group(data));
3025 }
3026 if let Some(deserializer) = deserializer {
3027 *self.state = RedefineDeserializerState::Group(deserializer);
3028 }
3029 Ok(DeserializerOutput {
3030 data: None,
3031 deserializer: Some(self),
3032 event,
3033 allow_any,
3034 })
3035 } else if matches!(
3036 reader.resolve_local_name(x.name(), NS_XS),
3037 Some(b"attributeGroup")
3038 ) {
3039 let DeserializerOutput {
3040 data,
3041 deserializer,
3042 event,
3043 allow_any,
3044 } = <AttributeGroupType as WithDeserializer>::Deserializer::init(
3045 reader, event,
3046 )?;
3047 if let Some(data) = data {
3048 self.content.push(RedefineContent::AttributeGroup(data));
3049 }
3050 if let Some(deserializer) = deserializer {
3051 *self.state = RedefineDeserializerState::AttributeGroup(deserializer);
3052 }
3053 Ok(DeserializerOutput {
3054 data: None,
3055 deserializer: Some(self),
3056 event,
3057 allow_any,
3058 })
3059 } else {
3060 Ok(DeserializerOutput {
3061 data: None,
3062 deserializer: Some(self),
3063 event: Some(event),
3064 allow_any: false,
3065 })
3066 }
3067 }
3068 (RedefineDeserializerState::Next__, Event::End(_)) => {
3069 let data = self.finish(reader)?;
3070 Ok(DeserializerOutput {
3071 data: Some(data),
3072 deserializer: None,
3073 event: None,
3074 allow_any: false,
3075 })
3076 }
3077 (RedefineDeserializerState::Next__, _) => Ok(DeserializerOutput {
3078 data: None,
3079 deserializer: Some(self),
3080 event: None,
3081 allow_any: false,
3082 }),
3083 (RedefineDeserializerState::Annotation(deserializer), _) => {
3084 let DeserializerOutput {
3085 data,
3086 deserializer,
3087 event,
3088 allow_any,
3089 } = deserializer.next(reader, event)?;
3090 if let Some(data) = data {
3091 self.content.push(RedefineContent::Annotation(data));
3092 }
3093 if let Some(deserializer) = deserializer {
3094 *self.state = RedefineDeserializerState::Annotation(deserializer);
3095 }
3096 Ok(DeserializerOutput {
3097 data: None,
3098 deserializer: Some(self),
3099 event,
3100 allow_any,
3101 })
3102 }
3103 (RedefineDeserializerState::SimpleType(deserializer), _) => {
3104 let DeserializerOutput {
3105 data,
3106 deserializer,
3107 event,
3108 allow_any,
3109 } = deserializer.next(reader, event)?;
3110 if let Some(data) = data {
3111 self.content.push(RedefineContent::SimpleType(data));
3112 }
3113 if let Some(deserializer) = deserializer {
3114 *self.state = RedefineDeserializerState::SimpleType(deserializer);
3115 }
3116 Ok(DeserializerOutput {
3117 data: None,
3118 deserializer: Some(self),
3119 event,
3120 allow_any,
3121 })
3122 }
3123 (RedefineDeserializerState::ComplexType(deserializer), _) => {
3124 let DeserializerOutput {
3125 data,
3126 deserializer,
3127 event,
3128 allow_any,
3129 } = deserializer.next(reader, event)?;
3130 if let Some(data) = data {
3131 self.content.push(RedefineContent::ComplexType(data));
3132 }
3133 if let Some(deserializer) = deserializer {
3134 *self.state = RedefineDeserializerState::ComplexType(deserializer);
3135 }
3136 Ok(DeserializerOutput {
3137 data: None,
3138 deserializer: Some(self),
3139 event,
3140 allow_any,
3141 })
3142 }
3143 (RedefineDeserializerState::Group(deserializer), _) => {
3144 let DeserializerOutput {
3145 data,
3146 deserializer,
3147 event,
3148 allow_any,
3149 } = deserializer.next(reader, event)?;
3150 if let Some(data) = data {
3151 self.content.push(RedefineContent::Group(data));
3152 }
3153 if let Some(deserializer) = deserializer {
3154 *self.state = RedefineDeserializerState::Group(deserializer);
3155 }
3156 Ok(DeserializerOutput {
3157 data: None,
3158 deserializer: Some(self),
3159 event,
3160 allow_any,
3161 })
3162 }
3163 (RedefineDeserializerState::AttributeGroup(deserializer), _) => {
3164 let DeserializerOutput {
3165 data,
3166 deserializer,
3167 event,
3168 allow_any,
3169 } = deserializer.next(reader, event)?;
3170 if let Some(data) = data {
3171 self.content.push(RedefineContent::AttributeGroup(data));
3172 }
3173 if let Some(deserializer) = deserializer {
3174 *self.state = RedefineDeserializerState::AttributeGroup(deserializer);
3175 }
3176 Ok(DeserializerOutput {
3177 data: None,
3178 deserializer: Some(self),
3179 event,
3180 allow_any,
3181 })
3182 }
3183 }
3184 }
3185 fn finish<R>(self, _reader: &R) -> Result<super::Redefine, crate::quick_xml::Error>
3186 where
3187 R: crate::quick_xml::XmlReader,
3188 {
3189 use crate::quick_xml::ErrorKind;
3190 Ok(super::Redefine {
3191 schema_location: self.schema_location,
3192 id: self.id,
3193 content: self.content,
3194 })
3195 }
3196 }
3197 #[derive(Debug)]
3198 pub struct OverrideDeserializer {
3199 schema_location: String,
3200 id: Option<String>,
3201 content: Vec<super::OverrideContent>,
3202 state: Box<OverrideDeserializerState>,
3203 }
3204 #[derive(Debug)]
3205 enum OverrideDeserializerState {
3206 Next__,
3207 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
3208 SimpleType(<SimpleBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
3209 ComplexType(<ComplexBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
3210 Group(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
3211 AttributeGroup(<AttributeGroupType as crate::quick_xml::WithDeserializer>::Deserializer),
3212 Element(<ElementType as crate::quick_xml::WithDeserializer>::Deserializer),
3213 Attribute(<AttributeType as crate::quick_xml::WithDeserializer>::Deserializer),
3214 Notation(<Notation as crate::quick_xml::WithDeserializer>::Deserializer),
3215 }
3216 impl OverrideDeserializer {
3217 fn from_bytes_start<R>(
3218 reader: &R,
3219 bytes_start: &crate::quick_xml::BytesStart<'_>,
3220 ) -> Result<Self, crate::quick_xml::Error>
3221 where
3222 R: crate::quick_xml::XmlReader,
3223 {
3224 use crate::quick_xml::ErrorKind;
3225 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
3226 let mut schema_location: Option<String> = None;
3227 let mut id: Option<String> = None;
3228 for attrib in bytes_start.attributes() {
3229 let attrib = attrib?;
3230 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
3231 continue;
3232 }
3233 if matches!(
3234 reader.resolve_local_name(attrib.key, NS_XS),
3235 Some(b"schemaLocation")
3236 ) {
3237 reader.read_attrib(&mut schema_location, b"schemaLocation", &attrib.value)?;
3238 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
3239 reader.read_attrib(&mut id, b"id", &attrib.value)?;
3240 }
3241 }
3242 Ok(Self {
3243 schema_location: schema_location
3244 .ok_or(ErrorKind::MissingAttribute("schemaLocation".into()))?,
3245 id: id,
3246 content: Vec::new(),
3247 state: Box::new(OverrideDeserializerState::Next__),
3248 })
3249 }
3250 }
3251 impl<'de> crate::quick_xml::Deserializer<'de, super::Override> for OverrideDeserializer {
3252 fn init<R>(
3253 reader: &R,
3254 event: crate::quick_xml::Event<'de>,
3255 ) -> crate::quick_xml::DeserializerResult<'de, super::Override, Self>
3256 where
3257 R: crate::quick_xml::XmlReader,
3258 {
3259 use crate::quick_xml::{DeserializerOutput, Event};
3260 match event {
3261 Event::Start(start) => {
3262 let deserializer = Self::from_bytes_start(reader, &start)?;
3263 Ok(DeserializerOutput {
3264 data: None,
3265 deserializer: Some(deserializer),
3266 event: None,
3267 allow_any: false,
3268 })
3269 }
3270 Event::Empty(start) => {
3271 let deserializer = Self::from_bytes_start(reader, &start)?;
3272 let data = deserializer.finish(reader)?;
3273 Ok(DeserializerOutput {
3274 data: Some(data),
3275 deserializer: None,
3276 event: None,
3277 allow_any: false,
3278 })
3279 }
3280 event => Ok(DeserializerOutput {
3281 data: None,
3282 deserializer: None,
3283 event: Some(event),
3284 allow_any: false,
3285 }),
3286 }
3287 }
3288 fn next<R>(
3289 mut self,
3290 reader: &R,
3291 event: crate::quick_xml::Event<'de>,
3292 ) -> crate::quick_xml::DeserializerResult<'de, super::Override, Self>
3293 where
3294 R: crate::quick_xml::XmlReader,
3295 {
3296 use crate::quick_xml::{
3297 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
3298 };
3299 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
3300 match (
3301 core::mem::replace(&mut *self.state, OverrideDeserializerState::Next__),
3302 &event,
3303 ) {
3304 (OverrideDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
3305 if matches!(
3306 reader.resolve_local_name(x.name(), NS_XS),
3307 Some(b"annotation")
3308 ) {
3309 let DeserializerOutput {
3310 data,
3311 deserializer,
3312 event,
3313 allow_any,
3314 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
3315 if let Some(data) = data {
3316 self.content.push(OverrideContent::Annotation(data));
3317 }
3318 if let Some(deserializer) = deserializer {
3319 *self.state = OverrideDeserializerState::Annotation(deserializer);
3320 }
3321 Ok(DeserializerOutput {
3322 data: None,
3323 deserializer: Some(self),
3324 event,
3325 allow_any,
3326 })
3327 } else if matches!(
3328 reader.resolve_local_name(x.name(), NS_XS),
3329 Some(b"simpleType")
3330 ) {
3331 let DeserializerOutput {
3332 data,
3333 deserializer,
3334 event,
3335 allow_any,
3336 } = <SimpleBaseType as WithDeserializer>::Deserializer::init(
3337 reader, event,
3338 )?;
3339 if let Some(data) = data {
3340 self.content.push(OverrideContent::SimpleType(data));
3341 }
3342 if let Some(deserializer) = deserializer {
3343 *self.state = OverrideDeserializerState::SimpleType(deserializer);
3344 }
3345 Ok(DeserializerOutput {
3346 data: None,
3347 deserializer: Some(self),
3348 event,
3349 allow_any,
3350 })
3351 } else if matches!(
3352 reader.resolve_local_name(x.name(), NS_XS),
3353 Some(b"complexType")
3354 ) {
3355 let DeserializerOutput {
3356 data,
3357 deserializer,
3358 event,
3359 allow_any,
3360 } = <ComplexBaseType as WithDeserializer>::Deserializer::init(
3361 reader, event,
3362 )?;
3363 if let Some(data) = data {
3364 self.content.push(OverrideContent::ComplexType(data));
3365 }
3366 if let Some(deserializer) = deserializer {
3367 *self.state = OverrideDeserializerState::ComplexType(deserializer);
3368 }
3369 Ok(DeserializerOutput {
3370 data: None,
3371 deserializer: Some(self),
3372 event,
3373 allow_any,
3374 })
3375 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"group")) {
3376 let DeserializerOutput {
3377 data,
3378 deserializer,
3379 event,
3380 allow_any,
3381 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
3382 if let Some(data) = data {
3383 self.content.push(OverrideContent::Group(data));
3384 }
3385 if let Some(deserializer) = deserializer {
3386 *self.state = OverrideDeserializerState::Group(deserializer);
3387 }
3388 Ok(DeserializerOutput {
3389 data: None,
3390 deserializer: Some(self),
3391 event,
3392 allow_any,
3393 })
3394 } else if matches!(
3395 reader.resolve_local_name(x.name(), NS_XS),
3396 Some(b"attributeGroup")
3397 ) {
3398 let DeserializerOutput {
3399 data,
3400 deserializer,
3401 event,
3402 allow_any,
3403 } = <AttributeGroupType as WithDeserializer>::Deserializer::init(
3404 reader, event,
3405 )?;
3406 if let Some(data) = data {
3407 self.content.push(OverrideContent::AttributeGroup(data));
3408 }
3409 if let Some(deserializer) = deserializer {
3410 *self.state = OverrideDeserializerState::AttributeGroup(deserializer);
3411 }
3412 Ok(DeserializerOutput {
3413 data: None,
3414 deserializer: Some(self),
3415 event,
3416 allow_any,
3417 })
3418 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"element"))
3419 {
3420 let DeserializerOutput {
3421 data,
3422 deserializer,
3423 event,
3424 allow_any,
3425 } = <ElementType as WithDeserializer>::Deserializer::init(reader, event)?;
3426 if let Some(data) = data {
3427 self.content.push(OverrideContent::Element(data));
3428 }
3429 if let Some(deserializer) = deserializer {
3430 *self.state = OverrideDeserializerState::Element(deserializer);
3431 }
3432 Ok(DeserializerOutput {
3433 data: None,
3434 deserializer: Some(self),
3435 event,
3436 allow_any,
3437 })
3438 } else if matches!(
3439 reader.resolve_local_name(x.name(), NS_XS),
3440 Some(b"attribute")
3441 ) {
3442 let DeserializerOutput {
3443 data,
3444 deserializer,
3445 event,
3446 allow_any,
3447 } = <AttributeType as WithDeserializer>::Deserializer::init(reader, event)?;
3448 if let Some(data) = data {
3449 self.content.push(OverrideContent::Attribute(data));
3450 }
3451 if let Some(deserializer) = deserializer {
3452 *self.state = OverrideDeserializerState::Attribute(deserializer);
3453 }
3454 Ok(DeserializerOutput {
3455 data: None,
3456 deserializer: Some(self),
3457 event,
3458 allow_any,
3459 })
3460 } else if matches!(
3461 reader.resolve_local_name(x.name(), NS_XS),
3462 Some(b"notation")
3463 ) {
3464 let DeserializerOutput {
3465 data,
3466 deserializer,
3467 event,
3468 allow_any,
3469 } = <Notation as WithDeserializer>::Deserializer::init(reader, event)?;
3470 if let Some(data) = data {
3471 self.content.push(OverrideContent::Notation(data));
3472 }
3473 if let Some(deserializer) = deserializer {
3474 *self.state = OverrideDeserializerState::Notation(deserializer);
3475 }
3476 Ok(DeserializerOutput {
3477 data: None,
3478 deserializer: Some(self),
3479 event,
3480 allow_any,
3481 })
3482 } else {
3483 Ok(DeserializerOutput {
3484 data: None,
3485 deserializer: Some(self),
3486 event: Some(event),
3487 allow_any: false,
3488 })
3489 }
3490 }
3491 (OverrideDeserializerState::Next__, Event::End(_)) => {
3492 let data = self.finish(reader)?;
3493 Ok(DeserializerOutput {
3494 data: Some(data),
3495 deserializer: None,
3496 event: None,
3497 allow_any: false,
3498 })
3499 }
3500 (OverrideDeserializerState::Next__, _) => Ok(DeserializerOutput {
3501 data: None,
3502 deserializer: Some(self),
3503 event: None,
3504 allow_any: false,
3505 }),
3506 (OverrideDeserializerState::Annotation(deserializer), _) => {
3507 let DeserializerOutput {
3508 data,
3509 deserializer,
3510 event,
3511 allow_any,
3512 } = deserializer.next(reader, event)?;
3513 if let Some(data) = data {
3514 self.content.push(OverrideContent::Annotation(data));
3515 }
3516 if let Some(deserializer) = deserializer {
3517 *self.state = OverrideDeserializerState::Annotation(deserializer);
3518 }
3519 Ok(DeserializerOutput {
3520 data: None,
3521 deserializer: Some(self),
3522 event,
3523 allow_any,
3524 })
3525 }
3526 (OverrideDeserializerState::SimpleType(deserializer), _) => {
3527 let DeserializerOutput {
3528 data,
3529 deserializer,
3530 event,
3531 allow_any,
3532 } = deserializer.next(reader, event)?;
3533 if let Some(data) = data {
3534 self.content.push(OverrideContent::SimpleType(data));
3535 }
3536 if let Some(deserializer) = deserializer {
3537 *self.state = OverrideDeserializerState::SimpleType(deserializer);
3538 }
3539 Ok(DeserializerOutput {
3540 data: None,
3541 deserializer: Some(self),
3542 event,
3543 allow_any,
3544 })
3545 }
3546 (OverrideDeserializerState::ComplexType(deserializer), _) => {
3547 let DeserializerOutput {
3548 data,
3549 deserializer,
3550 event,
3551 allow_any,
3552 } = deserializer.next(reader, event)?;
3553 if let Some(data) = data {
3554 self.content.push(OverrideContent::ComplexType(data));
3555 }
3556 if let Some(deserializer) = deserializer {
3557 *self.state = OverrideDeserializerState::ComplexType(deserializer);
3558 }
3559 Ok(DeserializerOutput {
3560 data: None,
3561 deserializer: Some(self),
3562 event,
3563 allow_any,
3564 })
3565 }
3566 (OverrideDeserializerState::Group(deserializer), _) => {
3567 let DeserializerOutput {
3568 data,
3569 deserializer,
3570 event,
3571 allow_any,
3572 } = deserializer.next(reader, event)?;
3573 if let Some(data) = data {
3574 self.content.push(OverrideContent::Group(data));
3575 }
3576 if let Some(deserializer) = deserializer {
3577 *self.state = OverrideDeserializerState::Group(deserializer);
3578 }
3579 Ok(DeserializerOutput {
3580 data: None,
3581 deserializer: Some(self),
3582 event,
3583 allow_any,
3584 })
3585 }
3586 (OverrideDeserializerState::AttributeGroup(deserializer), _) => {
3587 let DeserializerOutput {
3588 data,
3589 deserializer,
3590 event,
3591 allow_any,
3592 } = deserializer.next(reader, event)?;
3593 if let Some(data) = data {
3594 self.content.push(OverrideContent::AttributeGroup(data));
3595 }
3596 if let Some(deserializer) = deserializer {
3597 *self.state = OverrideDeserializerState::AttributeGroup(deserializer);
3598 }
3599 Ok(DeserializerOutput {
3600 data: None,
3601 deserializer: Some(self),
3602 event,
3603 allow_any,
3604 })
3605 }
3606 (OverrideDeserializerState::Element(deserializer), _) => {
3607 let DeserializerOutput {
3608 data,
3609 deserializer,
3610 event,
3611 allow_any,
3612 } = deserializer.next(reader, event)?;
3613 if let Some(data) = data {
3614 self.content.push(OverrideContent::Element(data));
3615 }
3616 if let Some(deserializer) = deserializer {
3617 *self.state = OverrideDeserializerState::Element(deserializer);
3618 }
3619 Ok(DeserializerOutput {
3620 data: None,
3621 deserializer: Some(self),
3622 event,
3623 allow_any,
3624 })
3625 }
3626 (OverrideDeserializerState::Attribute(deserializer), _) => {
3627 let DeserializerOutput {
3628 data,
3629 deserializer,
3630 event,
3631 allow_any,
3632 } = deserializer.next(reader, event)?;
3633 if let Some(data) = data {
3634 self.content.push(OverrideContent::Attribute(data));
3635 }
3636 if let Some(deserializer) = deserializer {
3637 *self.state = OverrideDeserializerState::Attribute(deserializer);
3638 }
3639 Ok(DeserializerOutput {
3640 data: None,
3641 deserializer: Some(self),
3642 event,
3643 allow_any,
3644 })
3645 }
3646 (OverrideDeserializerState::Notation(deserializer), _) => {
3647 let DeserializerOutput {
3648 data,
3649 deserializer,
3650 event,
3651 allow_any,
3652 } = deserializer.next(reader, event)?;
3653 if let Some(data) = data {
3654 self.content.push(OverrideContent::Notation(data));
3655 }
3656 if let Some(deserializer) = deserializer {
3657 *self.state = OverrideDeserializerState::Notation(deserializer);
3658 }
3659 Ok(DeserializerOutput {
3660 data: None,
3661 deserializer: Some(self),
3662 event,
3663 allow_any,
3664 })
3665 }
3666 }
3667 }
3668 fn finish<R>(self, _reader: &R) -> Result<super::Override, crate::quick_xml::Error>
3669 where
3670 R: crate::quick_xml::XmlReader,
3671 {
3672 use crate::quick_xml::ErrorKind;
3673 Ok(super::Override {
3674 schema_location: self.schema_location,
3675 id: self.id,
3676 content: self.content,
3677 })
3678 }
3679 }
3680 #[derive(Debug)]
3681 pub struct AnnotationDeserializer {
3682 id: Option<String>,
3683 content: Vec<super::AnnotationContent>,
3684 state: Box<AnnotationDeserializerState>,
3685 }
3686 #[derive(Debug)]
3687 enum AnnotationDeserializerState {
3688 Next__,
3689 Appinfo(<Appinfo as crate::quick_xml::WithDeserializer>::Deserializer),
3690 Documentation(<Documentation as crate::quick_xml::WithDeserializer>::Deserializer),
3691 }
3692 impl AnnotationDeserializer {
3693 fn from_bytes_start<R>(
3694 reader: &R,
3695 bytes_start: &crate::quick_xml::BytesStart<'_>,
3696 ) -> Result<Self, crate::quick_xml::Error>
3697 where
3698 R: crate::quick_xml::XmlReader,
3699 {
3700 use crate::quick_xml::ErrorKind;
3701 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
3702 let mut id: Option<String> = None;
3703 for attrib in bytes_start.attributes() {
3704 let attrib = attrib?;
3705 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
3706 continue;
3707 }
3708 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
3709 reader.read_attrib(&mut id, b"id", &attrib.value)?;
3710 }
3711 }
3712 Ok(Self {
3713 id: id,
3714 content: Vec::new(),
3715 state: Box::new(AnnotationDeserializerState::Next__),
3716 })
3717 }
3718 }
3719 impl<'de> crate::quick_xml::Deserializer<'de, super::Annotation> for AnnotationDeserializer {
3720 fn init<R>(
3721 reader: &R,
3722 event: crate::quick_xml::Event<'de>,
3723 ) -> crate::quick_xml::DeserializerResult<'de, super::Annotation, Self>
3724 where
3725 R: crate::quick_xml::XmlReader,
3726 {
3727 use crate::quick_xml::{DeserializerOutput, Event};
3728 match event {
3729 Event::Start(start) => {
3730 let deserializer = Self::from_bytes_start(reader, &start)?;
3731 Ok(DeserializerOutput {
3732 data: None,
3733 deserializer: Some(deserializer),
3734 event: None,
3735 allow_any: false,
3736 })
3737 }
3738 Event::Empty(start) => {
3739 let deserializer = Self::from_bytes_start(reader, &start)?;
3740 let data = deserializer.finish(reader)?;
3741 Ok(DeserializerOutput {
3742 data: Some(data),
3743 deserializer: None,
3744 event: None,
3745 allow_any: false,
3746 })
3747 }
3748 event => Ok(DeserializerOutput {
3749 data: None,
3750 deserializer: None,
3751 event: Some(event),
3752 allow_any: false,
3753 }),
3754 }
3755 }
3756 fn next<R>(
3757 mut self,
3758 reader: &R,
3759 event: crate::quick_xml::Event<'de>,
3760 ) -> crate::quick_xml::DeserializerResult<'de, super::Annotation, Self>
3761 where
3762 R: crate::quick_xml::XmlReader,
3763 {
3764 use crate::quick_xml::{
3765 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
3766 };
3767 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
3768 match (
3769 core::mem::replace(&mut *self.state, AnnotationDeserializerState::Next__),
3770 &event,
3771 ) {
3772 (AnnotationDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
3773 if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"appinfo")) {
3774 let DeserializerOutput {
3775 data,
3776 deserializer,
3777 event,
3778 allow_any,
3779 } = <Appinfo as WithDeserializer>::Deserializer::init(reader, event)?;
3780 if let Some(data) = data {
3781 self.content.push(AnnotationContent::Appinfo(data));
3782 }
3783 if let Some(deserializer) = deserializer {
3784 *self.state = AnnotationDeserializerState::Appinfo(deserializer);
3785 }
3786 Ok(DeserializerOutput {
3787 data: None,
3788 deserializer: Some(self),
3789 event,
3790 allow_any,
3791 })
3792 } else if matches!(
3793 reader.resolve_local_name(x.name(), NS_XS),
3794 Some(b"documentation")
3795 ) {
3796 let DeserializerOutput {
3797 data,
3798 deserializer,
3799 event,
3800 allow_any,
3801 } = <Documentation as WithDeserializer>::Deserializer::init(reader, event)?;
3802 if let Some(data) = data {
3803 self.content.push(AnnotationContent::Documentation(data));
3804 }
3805 if let Some(deserializer) = deserializer {
3806 *self.state = AnnotationDeserializerState::Documentation(deserializer);
3807 }
3808 Ok(DeserializerOutput {
3809 data: None,
3810 deserializer: Some(self),
3811 event,
3812 allow_any,
3813 })
3814 } else {
3815 Ok(DeserializerOutput {
3816 data: None,
3817 deserializer: Some(self),
3818 event: Some(event),
3819 allow_any: false,
3820 })
3821 }
3822 }
3823 (AnnotationDeserializerState::Next__, Event::End(_)) => {
3824 let data = self.finish(reader)?;
3825 Ok(DeserializerOutput {
3826 data: Some(data),
3827 deserializer: None,
3828 event: None,
3829 allow_any: false,
3830 })
3831 }
3832 (AnnotationDeserializerState::Next__, _) => Ok(DeserializerOutput {
3833 data: None,
3834 deserializer: Some(self),
3835 event: None,
3836 allow_any: false,
3837 }),
3838 (AnnotationDeserializerState::Appinfo(deserializer), _) => {
3839 let DeserializerOutput {
3840 data,
3841 deserializer,
3842 event,
3843 allow_any,
3844 } = deserializer.next(reader, event)?;
3845 if let Some(data) = data {
3846 self.content.push(AnnotationContent::Appinfo(data));
3847 }
3848 if let Some(deserializer) = deserializer {
3849 *self.state = AnnotationDeserializerState::Appinfo(deserializer);
3850 }
3851 Ok(DeserializerOutput {
3852 data: None,
3853 deserializer: Some(self),
3854 event,
3855 allow_any,
3856 })
3857 }
3858 (AnnotationDeserializerState::Documentation(deserializer), _) => {
3859 let DeserializerOutput {
3860 data,
3861 deserializer,
3862 event,
3863 allow_any,
3864 } = deserializer.next(reader, event)?;
3865 if let Some(data) = data {
3866 self.content.push(AnnotationContent::Documentation(data));
3867 }
3868 if let Some(deserializer) = deserializer {
3869 *self.state = AnnotationDeserializerState::Documentation(deserializer);
3870 }
3871 Ok(DeserializerOutput {
3872 data: None,
3873 deserializer: Some(self),
3874 event,
3875 allow_any,
3876 })
3877 }
3878 }
3879 }
3880 fn finish<R>(self, _reader: &R) -> Result<super::Annotation, crate::quick_xml::Error>
3881 where
3882 R: crate::quick_xml::XmlReader,
3883 {
3884 use crate::quick_xml::ErrorKind;
3885 Ok(super::Annotation {
3886 id: self.id,
3887 content: self.content,
3888 })
3889 }
3890 }
3891 #[derive(Debug)]
3892 pub struct DefaultOpenContentDeserializer {
3893 id: Option<String>,
3894 applies_to_empty: bool,
3895 mode: super::DefaultOpenContentModeType,
3896 annotation: Option<super::Annotation>,
3897 any: Option<super::WildcardType>,
3898 state: Box<DefaultOpenContentDeserializerState>,
3899 }
3900 #[derive(Debug)]
3901 enum DefaultOpenContentDeserializerState {
3902 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
3903 Any(Option<<WildcardType as crate::quick_xml::WithDeserializer>::Deserializer>),
3904 Done__,
3905 }
3906 impl DefaultOpenContentDeserializer {
3907 fn from_bytes_start<R>(
3908 reader: &R,
3909 bytes_start: &crate::quick_xml::BytesStart<'_>,
3910 ) -> Result<Self, crate::quick_xml::Error>
3911 where
3912 R: crate::quick_xml::XmlReader,
3913 {
3914 use crate::quick_xml::ErrorKind;
3915 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
3916 let mut id: Option<String> = None;
3917 let mut applies_to_empty: Option<bool> = None;
3918 let mut mode: Option<DefaultOpenContentModeType> = None;
3919 for attrib in bytes_start.attributes() {
3920 let attrib = attrib?;
3921 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
3922 continue;
3923 }
3924 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
3925 reader.read_attrib(&mut id, b"id", &attrib.value)?;
3926 } else if matches!(
3927 reader.resolve_local_name(attrib.key, NS_XS),
3928 Some(b"appliesToEmpty")
3929 ) {
3930 reader.read_attrib(&mut applies_to_empty, b"appliesToEmpty", &attrib.value)?;
3931 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"mode")) {
3932 reader.read_attrib(&mut mode, b"mode", &attrib.value)?;
3933 }
3934 }
3935 Ok(Self {
3936 id: id,
3937 applies_to_empty: applies_to_empty
3938 .unwrap_or_else(super::DefaultOpenContent::default_applies_to_empty),
3939 mode: mode.unwrap_or_else(super::DefaultOpenContent::default_mode),
3940 annotation: None,
3941 any: None,
3942 state: Box::new(DefaultOpenContentDeserializerState::Annotation(None)),
3943 })
3944 }
3945 }
3946 impl<'de> crate::quick_xml::Deserializer<'de, super::DefaultOpenContent>
3947 for DefaultOpenContentDeserializer
3948 {
3949 fn init<R>(
3950 reader: &R,
3951 event: crate::quick_xml::Event<'de>,
3952 ) -> crate::quick_xml::DeserializerResult<'de, super::DefaultOpenContent, Self>
3953 where
3954 R: crate::quick_xml::XmlReader,
3955 {
3956 use crate::quick_xml::{DeserializerOutput, Event};
3957 match event {
3958 Event::Start(start) => {
3959 let deserializer = Self::from_bytes_start(reader, &start)?;
3960 Ok(DeserializerOutput {
3961 data: None,
3962 deserializer: Some(deserializer),
3963 event: None,
3964 allow_any: false,
3965 })
3966 }
3967 Event::Empty(start) => {
3968 let deserializer = Self::from_bytes_start(reader, &start)?;
3969 let data = deserializer.finish(reader)?;
3970 Ok(DeserializerOutput {
3971 data: Some(data),
3972 deserializer: None,
3973 event: None,
3974 allow_any: false,
3975 })
3976 }
3977 event => Ok(DeserializerOutput {
3978 data: None,
3979 deserializer: None,
3980 event: Some(event),
3981 allow_any: false,
3982 }),
3983 }
3984 }
3985 fn next<R>(
3986 mut self,
3987 reader: &R,
3988 event: crate::quick_xml::Event<'de>,
3989 ) -> crate::quick_xml::DeserializerResult<'de, super::DefaultOpenContent, Self>
3990 where
3991 R: crate::quick_xml::XmlReader,
3992 {
3993 use crate::quick_xml::{
3994 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
3995 };
3996 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
3997 let mut event = event;
3998 let mut allow_any_fallback = None;
3999 loop {
4000 event = match (
4001 core::mem::replace(
4002 &mut *self.state,
4003 DefaultOpenContentDeserializerState::Done__,
4004 ),
4005 event,
4006 ) {
4007 (
4008 DefaultOpenContentDeserializerState::Annotation(Some(deserializer)),
4009 event,
4010 ) => {
4011 let DeserializerOutput {
4012 data,
4013 deserializer,
4014 event,
4015 allow_any,
4016 } = deserializer.next(reader, event)?;
4017 if let Some(data) = data {
4018 if self.annotation.is_some() {
4019 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4020 b"annotation",
4021 )))?;
4022 }
4023 self.annotation = Some(data);
4024 }
4025 let event = match event {
4026 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
4027 event
4028 }
4029 event => {
4030 *self.state =
4031 DefaultOpenContentDeserializerState::Annotation(deserializer);
4032 return Ok(DeserializerOutput {
4033 data: None,
4034 deserializer: Some(self),
4035 event: event,
4036 allow_any: false,
4037 });
4038 }
4039 };
4040 if allow_any {
4041 allow_any_fallback.get_or_insert(
4042 DefaultOpenContentDeserializerState::Annotation(deserializer),
4043 );
4044 } else if let Some(deserializer) = deserializer {
4045 let data = deserializer.finish(reader)?;
4046 if self.annotation.is_some() {
4047 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4048 b"annotation",
4049 )))?;
4050 }
4051 self.annotation = Some(data);
4052 }
4053 *self.state = DefaultOpenContentDeserializerState::Annotation(None);
4054 event
4055 }
4056 (DefaultOpenContentDeserializerState::Annotation(None), event) => {
4057 match &event {
4058 Event::Start(x) | Event::Empty(x)
4059 if matches!(
4060 reader.resolve_local_name(x.name(), NS_XS),
4061 Some(b"annotation")
4062 ) =>
4063 {
4064 let DeserializerOutput {
4065 data,
4066 deserializer,
4067 event,
4068 allow_any,
4069 } = <Annotation as WithDeserializer>::Deserializer::init(
4070 reader, event,
4071 )?;
4072 if let Some(data) = data {
4073 if self.annotation.is_some() {
4074 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4075 b"annotation",
4076 )))?;
4077 }
4078 self.annotation = Some(data);
4079 }
4080 *self.state =
4081 DefaultOpenContentDeserializerState::Annotation(deserializer);
4082 match event {
4083 Some(event @ (Event::Start(_) | Event::End(_))) => {
4084 *self.state =
4085 DefaultOpenContentDeserializerState::Any(None);
4086 if allow_any {
4087 allow_any_fallback.get_or_insert(
4088 DefaultOpenContentDeserializerState::Annotation(
4089 None,
4090 ),
4091 );
4092 }
4093 event
4094 }
4095 event @ (None | Some(_)) => {
4096 return Ok(DeserializerOutput {
4097 data: None,
4098 deserializer: Some(self),
4099 event,
4100 allow_any: false,
4101 })
4102 }
4103 }
4104 }
4105 Event::Start(_) | Event::Empty(_) => {
4106 *self.state = DefaultOpenContentDeserializerState::Any(None);
4107 allow_any_fallback.get_or_insert(
4108 DefaultOpenContentDeserializerState::Annotation(None),
4109 );
4110 event
4111 }
4112 Event::End(_) => {
4113 let data = self.finish(reader)?;
4114 return Ok(DeserializerOutput {
4115 data: Some(data),
4116 deserializer: None,
4117 event: None,
4118 allow_any: false,
4119 });
4120 }
4121 _ => {
4122 *self.state = DefaultOpenContentDeserializerState::Annotation(None);
4123 return Ok(DeserializerOutput {
4124 data: None,
4125 deserializer: Some(self),
4126 event: Some(event),
4127 allow_any: false,
4128 });
4129 }
4130 }
4131 }
4132 (DefaultOpenContentDeserializerState::Any(Some(deserializer)), event) => {
4133 let DeserializerOutput {
4134 data,
4135 deserializer,
4136 event,
4137 allow_any,
4138 } = deserializer.next(reader, event)?;
4139 if let Some(data) = data {
4140 if self.any.is_some() {
4141 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"any")))?;
4142 }
4143 self.any = Some(data);
4144 }
4145 let event = match event {
4146 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
4147 event
4148 }
4149 event => {
4150 *self.state =
4151 DefaultOpenContentDeserializerState::Any(deserializer);
4152 return Ok(DeserializerOutput {
4153 data: None,
4154 deserializer: Some(self),
4155 event: event,
4156 allow_any: false,
4157 });
4158 }
4159 };
4160 if allow_any {
4161 allow_any_fallback.get_or_insert(
4162 DefaultOpenContentDeserializerState::Any(deserializer),
4163 );
4164 } else if let Some(deserializer) = deserializer {
4165 let data = deserializer.finish(reader)?;
4166 if self.any.is_some() {
4167 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"any")))?;
4168 }
4169 self.any = Some(data);
4170 }
4171 *self.state = DefaultOpenContentDeserializerState::Any(None);
4172 event
4173 }
4174 (DefaultOpenContentDeserializerState::Any(None), event) => match &event {
4175 Event::Start(x) | Event::Empty(x)
4176 if matches!(
4177 reader.resolve_local_name(x.name(), NS_XS),
4178 Some(b"any")
4179 ) =>
4180 {
4181 let DeserializerOutput {
4182 data,
4183 deserializer,
4184 event,
4185 allow_any,
4186 } = <WildcardType as WithDeserializer>::Deserializer::init(
4187 reader, event,
4188 )?;
4189 if let Some(data) = data {
4190 if self.any.is_some() {
4191 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4192 b"any",
4193 )))?;
4194 }
4195 self.any = Some(data);
4196 }
4197 *self.state = DefaultOpenContentDeserializerState::Any(deserializer);
4198 match event {
4199 Some(event @ (Event::Start(_) | Event::End(_))) => {
4200 *self.state = DefaultOpenContentDeserializerState::Done__;
4201 if allow_any {
4202 allow_any_fallback.get_or_insert(
4203 DefaultOpenContentDeserializerState::Any(None),
4204 );
4205 }
4206 event
4207 }
4208 event @ (None | Some(_)) => {
4209 return Ok(DeserializerOutput {
4210 data: None,
4211 deserializer: Some(self),
4212 event,
4213 allow_any: false,
4214 })
4215 }
4216 }
4217 }
4218 Event::Start(_) | Event::Empty(_) => {
4219 *self.state = DefaultOpenContentDeserializerState::Done__;
4220 allow_any_fallback
4221 .get_or_insert(DefaultOpenContentDeserializerState::Any(None));
4222 event
4223 }
4224 Event::End(_) => {
4225 let data = self.finish(reader)?;
4226 return Ok(DeserializerOutput {
4227 data: Some(data),
4228 deserializer: None,
4229 event: None,
4230 allow_any: false,
4231 });
4232 }
4233 _ => {
4234 *self.state = DefaultOpenContentDeserializerState::Any(None);
4235 return Ok(DeserializerOutput {
4236 data: None,
4237 deserializer: Some(self),
4238 event: Some(event),
4239 allow_any: false,
4240 });
4241 }
4242 },
4243 (DefaultOpenContentDeserializerState::Done__, event) => {
4244 let allow_any = if let Some(fallback) = allow_any_fallback {
4245 *self.state = fallback;
4246 true
4247 } else {
4248 false
4249 };
4250 return Ok(DeserializerOutput {
4251 data: None,
4252 deserializer: Some(self),
4253 event: Some(event),
4254 allow_any,
4255 });
4256 }
4257 }
4258 }
4259 }
4260 fn finish<R>(
4261 self,
4262 _reader: &R,
4263 ) -> Result<super::DefaultOpenContent, crate::quick_xml::Error>
4264 where
4265 R: crate::quick_xml::XmlReader,
4266 {
4267 use crate::quick_xml::ErrorKind;
4268 Ok(super::DefaultOpenContent {
4269 id: self.id,
4270 applies_to_empty: self.applies_to_empty,
4271 mode: self.mode,
4272 annotation: self.annotation,
4273 any: self
4274 .any
4275 .ok_or_else(|| ErrorKind::MissingElement("any".into()))?,
4276 })
4277 }
4278 }
4279 #[derive(Debug)]
4280 pub struct SimpleBaseTypeDeserializer {
4281 id: Option<String>,
4282 final_: Option<super::SimpleDerivationSetType>,
4283 name: Option<String>,
4284 content: Vec<super::SimpleBaseTypeContent>,
4285 state: Box<SimpleBaseTypeDeserializerState>,
4286 }
4287 #[derive(Debug)]
4288 enum SimpleBaseTypeDeserializerState {
4289 Next__,
4290 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
4291 Restriction(<Restriction as crate::quick_xml::WithDeserializer>::Deserializer),
4292 List(<List as crate::quick_xml::WithDeserializer>::Deserializer),
4293 Union(<Union as crate::quick_xml::WithDeserializer>::Deserializer),
4294 }
4295 impl SimpleBaseTypeDeserializer {
4296 fn from_bytes_start<R>(
4297 reader: &R,
4298 bytes_start: &crate::quick_xml::BytesStart<'_>,
4299 ) -> Result<Self, crate::quick_xml::Error>
4300 where
4301 R: crate::quick_xml::XmlReader,
4302 {
4303 use crate::quick_xml::ErrorKind;
4304 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
4305 let mut id: Option<String> = None;
4306 let mut final_: Option<SimpleDerivationSetType> = None;
4307 let mut name: Option<String> = None;
4308 for attrib in bytes_start.attributes() {
4309 let attrib = attrib?;
4310 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
4311 continue;
4312 }
4313 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
4314 reader.read_attrib(&mut id, b"id", &attrib.value)?;
4315 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"final")) {
4316 reader.read_attrib(&mut final_, b"final", &attrib.value)?;
4317 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"name")) {
4318 reader.read_attrib(&mut name, b"name", &attrib.value)?;
4319 }
4320 }
4321 Ok(Self {
4322 id: id,
4323 final_: final_,
4324 name: name,
4325 content: Vec::new(),
4326 state: Box::new(SimpleBaseTypeDeserializerState::Next__),
4327 })
4328 }
4329 }
4330 impl<'de> crate::quick_xml::Deserializer<'de, super::SimpleBaseType>
4331 for SimpleBaseTypeDeserializer
4332 {
4333 fn init<R>(
4334 reader: &R,
4335 event: crate::quick_xml::Event<'de>,
4336 ) -> crate::quick_xml::DeserializerResult<'de, super::SimpleBaseType, Self>
4337 where
4338 R: crate::quick_xml::XmlReader,
4339 {
4340 use crate::quick_xml::{DeserializerOutput, Event};
4341 match event {
4342 Event::Start(start) => {
4343 let deserializer = Self::from_bytes_start(reader, &start)?;
4344 Ok(DeserializerOutput {
4345 data: None,
4346 deserializer: Some(deserializer),
4347 event: None,
4348 allow_any: false,
4349 })
4350 }
4351 Event::Empty(start) => {
4352 let deserializer = Self::from_bytes_start(reader, &start)?;
4353 let data = deserializer.finish(reader)?;
4354 Ok(DeserializerOutput {
4355 data: Some(data),
4356 deserializer: None,
4357 event: None,
4358 allow_any: false,
4359 })
4360 }
4361 event => Ok(DeserializerOutput {
4362 data: None,
4363 deserializer: None,
4364 event: Some(event),
4365 allow_any: false,
4366 }),
4367 }
4368 }
4369 fn next<R>(
4370 mut self,
4371 reader: &R,
4372 event: crate::quick_xml::Event<'de>,
4373 ) -> crate::quick_xml::DeserializerResult<'de, super::SimpleBaseType, Self>
4374 where
4375 R: crate::quick_xml::XmlReader,
4376 {
4377 use crate::quick_xml::{
4378 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
4379 };
4380 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
4381 match (
4382 core::mem::replace(&mut *self.state, SimpleBaseTypeDeserializerState::Next__),
4383 &event,
4384 ) {
4385 (SimpleBaseTypeDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
4386 if matches!(
4387 reader.resolve_local_name(x.name(), NS_XS),
4388 Some(b"annotation")
4389 ) {
4390 let DeserializerOutput {
4391 data,
4392 deserializer,
4393 event,
4394 allow_any,
4395 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
4396 if let Some(data) = data {
4397 self.content.push(SimpleBaseTypeContent::Annotation(data));
4398 }
4399 if let Some(deserializer) = deserializer {
4400 *self.state = SimpleBaseTypeDeserializerState::Annotation(deserializer);
4401 }
4402 Ok(DeserializerOutput {
4403 data: None,
4404 deserializer: Some(self),
4405 event,
4406 allow_any,
4407 })
4408 } else if matches!(
4409 reader.resolve_local_name(x.name(), NS_XS),
4410 Some(b"restriction")
4411 ) {
4412 let DeserializerOutput {
4413 data,
4414 deserializer,
4415 event,
4416 allow_any,
4417 } = <Restriction as WithDeserializer>::Deserializer::init(reader, event)?;
4418 if let Some(data) = data {
4419 self.content.push(SimpleBaseTypeContent::Restriction(data));
4420 }
4421 if let Some(deserializer) = deserializer {
4422 *self.state =
4423 SimpleBaseTypeDeserializerState::Restriction(deserializer);
4424 }
4425 Ok(DeserializerOutput {
4426 data: None,
4427 deserializer: Some(self),
4428 event,
4429 allow_any,
4430 })
4431 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"list")) {
4432 let DeserializerOutput {
4433 data,
4434 deserializer,
4435 event,
4436 allow_any,
4437 } = <List as WithDeserializer>::Deserializer::init(reader, event)?;
4438 if let Some(data) = data {
4439 self.content.push(SimpleBaseTypeContent::List(data));
4440 }
4441 if let Some(deserializer) = deserializer {
4442 *self.state = SimpleBaseTypeDeserializerState::List(deserializer);
4443 }
4444 Ok(DeserializerOutput {
4445 data: None,
4446 deserializer: Some(self),
4447 event,
4448 allow_any,
4449 })
4450 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"union")) {
4451 let DeserializerOutput {
4452 data,
4453 deserializer,
4454 event,
4455 allow_any,
4456 } = <Union as WithDeserializer>::Deserializer::init(reader, event)?;
4457 if let Some(data) = data {
4458 self.content.push(SimpleBaseTypeContent::Union(data));
4459 }
4460 if let Some(deserializer) = deserializer {
4461 *self.state = SimpleBaseTypeDeserializerState::Union(deserializer);
4462 }
4463 Ok(DeserializerOutput {
4464 data: None,
4465 deserializer: Some(self),
4466 event,
4467 allow_any,
4468 })
4469 } else {
4470 Ok(DeserializerOutput {
4471 data: None,
4472 deserializer: Some(self),
4473 event: Some(event),
4474 allow_any: false,
4475 })
4476 }
4477 }
4478 (SimpleBaseTypeDeserializerState::Next__, Event::End(_)) => {
4479 let data = self.finish(reader)?;
4480 Ok(DeserializerOutput {
4481 data: Some(data),
4482 deserializer: None,
4483 event: None,
4484 allow_any: false,
4485 })
4486 }
4487 (SimpleBaseTypeDeserializerState::Next__, _) => Ok(DeserializerOutput {
4488 data: None,
4489 deserializer: Some(self),
4490 event: None,
4491 allow_any: false,
4492 }),
4493 (SimpleBaseTypeDeserializerState::Annotation(deserializer), _) => {
4494 let DeserializerOutput {
4495 data,
4496 deserializer,
4497 event,
4498 allow_any,
4499 } = deserializer.next(reader, event)?;
4500 if let Some(data) = data {
4501 self.content.push(SimpleBaseTypeContent::Annotation(data));
4502 }
4503 if let Some(deserializer) = deserializer {
4504 *self.state = SimpleBaseTypeDeserializerState::Annotation(deserializer);
4505 }
4506 Ok(DeserializerOutput {
4507 data: None,
4508 deserializer: Some(self),
4509 event,
4510 allow_any,
4511 })
4512 }
4513 (SimpleBaseTypeDeserializerState::Restriction(deserializer), _) => {
4514 let DeserializerOutput {
4515 data,
4516 deserializer,
4517 event,
4518 allow_any,
4519 } = deserializer.next(reader, event)?;
4520 if let Some(data) = data {
4521 self.content.push(SimpleBaseTypeContent::Restriction(data));
4522 }
4523 if let Some(deserializer) = deserializer {
4524 *self.state = SimpleBaseTypeDeserializerState::Restriction(deserializer);
4525 }
4526 Ok(DeserializerOutput {
4527 data: None,
4528 deserializer: Some(self),
4529 event,
4530 allow_any,
4531 })
4532 }
4533 (SimpleBaseTypeDeserializerState::List(deserializer), _) => {
4534 let DeserializerOutput {
4535 data,
4536 deserializer,
4537 event,
4538 allow_any,
4539 } = deserializer.next(reader, event)?;
4540 if let Some(data) = data {
4541 self.content.push(SimpleBaseTypeContent::List(data));
4542 }
4543 if let Some(deserializer) = deserializer {
4544 *self.state = SimpleBaseTypeDeserializerState::List(deserializer);
4545 }
4546 Ok(DeserializerOutput {
4547 data: None,
4548 deserializer: Some(self),
4549 event,
4550 allow_any,
4551 })
4552 }
4553 (SimpleBaseTypeDeserializerState::Union(deserializer), _) => {
4554 let DeserializerOutput {
4555 data,
4556 deserializer,
4557 event,
4558 allow_any,
4559 } = deserializer.next(reader, event)?;
4560 if let Some(data) = data {
4561 self.content.push(SimpleBaseTypeContent::Union(data));
4562 }
4563 if let Some(deserializer) = deserializer {
4564 *self.state = SimpleBaseTypeDeserializerState::Union(deserializer);
4565 }
4566 Ok(DeserializerOutput {
4567 data: None,
4568 deserializer: Some(self),
4569 event,
4570 allow_any,
4571 })
4572 }
4573 }
4574 }
4575 fn finish<R>(self, _reader: &R) -> Result<super::SimpleBaseType, crate::quick_xml::Error>
4576 where
4577 R: crate::quick_xml::XmlReader,
4578 {
4579 use crate::quick_xml::ErrorKind;
4580 Ok(super::SimpleBaseType {
4581 id: self.id,
4582 final_: self.final_,
4583 name: self.name,
4584 content: self.content,
4585 })
4586 }
4587 }
4588 #[derive(Debug)]
4589 pub struct ComplexBaseTypeDeserializer {
4590 id: Option<String>,
4591 name: Option<String>,
4592 mixed: Option<bool>,
4593 abstract_: bool,
4594 final_: Option<super::DerivationSetType>,
4595 block: Option<super::DerivationSetType>,
4596 default_attributes_apply: bool,
4597 content: Vec<super::ComplexBaseTypeContent>,
4598 state: Box<ComplexBaseTypeDeserializerState>,
4599 }
4600 #[derive(Debug)]
4601 enum ComplexBaseTypeDeserializerState {
4602 Next__,
4603 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
4604 SimpleContent(<SimpleContent as crate::quick_xml::WithDeserializer>::Deserializer),
4605 ComplexContent(<ComplexContent as crate::quick_xml::WithDeserializer>::Deserializer),
4606 OpenContent(<OpenContent as crate::quick_xml::WithDeserializer>::Deserializer),
4607 Group(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
4608 All(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
4609 Choice(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
4610 Sequence(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
4611 Attribute(<AttributeType as crate::quick_xml::WithDeserializer>::Deserializer),
4612 AttributeGroup(<AttributeGroupType as crate::quick_xml::WithDeserializer>::Deserializer),
4613 AnyAttribute(<AnyAttribute as crate::quick_xml::WithDeserializer>::Deserializer),
4614 Assert(<AssertionType as crate::quick_xml::WithDeserializer>::Deserializer),
4615 }
4616 impl ComplexBaseTypeDeserializer {
4617 fn from_bytes_start<R>(
4618 reader: &R,
4619 bytes_start: &crate::quick_xml::BytesStart<'_>,
4620 ) -> Result<Self, crate::quick_xml::Error>
4621 where
4622 R: crate::quick_xml::XmlReader,
4623 {
4624 use crate::quick_xml::ErrorKind;
4625 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
4626 let mut id: Option<String> = None;
4627 let mut name: Option<String> = None;
4628 let mut mixed: Option<bool> = None;
4629 let mut abstract_: Option<bool> = None;
4630 let mut final_: Option<DerivationSetType> = None;
4631 let mut block: Option<DerivationSetType> = None;
4632 let mut default_attributes_apply: Option<bool> = None;
4633 for attrib in bytes_start.attributes() {
4634 let attrib = attrib?;
4635 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
4636 continue;
4637 }
4638 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
4639 reader.read_attrib(&mut id, b"id", &attrib.value)?;
4640 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"name")) {
4641 reader.read_attrib(&mut name, b"name", &attrib.value)?;
4642 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"mixed")) {
4643 reader.read_attrib(&mut mixed, b"mixed", &attrib.value)?;
4644 } else if matches!(
4645 reader.resolve_local_name(attrib.key, NS_XS),
4646 Some(b"abstract")
4647 ) {
4648 reader.read_attrib(&mut abstract_, b"abstract", &attrib.value)?;
4649 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"final")) {
4650 reader.read_attrib(&mut final_, b"final", &attrib.value)?;
4651 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"block")) {
4652 reader.read_attrib(&mut block, b"block", &attrib.value)?;
4653 } else if matches!(
4654 reader.resolve_local_name(attrib.key, NS_XS),
4655 Some(b"defaultAttributesApply")
4656 ) {
4657 reader.read_attrib(
4658 &mut default_attributes_apply,
4659 b"defaultAttributesApply",
4660 &attrib.value,
4661 )?;
4662 }
4663 }
4664 Ok(Self {
4665 id: id,
4666 name: name,
4667 mixed: mixed,
4668 abstract_: abstract_.unwrap_or_else(super::ComplexBaseType::default_abstract_),
4669 final_: final_,
4670 block: block,
4671 default_attributes_apply: default_attributes_apply
4672 .unwrap_or_else(super::ComplexBaseType::default_default_attributes_apply),
4673 content: Vec::new(),
4674 state: Box::new(ComplexBaseTypeDeserializerState::Next__),
4675 })
4676 }
4677 }
4678 impl<'de> crate::quick_xml::Deserializer<'de, super::ComplexBaseType>
4679 for ComplexBaseTypeDeserializer
4680 {
4681 fn init<R>(
4682 reader: &R,
4683 event: crate::quick_xml::Event<'de>,
4684 ) -> crate::quick_xml::DeserializerResult<'de, super::ComplexBaseType, Self>
4685 where
4686 R: crate::quick_xml::XmlReader,
4687 {
4688 use crate::quick_xml::{DeserializerOutput, Event};
4689 match event {
4690 Event::Start(start) => {
4691 let deserializer = Self::from_bytes_start(reader, &start)?;
4692 Ok(DeserializerOutput {
4693 data: None,
4694 deserializer: Some(deserializer),
4695 event: None,
4696 allow_any: false,
4697 })
4698 }
4699 Event::Empty(start) => {
4700 let deserializer = Self::from_bytes_start(reader, &start)?;
4701 let data = deserializer.finish(reader)?;
4702 Ok(DeserializerOutput {
4703 data: Some(data),
4704 deserializer: None,
4705 event: None,
4706 allow_any: false,
4707 })
4708 }
4709 event => Ok(DeserializerOutput {
4710 data: None,
4711 deserializer: None,
4712 event: Some(event),
4713 allow_any: false,
4714 }),
4715 }
4716 }
4717 fn next<R>(
4718 mut self,
4719 reader: &R,
4720 event: crate::quick_xml::Event<'de>,
4721 ) -> crate::quick_xml::DeserializerResult<'de, super::ComplexBaseType, Self>
4722 where
4723 R: crate::quick_xml::XmlReader,
4724 {
4725 use crate::quick_xml::{
4726 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
4727 };
4728 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
4729 match (
4730 core::mem::replace(&mut *self.state, ComplexBaseTypeDeserializerState::Next__),
4731 &event,
4732 ) {
4733 (ComplexBaseTypeDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
4734 if matches!(
4735 reader.resolve_local_name(x.name(), NS_XS),
4736 Some(b"annotation")
4737 ) {
4738 let DeserializerOutput {
4739 data,
4740 deserializer,
4741 event,
4742 allow_any,
4743 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
4744 if let Some(data) = data {
4745 self.content.push(ComplexBaseTypeContent::Annotation(data));
4746 }
4747 if let Some(deserializer) = deserializer {
4748 *self.state =
4749 ComplexBaseTypeDeserializerState::Annotation(deserializer);
4750 }
4751 Ok(DeserializerOutput {
4752 data: None,
4753 deserializer: Some(self),
4754 event,
4755 allow_any,
4756 })
4757 } else if matches!(
4758 reader.resolve_local_name(x.name(), NS_XS),
4759 Some(b"simpleContent")
4760 ) {
4761 let DeserializerOutput {
4762 data,
4763 deserializer,
4764 event,
4765 allow_any,
4766 } = <SimpleContent as WithDeserializer>::Deserializer::init(reader, event)?;
4767 if let Some(data) = data {
4768 self.content
4769 .push(ComplexBaseTypeContent::SimpleContent(data));
4770 }
4771 if let Some(deserializer) = deserializer {
4772 *self.state =
4773 ComplexBaseTypeDeserializerState::SimpleContent(deserializer);
4774 }
4775 Ok(DeserializerOutput {
4776 data: None,
4777 deserializer: Some(self),
4778 event,
4779 allow_any,
4780 })
4781 } else if matches!(
4782 reader.resolve_local_name(x.name(), NS_XS),
4783 Some(b"complexContent")
4784 ) {
4785 let DeserializerOutput {
4786 data,
4787 deserializer,
4788 event,
4789 allow_any,
4790 } = <ComplexContent as WithDeserializer>::Deserializer::init(
4791 reader, event,
4792 )?;
4793 if let Some(data) = data {
4794 self.content
4795 .push(ComplexBaseTypeContent::ComplexContent(data));
4796 }
4797 if let Some(deserializer) = deserializer {
4798 *self.state =
4799 ComplexBaseTypeDeserializerState::ComplexContent(deserializer);
4800 }
4801 Ok(DeserializerOutput {
4802 data: None,
4803 deserializer: Some(self),
4804 event,
4805 allow_any,
4806 })
4807 } else if matches!(
4808 reader.resolve_local_name(x.name(), NS_XS),
4809 Some(b"openContent")
4810 ) {
4811 let DeserializerOutput {
4812 data,
4813 deserializer,
4814 event,
4815 allow_any,
4816 } = <OpenContent as WithDeserializer>::Deserializer::init(reader, event)?;
4817 if let Some(data) = data {
4818 self.content.push(ComplexBaseTypeContent::OpenContent(data));
4819 }
4820 if let Some(deserializer) = deserializer {
4821 *self.state =
4822 ComplexBaseTypeDeserializerState::OpenContent(deserializer);
4823 }
4824 Ok(DeserializerOutput {
4825 data: None,
4826 deserializer: Some(self),
4827 event,
4828 allow_any,
4829 })
4830 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"group")) {
4831 let DeserializerOutput {
4832 data,
4833 deserializer,
4834 event,
4835 allow_any,
4836 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
4837 if let Some(data) = data {
4838 self.content.push(ComplexBaseTypeContent::Group(data));
4839 }
4840 if let Some(deserializer) = deserializer {
4841 *self.state = ComplexBaseTypeDeserializerState::Group(deserializer);
4842 }
4843 Ok(DeserializerOutput {
4844 data: None,
4845 deserializer: Some(self),
4846 event,
4847 allow_any,
4848 })
4849 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"all")) {
4850 let DeserializerOutput {
4851 data,
4852 deserializer,
4853 event,
4854 allow_any,
4855 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
4856 if let Some(data) = data {
4857 self.content.push(ComplexBaseTypeContent::All(data));
4858 }
4859 if let Some(deserializer) = deserializer {
4860 *self.state = ComplexBaseTypeDeserializerState::All(deserializer);
4861 }
4862 Ok(DeserializerOutput {
4863 data: None,
4864 deserializer: Some(self),
4865 event,
4866 allow_any,
4867 })
4868 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"choice"))
4869 {
4870 let DeserializerOutput {
4871 data,
4872 deserializer,
4873 event,
4874 allow_any,
4875 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
4876 if let Some(data) = data {
4877 self.content.push(ComplexBaseTypeContent::Choice(data));
4878 }
4879 if let Some(deserializer) = deserializer {
4880 *self.state = ComplexBaseTypeDeserializerState::Choice(deserializer);
4881 }
4882 Ok(DeserializerOutput {
4883 data: None,
4884 deserializer: Some(self),
4885 event,
4886 allow_any,
4887 })
4888 } else if matches!(
4889 reader.resolve_local_name(x.name(), NS_XS),
4890 Some(b"sequence")
4891 ) {
4892 let DeserializerOutput {
4893 data,
4894 deserializer,
4895 event,
4896 allow_any,
4897 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
4898 if let Some(data) = data {
4899 self.content.push(ComplexBaseTypeContent::Sequence(data));
4900 }
4901 if let Some(deserializer) = deserializer {
4902 *self.state = ComplexBaseTypeDeserializerState::Sequence(deserializer);
4903 }
4904 Ok(DeserializerOutput {
4905 data: None,
4906 deserializer: Some(self),
4907 event,
4908 allow_any,
4909 })
4910 } else if matches!(
4911 reader.resolve_local_name(x.name(), NS_XS),
4912 Some(b"attribute")
4913 ) {
4914 let DeserializerOutput {
4915 data,
4916 deserializer,
4917 event,
4918 allow_any,
4919 } = <AttributeType as WithDeserializer>::Deserializer::init(reader, event)?;
4920 if let Some(data) = data {
4921 self.content.push(ComplexBaseTypeContent::Attribute(data));
4922 }
4923 if let Some(deserializer) = deserializer {
4924 *self.state = ComplexBaseTypeDeserializerState::Attribute(deserializer);
4925 }
4926 Ok(DeserializerOutput {
4927 data: None,
4928 deserializer: Some(self),
4929 event,
4930 allow_any,
4931 })
4932 } else if matches!(
4933 reader.resolve_local_name(x.name(), NS_XS),
4934 Some(b"attributeGroup")
4935 ) {
4936 let DeserializerOutput {
4937 data,
4938 deserializer,
4939 event,
4940 allow_any,
4941 } = <AttributeGroupType as WithDeserializer>::Deserializer::init(
4942 reader, event,
4943 )?;
4944 if let Some(data) = data {
4945 self.content
4946 .push(ComplexBaseTypeContent::AttributeGroup(data));
4947 }
4948 if let Some(deserializer) = deserializer {
4949 *self.state =
4950 ComplexBaseTypeDeserializerState::AttributeGroup(deserializer);
4951 }
4952 Ok(DeserializerOutput {
4953 data: None,
4954 deserializer: Some(self),
4955 event,
4956 allow_any,
4957 })
4958 } else if matches!(
4959 reader.resolve_local_name(x.name(), NS_XS),
4960 Some(b"anyAttribute")
4961 ) {
4962 let DeserializerOutput {
4963 data,
4964 deserializer,
4965 event,
4966 allow_any,
4967 } = <AnyAttribute as WithDeserializer>::Deserializer::init(reader, event)?;
4968 if let Some(data) = data {
4969 self.content
4970 .push(ComplexBaseTypeContent::AnyAttribute(data));
4971 }
4972 if let Some(deserializer) = deserializer {
4973 *self.state =
4974 ComplexBaseTypeDeserializerState::AnyAttribute(deserializer);
4975 }
4976 Ok(DeserializerOutput {
4977 data: None,
4978 deserializer: Some(self),
4979 event,
4980 allow_any,
4981 })
4982 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"assert"))
4983 {
4984 let DeserializerOutput {
4985 data,
4986 deserializer,
4987 event,
4988 allow_any,
4989 } = <AssertionType as WithDeserializer>::Deserializer::init(reader, event)?;
4990 if let Some(data) = data {
4991 self.content.push(ComplexBaseTypeContent::Assert(data));
4992 }
4993 if let Some(deserializer) = deserializer {
4994 *self.state = ComplexBaseTypeDeserializerState::Assert(deserializer);
4995 }
4996 Ok(DeserializerOutput {
4997 data: None,
4998 deserializer: Some(self),
4999 event,
5000 allow_any,
5001 })
5002 } else {
5003 Ok(DeserializerOutput {
5004 data: None,
5005 deserializer: Some(self),
5006 event: Some(event),
5007 allow_any: false,
5008 })
5009 }
5010 }
5011 (ComplexBaseTypeDeserializerState::Next__, Event::End(_)) => {
5012 let data = self.finish(reader)?;
5013 Ok(DeserializerOutput {
5014 data: Some(data),
5015 deserializer: None,
5016 event: None,
5017 allow_any: false,
5018 })
5019 }
5020 (ComplexBaseTypeDeserializerState::Next__, _) => Ok(DeserializerOutput {
5021 data: None,
5022 deserializer: Some(self),
5023 event: None,
5024 allow_any: false,
5025 }),
5026 (ComplexBaseTypeDeserializerState::Annotation(deserializer), _) => {
5027 let DeserializerOutput {
5028 data,
5029 deserializer,
5030 event,
5031 allow_any,
5032 } = deserializer.next(reader, event)?;
5033 if let Some(data) = data {
5034 self.content.push(ComplexBaseTypeContent::Annotation(data));
5035 }
5036 if let Some(deserializer) = deserializer {
5037 *self.state = ComplexBaseTypeDeserializerState::Annotation(deserializer);
5038 }
5039 Ok(DeserializerOutput {
5040 data: None,
5041 deserializer: Some(self),
5042 event,
5043 allow_any,
5044 })
5045 }
5046 (ComplexBaseTypeDeserializerState::SimpleContent(deserializer), _) => {
5047 let DeserializerOutput {
5048 data,
5049 deserializer,
5050 event,
5051 allow_any,
5052 } = deserializer.next(reader, event)?;
5053 if let Some(data) = data {
5054 self.content
5055 .push(ComplexBaseTypeContent::SimpleContent(data));
5056 }
5057 if let Some(deserializer) = deserializer {
5058 *self.state = ComplexBaseTypeDeserializerState::SimpleContent(deserializer);
5059 }
5060 Ok(DeserializerOutput {
5061 data: None,
5062 deserializer: Some(self),
5063 event,
5064 allow_any,
5065 })
5066 }
5067 (ComplexBaseTypeDeserializerState::ComplexContent(deserializer), _) => {
5068 let DeserializerOutput {
5069 data,
5070 deserializer,
5071 event,
5072 allow_any,
5073 } = deserializer.next(reader, event)?;
5074 if let Some(data) = data {
5075 self.content
5076 .push(ComplexBaseTypeContent::ComplexContent(data));
5077 }
5078 if let Some(deserializer) = deserializer {
5079 *self.state =
5080 ComplexBaseTypeDeserializerState::ComplexContent(deserializer);
5081 }
5082 Ok(DeserializerOutput {
5083 data: None,
5084 deserializer: Some(self),
5085 event,
5086 allow_any,
5087 })
5088 }
5089 (ComplexBaseTypeDeserializerState::OpenContent(deserializer), _) => {
5090 let DeserializerOutput {
5091 data,
5092 deserializer,
5093 event,
5094 allow_any,
5095 } = deserializer.next(reader, event)?;
5096 if let Some(data) = data {
5097 self.content.push(ComplexBaseTypeContent::OpenContent(data));
5098 }
5099 if let Some(deserializer) = deserializer {
5100 *self.state = ComplexBaseTypeDeserializerState::OpenContent(deserializer);
5101 }
5102 Ok(DeserializerOutput {
5103 data: None,
5104 deserializer: Some(self),
5105 event,
5106 allow_any,
5107 })
5108 }
5109 (ComplexBaseTypeDeserializerState::Group(deserializer), _) => {
5110 let DeserializerOutput {
5111 data,
5112 deserializer,
5113 event,
5114 allow_any,
5115 } = deserializer.next(reader, event)?;
5116 if let Some(data) = data {
5117 self.content.push(ComplexBaseTypeContent::Group(data));
5118 }
5119 if let Some(deserializer) = deserializer {
5120 *self.state = ComplexBaseTypeDeserializerState::Group(deserializer);
5121 }
5122 Ok(DeserializerOutput {
5123 data: None,
5124 deserializer: Some(self),
5125 event,
5126 allow_any,
5127 })
5128 }
5129 (ComplexBaseTypeDeserializerState::All(deserializer), _) => {
5130 let DeserializerOutput {
5131 data,
5132 deserializer,
5133 event,
5134 allow_any,
5135 } = deserializer.next(reader, event)?;
5136 if let Some(data) = data {
5137 self.content.push(ComplexBaseTypeContent::All(data));
5138 }
5139 if let Some(deserializer) = deserializer {
5140 *self.state = ComplexBaseTypeDeserializerState::All(deserializer);
5141 }
5142 Ok(DeserializerOutput {
5143 data: None,
5144 deserializer: Some(self),
5145 event,
5146 allow_any,
5147 })
5148 }
5149 (ComplexBaseTypeDeserializerState::Choice(deserializer), _) => {
5150 let DeserializerOutput {
5151 data,
5152 deserializer,
5153 event,
5154 allow_any,
5155 } = deserializer.next(reader, event)?;
5156 if let Some(data) = data {
5157 self.content.push(ComplexBaseTypeContent::Choice(data));
5158 }
5159 if let Some(deserializer) = deserializer {
5160 *self.state = ComplexBaseTypeDeserializerState::Choice(deserializer);
5161 }
5162 Ok(DeserializerOutput {
5163 data: None,
5164 deserializer: Some(self),
5165 event,
5166 allow_any,
5167 })
5168 }
5169 (ComplexBaseTypeDeserializerState::Sequence(deserializer), _) => {
5170 let DeserializerOutput {
5171 data,
5172 deserializer,
5173 event,
5174 allow_any,
5175 } = deserializer.next(reader, event)?;
5176 if let Some(data) = data {
5177 self.content.push(ComplexBaseTypeContent::Sequence(data));
5178 }
5179 if let Some(deserializer) = deserializer {
5180 *self.state = ComplexBaseTypeDeserializerState::Sequence(deserializer);
5181 }
5182 Ok(DeserializerOutput {
5183 data: None,
5184 deserializer: Some(self),
5185 event,
5186 allow_any,
5187 })
5188 }
5189 (ComplexBaseTypeDeserializerState::Attribute(deserializer), _) => {
5190 let DeserializerOutput {
5191 data,
5192 deserializer,
5193 event,
5194 allow_any,
5195 } = deserializer.next(reader, event)?;
5196 if let Some(data) = data {
5197 self.content.push(ComplexBaseTypeContent::Attribute(data));
5198 }
5199 if let Some(deserializer) = deserializer {
5200 *self.state = ComplexBaseTypeDeserializerState::Attribute(deserializer);
5201 }
5202 Ok(DeserializerOutput {
5203 data: None,
5204 deserializer: Some(self),
5205 event,
5206 allow_any,
5207 })
5208 }
5209 (ComplexBaseTypeDeserializerState::AttributeGroup(deserializer), _) => {
5210 let DeserializerOutput {
5211 data,
5212 deserializer,
5213 event,
5214 allow_any,
5215 } = deserializer.next(reader, event)?;
5216 if let Some(data) = data {
5217 self.content
5218 .push(ComplexBaseTypeContent::AttributeGroup(data));
5219 }
5220 if let Some(deserializer) = deserializer {
5221 *self.state =
5222 ComplexBaseTypeDeserializerState::AttributeGroup(deserializer);
5223 }
5224 Ok(DeserializerOutput {
5225 data: None,
5226 deserializer: Some(self),
5227 event,
5228 allow_any,
5229 })
5230 }
5231 (ComplexBaseTypeDeserializerState::AnyAttribute(deserializer), _) => {
5232 let DeserializerOutput {
5233 data,
5234 deserializer,
5235 event,
5236 allow_any,
5237 } = deserializer.next(reader, event)?;
5238 if let Some(data) = data {
5239 self.content
5240 .push(ComplexBaseTypeContent::AnyAttribute(data));
5241 }
5242 if let Some(deserializer) = deserializer {
5243 *self.state = ComplexBaseTypeDeserializerState::AnyAttribute(deserializer);
5244 }
5245 Ok(DeserializerOutput {
5246 data: None,
5247 deserializer: Some(self),
5248 event,
5249 allow_any,
5250 })
5251 }
5252 (ComplexBaseTypeDeserializerState::Assert(deserializer), _) => {
5253 let DeserializerOutput {
5254 data,
5255 deserializer,
5256 event,
5257 allow_any,
5258 } = deserializer.next(reader, event)?;
5259 if let Some(data) = data {
5260 self.content.push(ComplexBaseTypeContent::Assert(data));
5261 }
5262 if let Some(deserializer) = deserializer {
5263 *self.state = ComplexBaseTypeDeserializerState::Assert(deserializer);
5264 }
5265 Ok(DeserializerOutput {
5266 data: None,
5267 deserializer: Some(self),
5268 event,
5269 allow_any,
5270 })
5271 }
5272 }
5273 }
5274 fn finish<R>(self, _reader: &R) -> Result<super::ComplexBaseType, crate::quick_xml::Error>
5275 where
5276 R: crate::quick_xml::XmlReader,
5277 {
5278 use crate::quick_xml::ErrorKind;
5279 Ok(super::ComplexBaseType {
5280 id: self.id,
5281 name: self.name,
5282 mixed: self.mixed,
5283 abstract_: self.abstract_,
5284 final_: self.final_,
5285 block: self.block,
5286 default_attributes_apply: self.default_attributes_apply,
5287 content: self.content,
5288 })
5289 }
5290 }
5291 #[derive(Debug)]
5292 pub struct GroupTypeDeserializer {
5293 id: Option<String>,
5294 name: Option<String>,
5295 ref_: Option<super::QName>,
5296 min_occurs: usize,
5297 max_occurs: super::MaxOccurs,
5298 content: Vec<super::GroupTypeContent>,
5299 state: Box<GroupTypeDeserializerState>,
5300 }
5301 #[derive(Debug)]
5302 enum GroupTypeDeserializerState {
5303 Next__,
5304 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
5305 Element(<ElementType as crate::quick_xml::WithDeserializer>::Deserializer),
5306 Group(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
5307 All(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
5308 Choice(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
5309 Sequence(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
5310 Any(<Any as crate::quick_xml::WithDeserializer>::Deserializer),
5311 }
5312 impl GroupTypeDeserializer {
5313 fn from_bytes_start<R>(
5314 reader: &R,
5315 bytes_start: &crate::quick_xml::BytesStart<'_>,
5316 ) -> Result<Self, crate::quick_xml::Error>
5317 where
5318 R: crate::quick_xml::XmlReader,
5319 {
5320 use crate::quick_xml::ErrorKind;
5321 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
5322 let mut id: Option<String> = None;
5323 let mut name: Option<String> = None;
5324 let mut ref_: Option<QName> = None;
5325 let mut min_occurs: Option<usize> = None;
5326 let mut max_occurs: Option<MaxOccurs> = None;
5327 for attrib in bytes_start.attributes() {
5328 let attrib = attrib?;
5329 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
5330 continue;
5331 }
5332 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
5333 reader.read_attrib(&mut id, b"id", &attrib.value)?;
5334 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"name")) {
5335 reader.read_attrib(&mut name, b"name", &attrib.value)?;
5336 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"ref")) {
5337 reader.read_attrib(&mut ref_, b"ref", &attrib.value)?;
5338 } else if matches!(
5339 reader.resolve_local_name(attrib.key, NS_XS),
5340 Some(b"minOccurs")
5341 ) {
5342 reader.read_attrib(&mut min_occurs, b"minOccurs", &attrib.value)?;
5343 } else if matches!(
5344 reader.resolve_local_name(attrib.key, NS_XS),
5345 Some(b"maxOccurs")
5346 ) {
5347 reader.read_attrib(&mut max_occurs, b"maxOccurs", &attrib.value)?;
5348 }
5349 }
5350 Ok(Self {
5351 id: id,
5352 name: name,
5353 ref_: ref_,
5354 min_occurs: min_occurs.unwrap_or_else(super::GroupType::default_min_occurs),
5355 max_occurs: max_occurs.unwrap_or_else(super::GroupType::default_max_occurs),
5356 content: Vec::new(),
5357 state: Box::new(GroupTypeDeserializerState::Next__),
5358 })
5359 }
5360 }
5361 impl<'de> crate::quick_xml::Deserializer<'de, super::GroupType> for GroupTypeDeserializer {
5362 fn init<R>(
5363 reader: &R,
5364 event: crate::quick_xml::Event<'de>,
5365 ) -> crate::quick_xml::DeserializerResult<'de, super::GroupType, Self>
5366 where
5367 R: crate::quick_xml::XmlReader,
5368 {
5369 use crate::quick_xml::{DeserializerOutput, Event};
5370 match event {
5371 Event::Start(start) => {
5372 let deserializer = Self::from_bytes_start(reader, &start)?;
5373 Ok(DeserializerOutput {
5374 data: None,
5375 deserializer: Some(deserializer),
5376 event: None,
5377 allow_any: false,
5378 })
5379 }
5380 Event::Empty(start) => {
5381 let deserializer = Self::from_bytes_start(reader, &start)?;
5382 let data = deserializer.finish(reader)?;
5383 Ok(DeserializerOutput {
5384 data: Some(data),
5385 deserializer: None,
5386 event: None,
5387 allow_any: false,
5388 })
5389 }
5390 event => Ok(DeserializerOutput {
5391 data: None,
5392 deserializer: None,
5393 event: Some(event),
5394 allow_any: false,
5395 }),
5396 }
5397 }
5398 fn next<R>(
5399 mut self,
5400 reader: &R,
5401 event: crate::quick_xml::Event<'de>,
5402 ) -> crate::quick_xml::DeserializerResult<'de, super::GroupType, Self>
5403 where
5404 R: crate::quick_xml::XmlReader,
5405 {
5406 use crate::quick_xml::{
5407 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
5408 };
5409 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
5410 match (
5411 core::mem::replace(&mut *self.state, GroupTypeDeserializerState::Next__),
5412 &event,
5413 ) {
5414 (GroupTypeDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
5415 if matches!(
5416 reader.resolve_local_name(x.name(), NS_XS),
5417 Some(b"annotation")
5418 ) {
5419 let DeserializerOutput {
5420 data,
5421 deserializer,
5422 event,
5423 allow_any,
5424 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
5425 if let Some(data) = data {
5426 self.content.push(GroupTypeContent::Annotation(data));
5427 }
5428 if let Some(deserializer) = deserializer {
5429 *self.state = GroupTypeDeserializerState::Annotation(deserializer);
5430 }
5431 Ok(DeserializerOutput {
5432 data: None,
5433 deserializer: Some(self),
5434 event,
5435 allow_any,
5436 })
5437 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"element"))
5438 {
5439 let DeserializerOutput {
5440 data,
5441 deserializer,
5442 event,
5443 allow_any,
5444 } = <ElementType as WithDeserializer>::Deserializer::init(reader, event)?;
5445 if let Some(data) = data {
5446 self.content.push(GroupTypeContent::Element(data));
5447 }
5448 if let Some(deserializer) = deserializer {
5449 *self.state = GroupTypeDeserializerState::Element(deserializer);
5450 }
5451 Ok(DeserializerOutput {
5452 data: None,
5453 deserializer: Some(self),
5454 event,
5455 allow_any,
5456 })
5457 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"group")) {
5458 let DeserializerOutput {
5459 data,
5460 deserializer,
5461 event,
5462 allow_any,
5463 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
5464 if let Some(data) = data {
5465 self.content.push(GroupTypeContent::Group(data));
5466 }
5467 if let Some(deserializer) = deserializer {
5468 *self.state = GroupTypeDeserializerState::Group(deserializer);
5469 }
5470 Ok(DeserializerOutput {
5471 data: None,
5472 deserializer: Some(self),
5473 event,
5474 allow_any,
5475 })
5476 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"all")) {
5477 let DeserializerOutput {
5478 data,
5479 deserializer,
5480 event,
5481 allow_any,
5482 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
5483 if let Some(data) = data {
5484 self.content.push(GroupTypeContent::All(data));
5485 }
5486 if let Some(deserializer) = deserializer {
5487 *self.state = GroupTypeDeserializerState::All(deserializer);
5488 }
5489 Ok(DeserializerOutput {
5490 data: None,
5491 deserializer: Some(self),
5492 event,
5493 allow_any,
5494 })
5495 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"choice"))
5496 {
5497 let DeserializerOutput {
5498 data,
5499 deserializer,
5500 event,
5501 allow_any,
5502 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
5503 if let Some(data) = data {
5504 self.content.push(GroupTypeContent::Choice(data));
5505 }
5506 if let Some(deserializer) = deserializer {
5507 *self.state = GroupTypeDeserializerState::Choice(deserializer);
5508 }
5509 Ok(DeserializerOutput {
5510 data: None,
5511 deserializer: Some(self),
5512 event,
5513 allow_any,
5514 })
5515 } else if matches!(
5516 reader.resolve_local_name(x.name(), NS_XS),
5517 Some(b"sequence")
5518 ) {
5519 let DeserializerOutput {
5520 data,
5521 deserializer,
5522 event,
5523 allow_any,
5524 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
5525 if let Some(data) = data {
5526 self.content.push(GroupTypeContent::Sequence(data));
5527 }
5528 if let Some(deserializer) = deserializer {
5529 *self.state = GroupTypeDeserializerState::Sequence(deserializer);
5530 }
5531 Ok(DeserializerOutput {
5532 data: None,
5533 deserializer: Some(self),
5534 event,
5535 allow_any,
5536 })
5537 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"any")) {
5538 let DeserializerOutput {
5539 data,
5540 deserializer,
5541 event,
5542 allow_any,
5543 } = <Any as WithDeserializer>::Deserializer::init(reader, event)?;
5544 if let Some(data) = data {
5545 self.content.push(GroupTypeContent::Any(data));
5546 }
5547 if let Some(deserializer) = deserializer {
5548 *self.state = GroupTypeDeserializerState::Any(deserializer);
5549 }
5550 Ok(DeserializerOutput {
5551 data: None,
5552 deserializer: Some(self),
5553 event,
5554 allow_any,
5555 })
5556 } else {
5557 Ok(DeserializerOutput {
5558 data: None,
5559 deserializer: Some(self),
5560 event: Some(event),
5561 allow_any: false,
5562 })
5563 }
5564 }
5565 (GroupTypeDeserializerState::Next__, Event::End(_)) => {
5566 let data = self.finish(reader)?;
5567 Ok(DeserializerOutput {
5568 data: Some(data),
5569 deserializer: None,
5570 event: None,
5571 allow_any: false,
5572 })
5573 }
5574 (GroupTypeDeserializerState::Next__, _) => Ok(DeserializerOutput {
5575 data: None,
5576 deserializer: Some(self),
5577 event: None,
5578 allow_any: false,
5579 }),
5580 (GroupTypeDeserializerState::Annotation(deserializer), _) => {
5581 let DeserializerOutput {
5582 data,
5583 deserializer,
5584 event,
5585 allow_any,
5586 } = deserializer.next(reader, event)?;
5587 if let Some(data) = data {
5588 self.content.push(GroupTypeContent::Annotation(data));
5589 }
5590 if let Some(deserializer) = deserializer {
5591 *self.state = GroupTypeDeserializerState::Annotation(deserializer);
5592 }
5593 Ok(DeserializerOutput {
5594 data: None,
5595 deserializer: Some(self),
5596 event,
5597 allow_any,
5598 })
5599 }
5600 (GroupTypeDeserializerState::Element(deserializer), _) => {
5601 let DeserializerOutput {
5602 data,
5603 deserializer,
5604 event,
5605 allow_any,
5606 } = deserializer.next(reader, event)?;
5607 if let Some(data) = data {
5608 self.content.push(GroupTypeContent::Element(data));
5609 }
5610 if let Some(deserializer) = deserializer {
5611 *self.state = GroupTypeDeserializerState::Element(deserializer);
5612 }
5613 Ok(DeserializerOutput {
5614 data: None,
5615 deserializer: Some(self),
5616 event,
5617 allow_any,
5618 })
5619 }
5620 (GroupTypeDeserializerState::Group(deserializer), _) => {
5621 let DeserializerOutput {
5622 data,
5623 deserializer,
5624 event,
5625 allow_any,
5626 } = deserializer.next(reader, event)?;
5627 if let Some(data) = data {
5628 self.content.push(GroupTypeContent::Group(data));
5629 }
5630 if let Some(deserializer) = deserializer {
5631 *self.state = GroupTypeDeserializerState::Group(deserializer);
5632 }
5633 Ok(DeserializerOutput {
5634 data: None,
5635 deserializer: Some(self),
5636 event,
5637 allow_any,
5638 })
5639 }
5640 (GroupTypeDeserializerState::All(deserializer), _) => {
5641 let DeserializerOutput {
5642 data,
5643 deserializer,
5644 event,
5645 allow_any,
5646 } = deserializer.next(reader, event)?;
5647 if let Some(data) = data {
5648 self.content.push(GroupTypeContent::All(data));
5649 }
5650 if let Some(deserializer) = deserializer {
5651 *self.state = GroupTypeDeserializerState::All(deserializer);
5652 }
5653 Ok(DeserializerOutput {
5654 data: None,
5655 deserializer: Some(self),
5656 event,
5657 allow_any,
5658 })
5659 }
5660 (GroupTypeDeserializerState::Choice(deserializer), _) => {
5661 let DeserializerOutput {
5662 data,
5663 deserializer,
5664 event,
5665 allow_any,
5666 } = deserializer.next(reader, event)?;
5667 if let Some(data) = data {
5668 self.content.push(GroupTypeContent::Choice(data));
5669 }
5670 if let Some(deserializer) = deserializer {
5671 *self.state = GroupTypeDeserializerState::Choice(deserializer);
5672 }
5673 Ok(DeserializerOutput {
5674 data: None,
5675 deserializer: Some(self),
5676 event,
5677 allow_any,
5678 })
5679 }
5680 (GroupTypeDeserializerState::Sequence(deserializer), _) => {
5681 let DeserializerOutput {
5682 data,
5683 deserializer,
5684 event,
5685 allow_any,
5686 } = deserializer.next(reader, event)?;
5687 if let Some(data) = data {
5688 self.content.push(GroupTypeContent::Sequence(data));
5689 }
5690 if let Some(deserializer) = deserializer {
5691 *self.state = GroupTypeDeserializerState::Sequence(deserializer);
5692 }
5693 Ok(DeserializerOutput {
5694 data: None,
5695 deserializer: Some(self),
5696 event,
5697 allow_any,
5698 })
5699 }
5700 (GroupTypeDeserializerState::Any(deserializer), _) => {
5701 let DeserializerOutput {
5702 data,
5703 deserializer,
5704 event,
5705 allow_any,
5706 } = deserializer.next(reader, event)?;
5707 if let Some(data) = data {
5708 self.content.push(GroupTypeContent::Any(data));
5709 }
5710 if let Some(deserializer) = deserializer {
5711 *self.state = GroupTypeDeserializerState::Any(deserializer);
5712 }
5713 Ok(DeserializerOutput {
5714 data: None,
5715 deserializer: Some(self),
5716 event,
5717 allow_any,
5718 })
5719 }
5720 }
5721 }
5722 fn finish<R>(self, _reader: &R) -> Result<super::GroupType, crate::quick_xml::Error>
5723 where
5724 R: crate::quick_xml::XmlReader,
5725 {
5726 use crate::quick_xml::ErrorKind;
5727 Ok(super::GroupType {
5728 id: self.id,
5729 name: self.name,
5730 ref_: self.ref_,
5731 min_occurs: self.min_occurs,
5732 max_occurs: self.max_occurs,
5733 content: self.content,
5734 })
5735 }
5736 }
5737 #[derive(Debug)]
5738 pub struct AttributeGroupTypeDeserializer {
5739 id: Option<String>,
5740 name: Option<String>,
5741 ref_: Option<super::QName>,
5742 content: Vec<super::AttributeGroupTypeContent>,
5743 state: Box<AttributeGroupTypeDeserializerState>,
5744 }
5745 #[derive(Debug)]
5746 enum AttributeGroupTypeDeserializerState {
5747 Next__,
5748 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
5749 Attribute(<AttributeType as crate::quick_xml::WithDeserializer>::Deserializer),
5750 AttributeGroup(<AttributeGroupType as crate::quick_xml::WithDeserializer>::Deserializer),
5751 AnyAttribute(<AnyAttribute as crate::quick_xml::WithDeserializer>::Deserializer),
5752 }
5753 impl AttributeGroupTypeDeserializer {
5754 fn from_bytes_start<R>(
5755 reader: &R,
5756 bytes_start: &crate::quick_xml::BytesStart<'_>,
5757 ) -> Result<Self, crate::quick_xml::Error>
5758 where
5759 R: crate::quick_xml::XmlReader,
5760 {
5761 use crate::quick_xml::ErrorKind;
5762 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
5763 let mut id: Option<String> = None;
5764 let mut name: Option<String> = None;
5765 let mut ref_: Option<QName> = None;
5766 for attrib in bytes_start.attributes() {
5767 let attrib = attrib?;
5768 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
5769 continue;
5770 }
5771 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
5772 reader.read_attrib(&mut id, b"id", &attrib.value)?;
5773 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"name")) {
5774 reader.read_attrib(&mut name, b"name", &attrib.value)?;
5775 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"ref")) {
5776 reader.read_attrib(&mut ref_, b"ref", &attrib.value)?;
5777 }
5778 }
5779 Ok(Self {
5780 id: id,
5781 name: name,
5782 ref_: ref_,
5783 content: Vec::new(),
5784 state: Box::new(AttributeGroupTypeDeserializerState::Next__),
5785 })
5786 }
5787 }
5788 impl<'de> crate::quick_xml::Deserializer<'de, super::AttributeGroupType>
5789 for AttributeGroupTypeDeserializer
5790 {
5791 fn init<R>(
5792 reader: &R,
5793 event: crate::quick_xml::Event<'de>,
5794 ) -> crate::quick_xml::DeserializerResult<'de, super::AttributeGroupType, Self>
5795 where
5796 R: crate::quick_xml::XmlReader,
5797 {
5798 use crate::quick_xml::{DeserializerOutput, Event};
5799 match event {
5800 Event::Start(start) => {
5801 let deserializer = Self::from_bytes_start(reader, &start)?;
5802 Ok(DeserializerOutput {
5803 data: None,
5804 deserializer: Some(deserializer),
5805 event: None,
5806 allow_any: false,
5807 })
5808 }
5809 Event::Empty(start) => {
5810 let deserializer = Self::from_bytes_start(reader, &start)?;
5811 let data = deserializer.finish(reader)?;
5812 Ok(DeserializerOutput {
5813 data: Some(data),
5814 deserializer: None,
5815 event: None,
5816 allow_any: false,
5817 })
5818 }
5819 event => Ok(DeserializerOutput {
5820 data: None,
5821 deserializer: None,
5822 event: Some(event),
5823 allow_any: false,
5824 }),
5825 }
5826 }
5827 fn next<R>(
5828 mut self,
5829 reader: &R,
5830 event: crate::quick_xml::Event<'de>,
5831 ) -> crate::quick_xml::DeserializerResult<'de, super::AttributeGroupType, Self>
5832 where
5833 R: crate::quick_xml::XmlReader,
5834 {
5835 use crate::quick_xml::{
5836 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
5837 };
5838 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
5839 match (
5840 core::mem::replace(
5841 &mut *self.state,
5842 AttributeGroupTypeDeserializerState::Next__,
5843 ),
5844 &event,
5845 ) {
5846 (
5847 AttributeGroupTypeDeserializerState::Next__,
5848 Event::Start(x) | Event::Empty(x),
5849 ) => {
5850 if matches!(
5851 reader.resolve_local_name(x.name(), NS_XS),
5852 Some(b"annotation")
5853 ) {
5854 let DeserializerOutput {
5855 data,
5856 deserializer,
5857 event,
5858 allow_any,
5859 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
5860 if let Some(data) = data {
5861 self.content
5862 .push(AttributeGroupTypeContent::Annotation(data));
5863 }
5864 if let Some(deserializer) = deserializer {
5865 *self.state =
5866 AttributeGroupTypeDeserializerState::Annotation(deserializer);
5867 }
5868 Ok(DeserializerOutput {
5869 data: None,
5870 deserializer: Some(self),
5871 event,
5872 allow_any,
5873 })
5874 } else if matches!(
5875 reader.resolve_local_name(x.name(), NS_XS),
5876 Some(b"attribute")
5877 ) {
5878 let DeserializerOutput {
5879 data,
5880 deserializer,
5881 event,
5882 allow_any,
5883 } = <AttributeType as WithDeserializer>::Deserializer::init(reader, event)?;
5884 if let Some(data) = data {
5885 self.content
5886 .push(AttributeGroupTypeContent::Attribute(data));
5887 }
5888 if let Some(deserializer) = deserializer {
5889 *self.state =
5890 AttributeGroupTypeDeserializerState::Attribute(deserializer);
5891 }
5892 Ok(DeserializerOutput {
5893 data: None,
5894 deserializer: Some(self),
5895 event,
5896 allow_any,
5897 })
5898 } else if matches!(
5899 reader.resolve_local_name(x.name(), NS_XS),
5900 Some(b"attributeGroup")
5901 ) {
5902 let DeserializerOutput {
5903 data,
5904 deserializer,
5905 event,
5906 allow_any,
5907 } = <AttributeGroupType as WithDeserializer>::Deserializer::init(
5908 reader, event,
5909 )?;
5910 if let Some(data) = data {
5911 self.content
5912 .push(AttributeGroupTypeContent::AttributeGroup(data));
5913 }
5914 if let Some(deserializer) = deserializer {
5915 *self.state =
5916 AttributeGroupTypeDeserializerState::AttributeGroup(deserializer);
5917 }
5918 Ok(DeserializerOutput {
5919 data: None,
5920 deserializer: Some(self),
5921 event,
5922 allow_any,
5923 })
5924 } else if matches!(
5925 reader.resolve_local_name(x.name(), NS_XS),
5926 Some(b"anyAttribute")
5927 ) {
5928 let DeserializerOutput {
5929 data,
5930 deserializer,
5931 event,
5932 allow_any,
5933 } = <AnyAttribute as WithDeserializer>::Deserializer::init(reader, event)?;
5934 if let Some(data) = data {
5935 self.content
5936 .push(AttributeGroupTypeContent::AnyAttribute(data));
5937 }
5938 if let Some(deserializer) = deserializer {
5939 *self.state =
5940 AttributeGroupTypeDeserializerState::AnyAttribute(deserializer);
5941 }
5942 Ok(DeserializerOutput {
5943 data: None,
5944 deserializer: Some(self),
5945 event,
5946 allow_any,
5947 })
5948 } else {
5949 Ok(DeserializerOutput {
5950 data: None,
5951 deserializer: Some(self),
5952 event: Some(event),
5953 allow_any: false,
5954 })
5955 }
5956 }
5957 (AttributeGroupTypeDeserializerState::Next__, Event::End(_)) => {
5958 let data = self.finish(reader)?;
5959 Ok(DeserializerOutput {
5960 data: Some(data),
5961 deserializer: None,
5962 event: None,
5963 allow_any: false,
5964 })
5965 }
5966 (AttributeGroupTypeDeserializerState::Next__, _) => Ok(DeserializerOutput {
5967 data: None,
5968 deserializer: Some(self),
5969 event: None,
5970 allow_any: false,
5971 }),
5972 (AttributeGroupTypeDeserializerState::Annotation(deserializer), _) => {
5973 let DeserializerOutput {
5974 data,
5975 deserializer,
5976 event,
5977 allow_any,
5978 } = deserializer.next(reader, event)?;
5979 if let Some(data) = data {
5980 self.content
5981 .push(AttributeGroupTypeContent::Annotation(data));
5982 }
5983 if let Some(deserializer) = deserializer {
5984 *self.state = AttributeGroupTypeDeserializerState::Annotation(deserializer);
5985 }
5986 Ok(DeserializerOutput {
5987 data: None,
5988 deserializer: Some(self),
5989 event,
5990 allow_any,
5991 })
5992 }
5993 (AttributeGroupTypeDeserializerState::Attribute(deserializer), _) => {
5994 let DeserializerOutput {
5995 data,
5996 deserializer,
5997 event,
5998 allow_any,
5999 } = deserializer.next(reader, event)?;
6000 if let Some(data) = data {
6001 self.content
6002 .push(AttributeGroupTypeContent::Attribute(data));
6003 }
6004 if let Some(deserializer) = deserializer {
6005 *self.state = AttributeGroupTypeDeserializerState::Attribute(deserializer);
6006 }
6007 Ok(DeserializerOutput {
6008 data: None,
6009 deserializer: Some(self),
6010 event,
6011 allow_any,
6012 })
6013 }
6014 (AttributeGroupTypeDeserializerState::AttributeGroup(deserializer), _) => {
6015 let DeserializerOutput {
6016 data,
6017 deserializer,
6018 event,
6019 allow_any,
6020 } = deserializer.next(reader, event)?;
6021 if let Some(data) = data {
6022 self.content
6023 .push(AttributeGroupTypeContent::AttributeGroup(data));
6024 }
6025 if let Some(deserializer) = deserializer {
6026 *self.state =
6027 AttributeGroupTypeDeserializerState::AttributeGroup(deserializer);
6028 }
6029 Ok(DeserializerOutput {
6030 data: None,
6031 deserializer: Some(self),
6032 event,
6033 allow_any,
6034 })
6035 }
6036 (AttributeGroupTypeDeserializerState::AnyAttribute(deserializer), _) => {
6037 let DeserializerOutput {
6038 data,
6039 deserializer,
6040 event,
6041 allow_any,
6042 } = deserializer.next(reader, event)?;
6043 if let Some(data) = data {
6044 self.content
6045 .push(AttributeGroupTypeContent::AnyAttribute(data));
6046 }
6047 if let Some(deserializer) = deserializer {
6048 *self.state =
6049 AttributeGroupTypeDeserializerState::AnyAttribute(deserializer);
6050 }
6051 Ok(DeserializerOutput {
6052 data: None,
6053 deserializer: Some(self),
6054 event,
6055 allow_any,
6056 })
6057 }
6058 }
6059 }
6060 fn finish<R>(
6061 self,
6062 _reader: &R,
6063 ) -> Result<super::AttributeGroupType, crate::quick_xml::Error>
6064 where
6065 R: crate::quick_xml::XmlReader,
6066 {
6067 use crate::quick_xml::ErrorKind;
6068 Ok(super::AttributeGroupType {
6069 id: self.id,
6070 name: self.name,
6071 ref_: self.ref_,
6072 content: self.content,
6073 })
6074 }
6075 }
6076 #[derive(Debug)]
6077 pub struct ElementTypeDeserializer {
6078 id: Option<String>,
6079 name: Option<String>,
6080 ref_: Option<super::QName>,
6081 type_: Option<super::QName>,
6082 substitution_group: Option<super::ElementSubstitutionGroupType>,
6083 min_occurs: usize,
6084 max_occurs: super::MaxOccurs,
6085 default: Option<String>,
6086 fixed: Option<String>,
6087 nillable: Option<bool>,
6088 abstract_: bool,
6089 final_: Option<super::DerivationSetType>,
6090 block: Option<super::BlockSetType>,
6091 form: Option<super::FormChoiceType>,
6092 target_namespace: Option<String>,
6093 content: Vec<super::ElementTypeContent>,
6094 state: Box<ElementTypeDeserializerState>,
6095 }
6096 #[derive(Debug)]
6097 enum ElementTypeDeserializerState {
6098 Next__,
6099 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
6100 SimpleType(<SimpleBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
6101 ComplexType(<ComplexBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
6102 Alternative(<AltType as crate::quick_xml::WithDeserializer>::Deserializer),
6103 Unique(<KeybaseType as crate::quick_xml::WithDeserializer>::Deserializer),
6104 Key(<KeybaseType as crate::quick_xml::WithDeserializer>::Deserializer),
6105 Keyref(<Keyref as crate::quick_xml::WithDeserializer>::Deserializer),
6106 }
6107 impl ElementTypeDeserializer {
6108 fn from_bytes_start<R>(
6109 reader: &R,
6110 bytes_start: &crate::quick_xml::BytesStart<'_>,
6111 ) -> Result<Self, crate::quick_xml::Error>
6112 where
6113 R: crate::quick_xml::XmlReader,
6114 {
6115 use crate::quick_xml::ErrorKind;
6116 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
6117 let mut id: Option<String> = None;
6118 let mut name: Option<String> = None;
6119 let mut ref_: Option<QName> = None;
6120 let mut type_: Option<QName> = None;
6121 let mut substitution_group: Option<ElementSubstitutionGroupType> = None;
6122 let mut min_occurs: Option<usize> = None;
6123 let mut max_occurs: Option<MaxOccurs> = None;
6124 let mut default: Option<String> = None;
6125 let mut fixed: Option<String> = None;
6126 let mut nillable: Option<bool> = None;
6127 let mut abstract_: Option<bool> = None;
6128 let mut final_: Option<DerivationSetType> = None;
6129 let mut block: Option<BlockSetType> = None;
6130 let mut form: Option<FormChoiceType> = None;
6131 let mut target_namespace: Option<String> = None;
6132 for attrib in bytes_start.attributes() {
6133 let attrib = attrib?;
6134 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
6135 continue;
6136 }
6137 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
6138 reader.read_attrib(&mut id, b"id", &attrib.value)?;
6139 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"name")) {
6140 reader.read_attrib(&mut name, b"name", &attrib.value)?;
6141 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"ref")) {
6142 reader.read_attrib(&mut ref_, b"ref", &attrib.value)?;
6143 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"type")) {
6144 reader.read_attrib(&mut type_, b"type", &attrib.value)?;
6145 } else if matches!(
6146 reader.resolve_local_name(attrib.key, NS_XS),
6147 Some(b"substitutionGroup")
6148 ) {
6149 reader.read_attrib(
6150 &mut substitution_group,
6151 b"substitutionGroup",
6152 &attrib.value,
6153 )?;
6154 } else if matches!(
6155 reader.resolve_local_name(attrib.key, NS_XS),
6156 Some(b"minOccurs")
6157 ) {
6158 reader.read_attrib(&mut min_occurs, b"minOccurs", &attrib.value)?;
6159 } else if matches!(
6160 reader.resolve_local_name(attrib.key, NS_XS),
6161 Some(b"maxOccurs")
6162 ) {
6163 reader.read_attrib(&mut max_occurs, b"maxOccurs", &attrib.value)?;
6164 } else if matches!(
6165 reader.resolve_local_name(attrib.key, NS_XS),
6166 Some(b"default")
6167 ) {
6168 reader.read_attrib(&mut default, b"default", &attrib.value)?;
6169 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"fixed")) {
6170 reader.read_attrib(&mut fixed, b"fixed", &attrib.value)?;
6171 } else if matches!(
6172 reader.resolve_local_name(attrib.key, NS_XS),
6173 Some(b"nillable")
6174 ) {
6175 reader.read_attrib(&mut nillable, b"nillable", &attrib.value)?;
6176 } else if matches!(
6177 reader.resolve_local_name(attrib.key, NS_XS),
6178 Some(b"abstract")
6179 ) {
6180 reader.read_attrib(&mut abstract_, b"abstract", &attrib.value)?;
6181 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"final")) {
6182 reader.read_attrib(&mut final_, b"final", &attrib.value)?;
6183 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"block")) {
6184 reader.read_attrib(&mut block, b"block", &attrib.value)?;
6185 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"form")) {
6186 reader.read_attrib(&mut form, b"form", &attrib.value)?;
6187 } else if matches!(
6188 reader.resolve_local_name(attrib.key, NS_XS),
6189 Some(b"targetNamespace")
6190 ) {
6191 reader.read_attrib(&mut target_namespace, b"targetNamespace", &attrib.value)?;
6192 }
6193 }
6194 Ok(Self {
6195 id: id,
6196 name: name,
6197 ref_: ref_,
6198 type_: type_,
6199 substitution_group: substitution_group,
6200 min_occurs: min_occurs.unwrap_or_else(super::ElementType::default_min_occurs),
6201 max_occurs: max_occurs.unwrap_or_else(super::ElementType::default_max_occurs),
6202 default: default,
6203 fixed: fixed,
6204 nillable: nillable,
6205 abstract_: abstract_.unwrap_or_else(super::ElementType::default_abstract_),
6206 final_: final_,
6207 block: block,
6208 form: form,
6209 target_namespace: target_namespace,
6210 content: Vec::new(),
6211 state: Box::new(ElementTypeDeserializerState::Next__),
6212 })
6213 }
6214 }
6215 impl<'de> crate::quick_xml::Deserializer<'de, super::ElementType> for ElementTypeDeserializer {
6216 fn init<R>(
6217 reader: &R,
6218 event: crate::quick_xml::Event<'de>,
6219 ) -> crate::quick_xml::DeserializerResult<'de, super::ElementType, Self>
6220 where
6221 R: crate::quick_xml::XmlReader,
6222 {
6223 use crate::quick_xml::{DeserializerOutput, Event};
6224 match event {
6225 Event::Start(start) => {
6226 let deserializer = Self::from_bytes_start(reader, &start)?;
6227 Ok(DeserializerOutput {
6228 data: None,
6229 deserializer: Some(deserializer),
6230 event: None,
6231 allow_any: false,
6232 })
6233 }
6234 Event::Empty(start) => {
6235 let deserializer = Self::from_bytes_start(reader, &start)?;
6236 let data = deserializer.finish(reader)?;
6237 Ok(DeserializerOutput {
6238 data: Some(data),
6239 deserializer: None,
6240 event: None,
6241 allow_any: false,
6242 })
6243 }
6244 event => Ok(DeserializerOutput {
6245 data: None,
6246 deserializer: None,
6247 event: Some(event),
6248 allow_any: false,
6249 }),
6250 }
6251 }
6252 fn next<R>(
6253 mut self,
6254 reader: &R,
6255 event: crate::quick_xml::Event<'de>,
6256 ) -> crate::quick_xml::DeserializerResult<'de, super::ElementType, Self>
6257 where
6258 R: crate::quick_xml::XmlReader,
6259 {
6260 use crate::quick_xml::{
6261 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
6262 };
6263 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
6264 match (
6265 core::mem::replace(&mut *self.state, ElementTypeDeserializerState::Next__),
6266 &event,
6267 ) {
6268 (ElementTypeDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
6269 if matches!(
6270 reader.resolve_local_name(x.name(), NS_XS),
6271 Some(b"annotation")
6272 ) {
6273 let DeserializerOutput {
6274 data,
6275 deserializer,
6276 event,
6277 allow_any,
6278 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
6279 if let Some(data) = data {
6280 self.content.push(ElementTypeContent::Annotation(data));
6281 }
6282 if let Some(deserializer) = deserializer {
6283 *self.state = ElementTypeDeserializerState::Annotation(deserializer);
6284 }
6285 Ok(DeserializerOutput {
6286 data: None,
6287 deserializer: Some(self),
6288 event,
6289 allow_any,
6290 })
6291 } else if matches!(
6292 reader.resolve_local_name(x.name(), NS_XS),
6293 Some(b"simpleType")
6294 ) {
6295 let DeserializerOutput {
6296 data,
6297 deserializer,
6298 event,
6299 allow_any,
6300 } = <SimpleBaseType as WithDeserializer>::Deserializer::init(
6301 reader, event,
6302 )?;
6303 if let Some(data) = data {
6304 self.content.push(ElementTypeContent::SimpleType(data));
6305 }
6306 if let Some(deserializer) = deserializer {
6307 *self.state = ElementTypeDeserializerState::SimpleType(deserializer);
6308 }
6309 Ok(DeserializerOutput {
6310 data: None,
6311 deserializer: Some(self),
6312 event,
6313 allow_any,
6314 })
6315 } else if matches!(
6316 reader.resolve_local_name(x.name(), NS_XS),
6317 Some(b"complexType")
6318 ) {
6319 let DeserializerOutput {
6320 data,
6321 deserializer,
6322 event,
6323 allow_any,
6324 } = <ComplexBaseType as WithDeserializer>::Deserializer::init(
6325 reader, event,
6326 )?;
6327 if let Some(data) = data {
6328 self.content.push(ElementTypeContent::ComplexType(data));
6329 }
6330 if let Some(deserializer) = deserializer {
6331 *self.state = ElementTypeDeserializerState::ComplexType(deserializer);
6332 }
6333 Ok(DeserializerOutput {
6334 data: None,
6335 deserializer: Some(self),
6336 event,
6337 allow_any,
6338 })
6339 } else if matches!(
6340 reader.resolve_local_name(x.name(), NS_XS),
6341 Some(b"alternative")
6342 ) {
6343 let DeserializerOutput {
6344 data,
6345 deserializer,
6346 event,
6347 allow_any,
6348 } = <AltType as WithDeserializer>::Deserializer::init(reader, event)?;
6349 if let Some(data) = data {
6350 self.content.push(ElementTypeContent::Alternative(data));
6351 }
6352 if let Some(deserializer) = deserializer {
6353 *self.state = ElementTypeDeserializerState::Alternative(deserializer);
6354 }
6355 Ok(DeserializerOutput {
6356 data: None,
6357 deserializer: Some(self),
6358 event,
6359 allow_any,
6360 })
6361 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"unique"))
6362 {
6363 let DeserializerOutput {
6364 data,
6365 deserializer,
6366 event,
6367 allow_any,
6368 } = <KeybaseType as WithDeserializer>::Deserializer::init(reader, event)?;
6369 if let Some(data) = data {
6370 self.content.push(ElementTypeContent::Unique(data));
6371 }
6372 if let Some(deserializer) = deserializer {
6373 *self.state = ElementTypeDeserializerState::Unique(deserializer);
6374 }
6375 Ok(DeserializerOutput {
6376 data: None,
6377 deserializer: Some(self),
6378 event,
6379 allow_any,
6380 })
6381 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"key")) {
6382 let DeserializerOutput {
6383 data,
6384 deserializer,
6385 event,
6386 allow_any,
6387 } = <KeybaseType as WithDeserializer>::Deserializer::init(reader, event)?;
6388 if let Some(data) = data {
6389 self.content.push(ElementTypeContent::Key(data));
6390 }
6391 if let Some(deserializer) = deserializer {
6392 *self.state = ElementTypeDeserializerState::Key(deserializer);
6393 }
6394 Ok(DeserializerOutput {
6395 data: None,
6396 deserializer: Some(self),
6397 event,
6398 allow_any,
6399 })
6400 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"keyref"))
6401 {
6402 let DeserializerOutput {
6403 data,
6404 deserializer,
6405 event,
6406 allow_any,
6407 } = <Keyref as WithDeserializer>::Deserializer::init(reader, event)?;
6408 if let Some(data) = data {
6409 self.content.push(ElementTypeContent::Keyref(data));
6410 }
6411 if let Some(deserializer) = deserializer {
6412 *self.state = ElementTypeDeserializerState::Keyref(deserializer);
6413 }
6414 Ok(DeserializerOutput {
6415 data: None,
6416 deserializer: Some(self),
6417 event,
6418 allow_any,
6419 })
6420 } else {
6421 Ok(DeserializerOutput {
6422 data: None,
6423 deserializer: Some(self),
6424 event: Some(event),
6425 allow_any: false,
6426 })
6427 }
6428 }
6429 (ElementTypeDeserializerState::Next__, Event::End(_)) => {
6430 let data = self.finish(reader)?;
6431 Ok(DeserializerOutput {
6432 data: Some(data),
6433 deserializer: None,
6434 event: None,
6435 allow_any: false,
6436 })
6437 }
6438 (ElementTypeDeserializerState::Next__, _) => Ok(DeserializerOutput {
6439 data: None,
6440 deserializer: Some(self),
6441 event: None,
6442 allow_any: false,
6443 }),
6444 (ElementTypeDeserializerState::Annotation(deserializer), _) => {
6445 let DeserializerOutput {
6446 data,
6447 deserializer,
6448 event,
6449 allow_any,
6450 } = deserializer.next(reader, event)?;
6451 if let Some(data) = data {
6452 self.content.push(ElementTypeContent::Annotation(data));
6453 }
6454 if let Some(deserializer) = deserializer {
6455 *self.state = ElementTypeDeserializerState::Annotation(deserializer);
6456 }
6457 Ok(DeserializerOutput {
6458 data: None,
6459 deserializer: Some(self),
6460 event,
6461 allow_any,
6462 })
6463 }
6464 (ElementTypeDeserializerState::SimpleType(deserializer), _) => {
6465 let DeserializerOutput {
6466 data,
6467 deserializer,
6468 event,
6469 allow_any,
6470 } = deserializer.next(reader, event)?;
6471 if let Some(data) = data {
6472 self.content.push(ElementTypeContent::SimpleType(data));
6473 }
6474 if let Some(deserializer) = deserializer {
6475 *self.state = ElementTypeDeserializerState::SimpleType(deserializer);
6476 }
6477 Ok(DeserializerOutput {
6478 data: None,
6479 deserializer: Some(self),
6480 event,
6481 allow_any,
6482 })
6483 }
6484 (ElementTypeDeserializerState::ComplexType(deserializer), _) => {
6485 let DeserializerOutput {
6486 data,
6487 deserializer,
6488 event,
6489 allow_any,
6490 } = deserializer.next(reader, event)?;
6491 if let Some(data) = data {
6492 self.content.push(ElementTypeContent::ComplexType(data));
6493 }
6494 if let Some(deserializer) = deserializer {
6495 *self.state = ElementTypeDeserializerState::ComplexType(deserializer);
6496 }
6497 Ok(DeserializerOutput {
6498 data: None,
6499 deserializer: Some(self),
6500 event,
6501 allow_any,
6502 })
6503 }
6504 (ElementTypeDeserializerState::Alternative(deserializer), _) => {
6505 let DeserializerOutput {
6506 data,
6507 deserializer,
6508 event,
6509 allow_any,
6510 } = deserializer.next(reader, event)?;
6511 if let Some(data) = data {
6512 self.content.push(ElementTypeContent::Alternative(data));
6513 }
6514 if let Some(deserializer) = deserializer {
6515 *self.state = ElementTypeDeserializerState::Alternative(deserializer);
6516 }
6517 Ok(DeserializerOutput {
6518 data: None,
6519 deserializer: Some(self),
6520 event,
6521 allow_any,
6522 })
6523 }
6524 (ElementTypeDeserializerState::Unique(deserializer), _) => {
6525 let DeserializerOutput {
6526 data,
6527 deserializer,
6528 event,
6529 allow_any,
6530 } = deserializer.next(reader, event)?;
6531 if let Some(data) = data {
6532 self.content.push(ElementTypeContent::Unique(data));
6533 }
6534 if let Some(deserializer) = deserializer {
6535 *self.state = ElementTypeDeserializerState::Unique(deserializer);
6536 }
6537 Ok(DeserializerOutput {
6538 data: None,
6539 deserializer: Some(self),
6540 event,
6541 allow_any,
6542 })
6543 }
6544 (ElementTypeDeserializerState::Key(deserializer), _) => {
6545 let DeserializerOutput {
6546 data,
6547 deserializer,
6548 event,
6549 allow_any,
6550 } = deserializer.next(reader, event)?;
6551 if let Some(data) = data {
6552 self.content.push(ElementTypeContent::Key(data));
6553 }
6554 if let Some(deserializer) = deserializer {
6555 *self.state = ElementTypeDeserializerState::Key(deserializer);
6556 }
6557 Ok(DeserializerOutput {
6558 data: None,
6559 deserializer: Some(self),
6560 event,
6561 allow_any,
6562 })
6563 }
6564 (ElementTypeDeserializerState::Keyref(deserializer), _) => {
6565 let DeserializerOutput {
6566 data,
6567 deserializer,
6568 event,
6569 allow_any,
6570 } = deserializer.next(reader, event)?;
6571 if let Some(data) = data {
6572 self.content.push(ElementTypeContent::Keyref(data));
6573 }
6574 if let Some(deserializer) = deserializer {
6575 *self.state = ElementTypeDeserializerState::Keyref(deserializer);
6576 }
6577 Ok(DeserializerOutput {
6578 data: None,
6579 deserializer: Some(self),
6580 event,
6581 allow_any,
6582 })
6583 }
6584 }
6585 }
6586 fn finish<R>(self, _reader: &R) -> Result<super::ElementType, crate::quick_xml::Error>
6587 where
6588 R: crate::quick_xml::XmlReader,
6589 {
6590 use crate::quick_xml::ErrorKind;
6591 Ok(super::ElementType {
6592 id: self.id,
6593 name: self.name,
6594 ref_: self.ref_,
6595 type_: self.type_,
6596 substitution_group: self.substitution_group,
6597 min_occurs: self.min_occurs,
6598 max_occurs: self.max_occurs,
6599 default: self.default,
6600 fixed: self.fixed,
6601 nillable: self.nillable,
6602 abstract_: self.abstract_,
6603 final_: self.final_,
6604 block: self.block,
6605 form: self.form,
6606 target_namespace: self.target_namespace,
6607 content: self.content,
6608 })
6609 }
6610 }
6611 #[derive(Debug)]
6612 pub struct AttributeTypeDeserializer {
6613 id: Option<String>,
6614 name: Option<String>,
6615 ref_: Option<super::QName>,
6616 type_: Option<super::QName>,
6617 use_: super::AttributeUseType,
6618 default: Option<String>,
6619 fixed: Option<String>,
6620 form: Option<super::FormChoiceType>,
6621 target_namespace: Option<String>,
6622 inheritable: Option<bool>,
6623 annotation: Option<super::Annotation>,
6624 simple_type: Option<super::SimpleBaseType>,
6625 state: Box<AttributeTypeDeserializerState>,
6626 }
6627 #[derive(Debug)]
6628 enum AttributeTypeDeserializerState {
6629 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
6630 SimpleType(Option<<SimpleBaseType as crate::quick_xml::WithDeserializer>::Deserializer>),
6631 Done__,
6632 }
6633 impl AttributeTypeDeserializer {
6634 fn from_bytes_start<R>(
6635 reader: &R,
6636 bytes_start: &crate::quick_xml::BytesStart<'_>,
6637 ) -> Result<Self, crate::quick_xml::Error>
6638 where
6639 R: crate::quick_xml::XmlReader,
6640 {
6641 use crate::quick_xml::ErrorKind;
6642 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
6643 let mut id: Option<String> = None;
6644 let mut name: Option<String> = None;
6645 let mut ref_: Option<QName> = None;
6646 let mut type_: Option<QName> = None;
6647 let mut use_: Option<AttributeUseType> = None;
6648 let mut default: Option<String> = None;
6649 let mut fixed: Option<String> = None;
6650 let mut form: Option<FormChoiceType> = None;
6651 let mut target_namespace: Option<String> = None;
6652 let mut inheritable: Option<bool> = None;
6653 for attrib in bytes_start.attributes() {
6654 let attrib = attrib?;
6655 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
6656 continue;
6657 }
6658 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
6659 reader.read_attrib(&mut id, b"id", &attrib.value)?;
6660 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"name")) {
6661 reader.read_attrib(&mut name, b"name", &attrib.value)?;
6662 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"ref")) {
6663 reader.read_attrib(&mut ref_, b"ref", &attrib.value)?;
6664 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"type")) {
6665 reader.read_attrib(&mut type_, b"type", &attrib.value)?;
6666 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"use")) {
6667 reader.read_attrib(&mut use_, b"use", &attrib.value)?;
6668 } else if matches!(
6669 reader.resolve_local_name(attrib.key, NS_XS),
6670 Some(b"default")
6671 ) {
6672 reader.read_attrib(&mut default, b"default", &attrib.value)?;
6673 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"fixed")) {
6674 reader.read_attrib(&mut fixed, b"fixed", &attrib.value)?;
6675 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"form")) {
6676 reader.read_attrib(&mut form, b"form", &attrib.value)?;
6677 } else if matches!(
6678 reader.resolve_local_name(attrib.key, NS_XS),
6679 Some(b"targetNamespace")
6680 ) {
6681 reader.read_attrib(&mut target_namespace, b"targetNamespace", &attrib.value)?;
6682 } else if matches!(
6683 reader.resolve_local_name(attrib.key, NS_XS),
6684 Some(b"inheritable")
6685 ) {
6686 reader.read_attrib(&mut inheritable, b"inheritable", &attrib.value)?;
6687 }
6688 }
6689 Ok(Self {
6690 id: id,
6691 name: name,
6692 ref_: ref_,
6693 type_: type_,
6694 use_: use_.unwrap_or_else(super::AttributeType::default_use_),
6695 default: default,
6696 fixed: fixed,
6697 form: form,
6698 target_namespace: target_namespace,
6699 inheritable: inheritable,
6700 annotation: None,
6701 simple_type: None,
6702 state: Box::new(AttributeTypeDeserializerState::Annotation(None)),
6703 })
6704 }
6705 }
6706 impl<'de> crate::quick_xml::Deserializer<'de, super::AttributeType> for AttributeTypeDeserializer {
6707 fn init<R>(
6708 reader: &R,
6709 event: crate::quick_xml::Event<'de>,
6710 ) -> crate::quick_xml::DeserializerResult<'de, super::AttributeType, Self>
6711 where
6712 R: crate::quick_xml::XmlReader,
6713 {
6714 use crate::quick_xml::{DeserializerOutput, Event};
6715 match event {
6716 Event::Start(start) => {
6717 let deserializer = Self::from_bytes_start(reader, &start)?;
6718 Ok(DeserializerOutput {
6719 data: None,
6720 deserializer: Some(deserializer),
6721 event: None,
6722 allow_any: false,
6723 })
6724 }
6725 Event::Empty(start) => {
6726 let deserializer = Self::from_bytes_start(reader, &start)?;
6727 let data = deserializer.finish(reader)?;
6728 Ok(DeserializerOutput {
6729 data: Some(data),
6730 deserializer: None,
6731 event: None,
6732 allow_any: false,
6733 })
6734 }
6735 event => Ok(DeserializerOutput {
6736 data: None,
6737 deserializer: None,
6738 event: Some(event),
6739 allow_any: false,
6740 }),
6741 }
6742 }
6743 fn next<R>(
6744 mut self,
6745 reader: &R,
6746 event: crate::quick_xml::Event<'de>,
6747 ) -> crate::quick_xml::DeserializerResult<'de, super::AttributeType, Self>
6748 where
6749 R: crate::quick_xml::XmlReader,
6750 {
6751 use crate::quick_xml::{
6752 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
6753 };
6754 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
6755 let mut event = event;
6756 let mut allow_any_fallback = None;
6757 loop {
6758 event = match (
6759 core::mem::replace(&mut *self.state, AttributeTypeDeserializerState::Done__),
6760 event,
6761 ) {
6762 (AttributeTypeDeserializerState::Annotation(Some(deserializer)), event) => {
6763 let DeserializerOutput {
6764 data,
6765 deserializer,
6766 event,
6767 allow_any,
6768 } = deserializer.next(reader, event)?;
6769 if let Some(data) = data {
6770 if self.annotation.is_some() {
6771 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6772 b"annotation",
6773 )))?;
6774 }
6775 self.annotation = Some(data);
6776 }
6777 let event = match event {
6778 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
6779 event
6780 }
6781 event => {
6782 *self.state =
6783 AttributeTypeDeserializerState::Annotation(deserializer);
6784 return Ok(DeserializerOutput {
6785 data: None,
6786 deserializer: Some(self),
6787 event: event,
6788 allow_any: false,
6789 });
6790 }
6791 };
6792 if allow_any {
6793 allow_any_fallback.get_or_insert(
6794 AttributeTypeDeserializerState::Annotation(deserializer),
6795 );
6796 } else if let Some(deserializer) = deserializer {
6797 let data = deserializer.finish(reader)?;
6798 if self.annotation.is_some() {
6799 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6800 b"annotation",
6801 )))?;
6802 }
6803 self.annotation = Some(data);
6804 }
6805 *self.state = AttributeTypeDeserializerState::Annotation(None);
6806 event
6807 }
6808 (AttributeTypeDeserializerState::Annotation(None), event) => match &event {
6809 Event::Start(x) | Event::Empty(x)
6810 if matches!(
6811 reader.resolve_local_name(x.name(), NS_XS),
6812 Some(b"annotation")
6813 ) =>
6814 {
6815 let DeserializerOutput {
6816 data,
6817 deserializer,
6818 event,
6819 allow_any,
6820 } = <Annotation as WithDeserializer>::Deserializer::init(
6821 reader, event,
6822 )?;
6823 if let Some(data) = data {
6824 if self.annotation.is_some() {
6825 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6826 b"annotation",
6827 )))?;
6828 }
6829 self.annotation = Some(data);
6830 }
6831 *self.state = AttributeTypeDeserializerState::Annotation(deserializer);
6832 match event {
6833 Some(event @ (Event::Start(_) | Event::End(_))) => {
6834 *self.state = AttributeTypeDeserializerState::SimpleType(None);
6835 if allow_any {
6836 allow_any_fallback.get_or_insert(
6837 AttributeTypeDeserializerState::Annotation(None),
6838 );
6839 }
6840 event
6841 }
6842 event @ (None | Some(_)) => {
6843 return Ok(DeserializerOutput {
6844 data: None,
6845 deserializer: Some(self),
6846 event,
6847 allow_any: false,
6848 })
6849 }
6850 }
6851 }
6852 Event::Start(_) | Event::Empty(_) => {
6853 *self.state = AttributeTypeDeserializerState::SimpleType(None);
6854 allow_any_fallback
6855 .get_or_insert(AttributeTypeDeserializerState::Annotation(None));
6856 event
6857 }
6858 Event::End(_) => {
6859 let data = self.finish(reader)?;
6860 return Ok(DeserializerOutput {
6861 data: Some(data),
6862 deserializer: None,
6863 event: None,
6864 allow_any: false,
6865 });
6866 }
6867 _ => {
6868 *self.state = AttributeTypeDeserializerState::Annotation(None);
6869 return Ok(DeserializerOutput {
6870 data: None,
6871 deserializer: Some(self),
6872 event: Some(event),
6873 allow_any: false,
6874 });
6875 }
6876 },
6877 (AttributeTypeDeserializerState::SimpleType(Some(deserializer)), event) => {
6878 let DeserializerOutput {
6879 data,
6880 deserializer,
6881 event,
6882 allow_any,
6883 } = deserializer.next(reader, event)?;
6884 if let Some(data) = data {
6885 if self.simple_type.is_some() {
6886 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6887 b"simpleType",
6888 )))?;
6889 }
6890 self.simple_type = Some(data);
6891 }
6892 let event = match event {
6893 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
6894 event
6895 }
6896 event => {
6897 *self.state =
6898 AttributeTypeDeserializerState::SimpleType(deserializer);
6899 return Ok(DeserializerOutput {
6900 data: None,
6901 deserializer: Some(self),
6902 event: event,
6903 allow_any: false,
6904 });
6905 }
6906 };
6907 if allow_any {
6908 allow_any_fallback.get_or_insert(
6909 AttributeTypeDeserializerState::SimpleType(deserializer),
6910 );
6911 } else if let Some(deserializer) = deserializer {
6912 let data = deserializer.finish(reader)?;
6913 if self.simple_type.is_some() {
6914 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6915 b"simpleType",
6916 )))?;
6917 }
6918 self.simple_type = Some(data);
6919 }
6920 *self.state = AttributeTypeDeserializerState::SimpleType(None);
6921 event
6922 }
6923 (AttributeTypeDeserializerState::SimpleType(None), event) => match &event {
6924 Event::Start(x) | Event::Empty(x)
6925 if matches!(
6926 reader.resolve_local_name(x.name(), NS_XS),
6927 Some(b"simpleType")
6928 ) =>
6929 {
6930 let DeserializerOutput {
6931 data,
6932 deserializer,
6933 event,
6934 allow_any,
6935 } = <SimpleBaseType as WithDeserializer>::Deserializer::init(
6936 reader, event,
6937 )?;
6938 if let Some(data) = data {
6939 if self.simple_type.is_some() {
6940 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6941 b"simpleType",
6942 )))?;
6943 }
6944 self.simple_type = Some(data);
6945 }
6946 *self.state = AttributeTypeDeserializerState::SimpleType(deserializer);
6947 match event {
6948 Some(event @ (Event::Start(_) | Event::End(_))) => {
6949 *self.state = AttributeTypeDeserializerState::Done__;
6950 if allow_any {
6951 allow_any_fallback.get_or_insert(
6952 AttributeTypeDeserializerState::SimpleType(None),
6953 );
6954 }
6955 event
6956 }
6957 event @ (None | Some(_)) => {
6958 return Ok(DeserializerOutput {
6959 data: None,
6960 deserializer: Some(self),
6961 event,
6962 allow_any: false,
6963 })
6964 }
6965 }
6966 }
6967 Event::Start(_) | Event::Empty(_) => {
6968 *self.state = AttributeTypeDeserializerState::Done__;
6969 allow_any_fallback
6970 .get_or_insert(AttributeTypeDeserializerState::SimpleType(None));
6971 event
6972 }
6973 Event::End(_) => {
6974 let data = self.finish(reader)?;
6975 return Ok(DeserializerOutput {
6976 data: Some(data),
6977 deserializer: None,
6978 event: None,
6979 allow_any: false,
6980 });
6981 }
6982 _ => {
6983 *self.state = AttributeTypeDeserializerState::SimpleType(None);
6984 return Ok(DeserializerOutput {
6985 data: None,
6986 deserializer: Some(self),
6987 event: Some(event),
6988 allow_any: false,
6989 });
6990 }
6991 },
6992 (AttributeTypeDeserializerState::Done__, event) => {
6993 let allow_any = if let Some(fallback) = allow_any_fallback {
6994 *self.state = fallback;
6995 true
6996 } else {
6997 false
6998 };
6999 return Ok(DeserializerOutput {
7000 data: None,
7001 deserializer: Some(self),
7002 event: Some(event),
7003 allow_any,
7004 });
7005 }
7006 }
7007 }
7008 }
7009 fn finish<R>(self, _reader: &R) -> Result<super::AttributeType, crate::quick_xml::Error>
7010 where
7011 R: crate::quick_xml::XmlReader,
7012 {
7013 use crate::quick_xml::ErrorKind;
7014 Ok(super::AttributeType {
7015 id: self.id,
7016 name: self.name,
7017 ref_: self.ref_,
7018 type_: self.type_,
7019 use_: self.use_,
7020 default: self.default,
7021 fixed: self.fixed,
7022 form: self.form,
7023 target_namespace: self.target_namespace,
7024 inheritable: self.inheritable,
7025 annotation: self.annotation,
7026 simple_type: self.simple_type,
7027 })
7028 }
7029 }
7030 #[derive(Debug)]
7031 pub struct NotationDeserializer {
7032 id: Option<String>,
7033 name: String,
7034 public: Option<String>,
7035 system: Option<String>,
7036 annotation: Option<super::Annotation>,
7037 state: Box<NotationDeserializerState>,
7038 }
7039 #[derive(Debug)]
7040 enum NotationDeserializerState {
7041 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
7042 Done__,
7043 }
7044 impl NotationDeserializer {
7045 fn from_bytes_start<R>(
7046 reader: &R,
7047 bytes_start: &crate::quick_xml::BytesStart<'_>,
7048 ) -> Result<Self, crate::quick_xml::Error>
7049 where
7050 R: crate::quick_xml::XmlReader,
7051 {
7052 use crate::quick_xml::ErrorKind;
7053 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
7054 let mut id: Option<String> = None;
7055 let mut name: Option<String> = None;
7056 let mut public: Option<String> = None;
7057 let mut system: Option<String> = None;
7058 for attrib in bytes_start.attributes() {
7059 let attrib = attrib?;
7060 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
7061 continue;
7062 }
7063 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
7064 reader.read_attrib(&mut id, b"id", &attrib.value)?;
7065 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"name")) {
7066 reader.read_attrib(&mut name, b"name", &attrib.value)?;
7067 } else if matches!(
7068 reader.resolve_local_name(attrib.key, NS_XS),
7069 Some(b"public")
7070 ) {
7071 reader.read_attrib(&mut public, b"public", &attrib.value)?;
7072 } else if matches!(
7073 reader.resolve_local_name(attrib.key, NS_XS),
7074 Some(b"system")
7075 ) {
7076 reader.read_attrib(&mut system, b"system", &attrib.value)?;
7077 }
7078 }
7079 Ok(Self {
7080 id: id,
7081 name: name.ok_or(ErrorKind::MissingAttribute("name".into()))?,
7082 public: public,
7083 system: system,
7084 annotation: None,
7085 state: Box::new(NotationDeserializerState::Annotation(None)),
7086 })
7087 }
7088 }
7089 impl<'de> crate::quick_xml::Deserializer<'de, super::Notation> for NotationDeserializer {
7090 fn init<R>(
7091 reader: &R,
7092 event: crate::quick_xml::Event<'de>,
7093 ) -> crate::quick_xml::DeserializerResult<'de, super::Notation, Self>
7094 where
7095 R: crate::quick_xml::XmlReader,
7096 {
7097 use crate::quick_xml::{DeserializerOutput, Event};
7098 match event {
7099 Event::Start(start) => {
7100 let deserializer = Self::from_bytes_start(reader, &start)?;
7101 Ok(DeserializerOutput {
7102 data: None,
7103 deserializer: Some(deserializer),
7104 event: None,
7105 allow_any: false,
7106 })
7107 }
7108 Event::Empty(start) => {
7109 let deserializer = Self::from_bytes_start(reader, &start)?;
7110 let data = deserializer.finish(reader)?;
7111 Ok(DeserializerOutput {
7112 data: Some(data),
7113 deserializer: None,
7114 event: None,
7115 allow_any: false,
7116 })
7117 }
7118 event => Ok(DeserializerOutput {
7119 data: None,
7120 deserializer: None,
7121 event: Some(event),
7122 allow_any: false,
7123 }),
7124 }
7125 }
7126 fn next<R>(
7127 mut self,
7128 reader: &R,
7129 event: crate::quick_xml::Event<'de>,
7130 ) -> crate::quick_xml::DeserializerResult<'de, super::Notation, Self>
7131 where
7132 R: crate::quick_xml::XmlReader,
7133 {
7134 use crate::quick_xml::{
7135 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
7136 };
7137 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
7138 let mut event = event;
7139 let mut allow_any_fallback = None;
7140 loop {
7141 event = match (
7142 core::mem::replace(&mut *self.state, NotationDeserializerState::Done__),
7143 event,
7144 ) {
7145 (NotationDeserializerState::Annotation(Some(deserializer)), event) => {
7146 let DeserializerOutput {
7147 data,
7148 deserializer,
7149 event,
7150 allow_any,
7151 } = deserializer.next(reader, event)?;
7152 if let Some(data) = data {
7153 if self.annotation.is_some() {
7154 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
7155 b"annotation",
7156 )))?;
7157 }
7158 self.annotation = Some(data);
7159 }
7160 let event = match event {
7161 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
7162 event
7163 }
7164 event => {
7165 *self.state = NotationDeserializerState::Annotation(deserializer);
7166 return Ok(DeserializerOutput {
7167 data: None,
7168 deserializer: Some(self),
7169 event: event,
7170 allow_any: false,
7171 });
7172 }
7173 };
7174 if allow_any {
7175 allow_any_fallback
7176 .get_or_insert(NotationDeserializerState::Annotation(deserializer));
7177 } else if let Some(deserializer) = deserializer {
7178 let data = deserializer.finish(reader)?;
7179 if self.annotation.is_some() {
7180 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
7181 b"annotation",
7182 )))?;
7183 }
7184 self.annotation = Some(data);
7185 }
7186 *self.state = NotationDeserializerState::Annotation(None);
7187 event
7188 }
7189 (NotationDeserializerState::Annotation(None), event) => match &event {
7190 Event::Start(x) | Event::Empty(x)
7191 if matches!(
7192 reader.resolve_local_name(x.name(), NS_XS),
7193 Some(b"annotation")
7194 ) =>
7195 {
7196 let DeserializerOutput {
7197 data,
7198 deserializer,
7199 event,
7200 allow_any,
7201 } = <Annotation as WithDeserializer>::Deserializer::init(
7202 reader, event,
7203 )?;
7204 if let Some(data) = data {
7205 if self.annotation.is_some() {
7206 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
7207 b"annotation",
7208 )))?;
7209 }
7210 self.annotation = Some(data);
7211 }
7212 *self.state = NotationDeserializerState::Annotation(deserializer);
7213 match event {
7214 Some(event @ (Event::Start(_) | Event::End(_))) => {
7215 *self.state = NotationDeserializerState::Done__;
7216 if allow_any {
7217 allow_any_fallback.get_or_insert(
7218 NotationDeserializerState::Annotation(None),
7219 );
7220 }
7221 event
7222 }
7223 event @ (None | Some(_)) => {
7224 return Ok(DeserializerOutput {
7225 data: None,
7226 deserializer: Some(self),
7227 event,
7228 allow_any: false,
7229 })
7230 }
7231 }
7232 }
7233 Event::Start(_) | Event::Empty(_) => {
7234 *self.state = NotationDeserializerState::Done__;
7235 allow_any_fallback
7236 .get_or_insert(NotationDeserializerState::Annotation(None));
7237 event
7238 }
7239 Event::End(_) => {
7240 let data = self.finish(reader)?;
7241 return Ok(DeserializerOutput {
7242 data: Some(data),
7243 deserializer: None,
7244 event: None,
7245 allow_any: false,
7246 });
7247 }
7248 _ => {
7249 *self.state = NotationDeserializerState::Annotation(None);
7250 return Ok(DeserializerOutput {
7251 data: None,
7252 deserializer: Some(self),
7253 event: Some(event),
7254 allow_any: false,
7255 });
7256 }
7257 },
7258 (NotationDeserializerState::Done__, event) => {
7259 let allow_any = if let Some(fallback) = allow_any_fallback {
7260 *self.state = fallback;
7261 true
7262 } else {
7263 false
7264 };
7265 return Ok(DeserializerOutput {
7266 data: None,
7267 deserializer: Some(self),
7268 event: Some(event),
7269 allow_any,
7270 });
7271 }
7272 }
7273 }
7274 }
7275 fn finish<R>(self, _reader: &R) -> Result<super::Notation, crate::quick_xml::Error>
7276 where
7277 R: crate::quick_xml::XmlReader,
7278 {
7279 use crate::quick_xml::ErrorKind;
7280 Ok(super::Notation {
7281 id: self.id,
7282 name: self.name,
7283 public: self.public,
7284 system: self.system,
7285 annotation: self.annotation,
7286 })
7287 }
7288 }
7289 #[derive(Debug)]
7290 pub struct AppinfoDeserializer {
7291 source: Option<String>,
7292 }
7293 impl AppinfoDeserializer {
7294 fn from_bytes_start<R>(
7295 reader: &R,
7296 bytes_start: &crate::quick_xml::BytesStart<'_>,
7297 ) -> Result<Self, crate::quick_xml::Error>
7298 where
7299 R: crate::quick_xml::XmlReader,
7300 {
7301 use crate::quick_xml::ErrorKind;
7302 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
7303 let mut source: Option<String> = None;
7304 for attrib in bytes_start.attributes() {
7305 let attrib = attrib?;
7306 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
7307 continue;
7308 }
7309 if matches!(
7310 reader.resolve_local_name(attrib.key, NS_XS),
7311 Some(b"source")
7312 ) {
7313 reader.read_attrib(&mut source, b"source", &attrib.value)?;
7314 }
7315 }
7316 Ok(Self { source: source })
7317 }
7318 }
7319 impl<'de> crate::quick_xml::Deserializer<'de, super::Appinfo> for AppinfoDeserializer {
7320 fn init<R>(
7321 reader: &R,
7322 event: crate::quick_xml::Event<'de>,
7323 ) -> crate::quick_xml::DeserializerResult<'de, super::Appinfo, Self>
7324 where
7325 R: crate::quick_xml::XmlReader,
7326 {
7327 use crate::quick_xml::{DeserializerOutput, Event};
7328 match event {
7329 Event::Start(start) => {
7330 let deserializer = Self::from_bytes_start(reader, &start)?;
7331 Ok(DeserializerOutput {
7332 data: None,
7333 deserializer: Some(deserializer),
7334 event: None,
7335 allow_any: false,
7336 })
7337 }
7338 Event::Empty(start) => {
7339 let deserializer = Self::from_bytes_start(reader, &start)?;
7340 let data = deserializer.finish(reader)?;
7341 Ok(DeserializerOutput {
7342 data: Some(data),
7343 deserializer: None,
7344 event: None,
7345 allow_any: false,
7346 })
7347 }
7348 event => Ok(DeserializerOutput {
7349 data: None,
7350 deserializer: None,
7351 event: Some(event),
7352 allow_any: false,
7353 }),
7354 }
7355 }
7356 fn next<R>(
7357 self,
7358 reader: &R,
7359 event: crate::quick_xml::Event<'de>,
7360 ) -> crate::quick_xml::DeserializerResult<'de, super::Appinfo, Self>
7361 where
7362 R: crate::quick_xml::XmlReader,
7363 {
7364 use crate::quick_xml::{DeserializerOutput, Event};
7365 match event {
7366 Event::End(_) => {
7367 let data = self.finish(reader)?;
7368 Ok(DeserializerOutput {
7369 data: Some(data),
7370 deserializer: None,
7371 event: None,
7372 allow_any: false,
7373 })
7374 }
7375 _ => Ok(DeserializerOutput {
7376 data: None,
7377 deserializer: Some(self),
7378 event: Some(event),
7379 allow_any: true,
7380 }),
7381 }
7382 }
7383 fn finish<R>(self, _reader: &R) -> Result<super::Appinfo, crate::quick_xml::Error>
7384 where
7385 R: crate::quick_xml::XmlReader,
7386 {
7387 use crate::quick_xml::ErrorKind;
7388 Ok(super::Appinfo {
7389 source: self.source,
7390 })
7391 }
7392 }
7393 #[derive(Debug)]
7394 pub struct DocumentationDeserializer {
7395 source: Option<String>,
7396 lang: Option<String>,
7397 }
7398 impl DocumentationDeserializer {
7399 fn from_bytes_start<R>(
7400 reader: &R,
7401 bytes_start: &crate::quick_xml::BytesStart<'_>,
7402 ) -> Result<Self, crate::quick_xml::Error>
7403 where
7404 R: crate::quick_xml::XmlReader,
7405 {
7406 use crate::quick_xml::ErrorKind;
7407 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
7408 const NS_XML: &[u8] = b"http://www.w3.org/XML/1998/namespace";
7409 let mut source: Option<String> = None;
7410 let mut lang: Option<String> = None;
7411 for attrib in bytes_start.attributes() {
7412 let attrib = attrib?;
7413 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
7414 continue;
7415 }
7416 if matches!(
7417 reader.resolve_local_name(attrib.key, NS_XS),
7418 Some(b"source")
7419 ) {
7420 reader.read_attrib(&mut source, b"source", &attrib.value)?;
7421 } else if matches!(reader.resolve_local_name(attrib.key, NS_XML), Some(b"lang")) {
7422 reader.read_attrib(&mut lang, b"lang", &attrib.value)?;
7423 }
7424 }
7425 Ok(Self {
7426 source: source,
7427 lang: lang,
7428 })
7429 }
7430 }
7431 impl<'de> crate::quick_xml::Deserializer<'de, super::Documentation> for DocumentationDeserializer {
7432 fn init<R>(
7433 reader: &R,
7434 event: crate::quick_xml::Event<'de>,
7435 ) -> crate::quick_xml::DeserializerResult<'de, super::Documentation, Self>
7436 where
7437 R: crate::quick_xml::XmlReader,
7438 {
7439 use crate::quick_xml::{DeserializerOutput, Event};
7440 match event {
7441 Event::Start(start) => {
7442 let deserializer = Self::from_bytes_start(reader, &start)?;
7443 Ok(DeserializerOutput {
7444 data: None,
7445 deserializer: Some(deserializer),
7446 event: None,
7447 allow_any: false,
7448 })
7449 }
7450 Event::Empty(start) => {
7451 let deserializer = Self::from_bytes_start(reader, &start)?;
7452 let data = deserializer.finish(reader)?;
7453 Ok(DeserializerOutput {
7454 data: Some(data),
7455 deserializer: None,
7456 event: None,
7457 allow_any: false,
7458 })
7459 }
7460 event => Ok(DeserializerOutput {
7461 data: None,
7462 deserializer: None,
7463 event: Some(event),
7464 allow_any: false,
7465 }),
7466 }
7467 }
7468 fn next<R>(
7469 self,
7470 reader: &R,
7471 event: crate::quick_xml::Event<'de>,
7472 ) -> crate::quick_xml::DeserializerResult<'de, super::Documentation, Self>
7473 where
7474 R: crate::quick_xml::XmlReader,
7475 {
7476 use crate::quick_xml::{DeserializerOutput, Event};
7477 match event {
7478 Event::End(_) => {
7479 let data = self.finish(reader)?;
7480 Ok(DeserializerOutput {
7481 data: Some(data),
7482 deserializer: None,
7483 event: None,
7484 allow_any: false,
7485 })
7486 }
7487 _ => Ok(DeserializerOutput {
7488 data: None,
7489 deserializer: Some(self),
7490 event: Some(event),
7491 allow_any: true,
7492 }),
7493 }
7494 }
7495 fn finish<R>(self, _reader: &R) -> Result<super::Documentation, crate::quick_xml::Error>
7496 where
7497 R: crate::quick_xml::XmlReader,
7498 {
7499 use crate::quick_xml::ErrorKind;
7500 Ok(super::Documentation {
7501 source: self.source,
7502 lang: self.lang,
7503 })
7504 }
7505 }
7506 #[derive(Debug)]
7507 pub struct WildcardTypeDeserializer {
7508 id: Option<String>,
7509 namespace: Option<super::NamespaceListType>,
7510 not_namespace: Option<super::NotNamespaceType>,
7511 process_contents: super::ProcessContentsType,
7512 annotation: Option<super::Annotation>,
7513 state: Box<WildcardTypeDeserializerState>,
7514 }
7515 #[derive(Debug)]
7516 enum WildcardTypeDeserializerState {
7517 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
7518 Done__,
7519 }
7520 impl WildcardTypeDeserializer {
7521 fn from_bytes_start<R>(
7522 reader: &R,
7523 bytes_start: &crate::quick_xml::BytesStart<'_>,
7524 ) -> Result<Self, crate::quick_xml::Error>
7525 where
7526 R: crate::quick_xml::XmlReader,
7527 {
7528 use crate::quick_xml::ErrorKind;
7529 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
7530 let mut id: Option<String> = None;
7531 let mut namespace: Option<NamespaceListType> = None;
7532 let mut not_namespace: Option<NotNamespaceType> = None;
7533 let mut process_contents: Option<ProcessContentsType> = None;
7534 for attrib in bytes_start.attributes() {
7535 let attrib = attrib?;
7536 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
7537 continue;
7538 }
7539 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
7540 reader.read_attrib(&mut id, b"id", &attrib.value)?;
7541 } else if matches!(
7542 reader.resolve_local_name(attrib.key, NS_XS),
7543 Some(b"namespace")
7544 ) {
7545 reader.read_attrib(&mut namespace, b"namespace", &attrib.value)?;
7546 } else if matches!(
7547 reader.resolve_local_name(attrib.key, NS_XS),
7548 Some(b"notNamespace")
7549 ) {
7550 reader.read_attrib(&mut not_namespace, b"notNamespace", &attrib.value)?;
7551 } else if matches!(
7552 reader.resolve_local_name(attrib.key, NS_XS),
7553 Some(b"processContents")
7554 ) {
7555 reader.read_attrib(&mut process_contents, b"processContents", &attrib.value)?;
7556 }
7557 }
7558 Ok(Self {
7559 id: id,
7560 namespace: namespace,
7561 not_namespace: not_namespace,
7562 process_contents: process_contents
7563 .unwrap_or_else(super::WildcardType::default_process_contents),
7564 annotation: None,
7565 state: Box::new(WildcardTypeDeserializerState::Annotation(None)),
7566 })
7567 }
7568 }
7569 impl<'de> crate::quick_xml::Deserializer<'de, super::WildcardType> for WildcardTypeDeserializer {
7570 fn init<R>(
7571 reader: &R,
7572 event: crate::quick_xml::Event<'de>,
7573 ) -> crate::quick_xml::DeserializerResult<'de, super::WildcardType, Self>
7574 where
7575 R: crate::quick_xml::XmlReader,
7576 {
7577 use crate::quick_xml::{DeserializerOutput, Event};
7578 match event {
7579 Event::Start(start) => {
7580 let deserializer = Self::from_bytes_start(reader, &start)?;
7581 Ok(DeserializerOutput {
7582 data: None,
7583 deserializer: Some(deserializer),
7584 event: None,
7585 allow_any: false,
7586 })
7587 }
7588 Event::Empty(start) => {
7589 let deserializer = Self::from_bytes_start(reader, &start)?;
7590 let data = deserializer.finish(reader)?;
7591 Ok(DeserializerOutput {
7592 data: Some(data),
7593 deserializer: None,
7594 event: None,
7595 allow_any: false,
7596 })
7597 }
7598 event => Ok(DeserializerOutput {
7599 data: None,
7600 deserializer: None,
7601 event: Some(event),
7602 allow_any: false,
7603 }),
7604 }
7605 }
7606 fn next<R>(
7607 mut self,
7608 reader: &R,
7609 event: crate::quick_xml::Event<'de>,
7610 ) -> crate::quick_xml::DeserializerResult<'de, super::WildcardType, Self>
7611 where
7612 R: crate::quick_xml::XmlReader,
7613 {
7614 use crate::quick_xml::{
7615 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
7616 };
7617 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
7618 let mut event = event;
7619 let mut allow_any_fallback = None;
7620 loop {
7621 event = match (
7622 core::mem::replace(&mut *self.state, WildcardTypeDeserializerState::Done__),
7623 event,
7624 ) {
7625 (WildcardTypeDeserializerState::Annotation(Some(deserializer)), event) => {
7626 let DeserializerOutput {
7627 data,
7628 deserializer,
7629 event,
7630 allow_any,
7631 } = deserializer.next(reader, event)?;
7632 if let Some(data) = data {
7633 if self.annotation.is_some() {
7634 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
7635 b"annotation",
7636 )))?;
7637 }
7638 self.annotation = Some(data);
7639 }
7640 let event = match event {
7641 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
7642 event
7643 }
7644 event => {
7645 *self.state =
7646 WildcardTypeDeserializerState::Annotation(deserializer);
7647 return Ok(DeserializerOutput {
7648 data: None,
7649 deserializer: Some(self),
7650 event: event,
7651 allow_any: false,
7652 });
7653 }
7654 };
7655 if allow_any {
7656 allow_any_fallback.get_or_insert(
7657 WildcardTypeDeserializerState::Annotation(deserializer),
7658 );
7659 } else if let Some(deserializer) = deserializer {
7660 let data = deserializer.finish(reader)?;
7661 if self.annotation.is_some() {
7662 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
7663 b"annotation",
7664 )))?;
7665 }
7666 self.annotation = Some(data);
7667 }
7668 *self.state = WildcardTypeDeserializerState::Annotation(None);
7669 event
7670 }
7671 (WildcardTypeDeserializerState::Annotation(None), event) => match &event {
7672 Event::Start(x) | Event::Empty(x)
7673 if matches!(
7674 reader.resolve_local_name(x.name(), NS_XS),
7675 Some(b"annotation")
7676 ) =>
7677 {
7678 let DeserializerOutput {
7679 data,
7680 deserializer,
7681 event,
7682 allow_any,
7683 } = <Annotation as WithDeserializer>::Deserializer::init(
7684 reader, event,
7685 )?;
7686 if let Some(data) = data {
7687 if self.annotation.is_some() {
7688 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
7689 b"annotation",
7690 )))?;
7691 }
7692 self.annotation = Some(data);
7693 }
7694 *self.state = WildcardTypeDeserializerState::Annotation(deserializer);
7695 match event {
7696 Some(event @ (Event::Start(_) | Event::End(_))) => {
7697 *self.state = WildcardTypeDeserializerState::Done__;
7698 if allow_any {
7699 allow_any_fallback.get_or_insert(
7700 WildcardTypeDeserializerState::Annotation(None),
7701 );
7702 }
7703 event
7704 }
7705 event @ (None | Some(_)) => {
7706 return Ok(DeserializerOutput {
7707 data: None,
7708 deserializer: Some(self),
7709 event,
7710 allow_any: false,
7711 })
7712 }
7713 }
7714 }
7715 Event::Start(_) | Event::Empty(_) => {
7716 *self.state = WildcardTypeDeserializerState::Done__;
7717 allow_any_fallback
7718 .get_or_insert(WildcardTypeDeserializerState::Annotation(None));
7719 event
7720 }
7721 Event::End(_) => {
7722 let data = self.finish(reader)?;
7723 return Ok(DeserializerOutput {
7724 data: Some(data),
7725 deserializer: None,
7726 event: None,
7727 allow_any: false,
7728 });
7729 }
7730 _ => {
7731 *self.state = WildcardTypeDeserializerState::Annotation(None);
7732 return Ok(DeserializerOutput {
7733 data: None,
7734 deserializer: Some(self),
7735 event: Some(event),
7736 allow_any: false,
7737 });
7738 }
7739 },
7740 (WildcardTypeDeserializerState::Done__, event) => {
7741 let allow_any = if let Some(fallback) = allow_any_fallback {
7742 *self.state = fallback;
7743 true
7744 } else {
7745 false
7746 };
7747 return Ok(DeserializerOutput {
7748 data: None,
7749 deserializer: Some(self),
7750 event: Some(event),
7751 allow_any,
7752 });
7753 }
7754 }
7755 }
7756 }
7757 fn finish<R>(self, _reader: &R) -> Result<super::WildcardType, crate::quick_xml::Error>
7758 where
7759 R: crate::quick_xml::XmlReader,
7760 {
7761 use crate::quick_xml::ErrorKind;
7762 Ok(super::WildcardType {
7763 id: self.id,
7764 namespace: self.namespace,
7765 not_namespace: self.not_namespace,
7766 process_contents: self.process_contents,
7767 annotation: self.annotation,
7768 })
7769 }
7770 }
7771 #[derive(Debug)]
7772 pub struct RestrictionDeserializer {
7773 id: Option<String>,
7774 base: Option<super::QName>,
7775 content: Vec<super::RestrictionContent>,
7776 state: Box<RestrictionDeserializerState>,
7777 }
7778 #[derive(Debug)]
7779 enum RestrictionDeserializerState {
7780 Next__,
7781 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
7782 SimpleType(<SimpleBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
7783 Facet(<Facet as crate::quick_xml::WithDeserializer>::Deserializer),
7784 }
7785 impl RestrictionDeserializer {
7786 fn from_bytes_start<R>(
7787 reader: &R,
7788 bytes_start: &crate::quick_xml::BytesStart<'_>,
7789 ) -> Result<Self, crate::quick_xml::Error>
7790 where
7791 R: crate::quick_xml::XmlReader,
7792 {
7793 use crate::quick_xml::ErrorKind;
7794 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
7795 let mut id: Option<String> = None;
7796 let mut base: Option<QName> = None;
7797 for attrib in bytes_start.attributes() {
7798 let attrib = attrib?;
7799 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
7800 continue;
7801 }
7802 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
7803 reader.read_attrib(&mut id, b"id", &attrib.value)?;
7804 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"base")) {
7805 reader.read_attrib(&mut base, b"base", &attrib.value)?;
7806 }
7807 }
7808 Ok(Self {
7809 id: id,
7810 base: base,
7811 content: Vec::new(),
7812 state: Box::new(RestrictionDeserializerState::Next__),
7813 })
7814 }
7815 }
7816 impl<'de> crate::quick_xml::Deserializer<'de, super::Restriction> for RestrictionDeserializer {
7817 fn init<R>(
7818 reader: &R,
7819 event: crate::quick_xml::Event<'de>,
7820 ) -> crate::quick_xml::DeserializerResult<'de, super::Restriction, Self>
7821 where
7822 R: crate::quick_xml::XmlReader,
7823 {
7824 use crate::quick_xml::{DeserializerOutput, Event};
7825 match event {
7826 Event::Start(start) => {
7827 let deserializer = Self::from_bytes_start(reader, &start)?;
7828 Ok(DeserializerOutput {
7829 data: None,
7830 deserializer: Some(deserializer),
7831 event: None,
7832 allow_any: false,
7833 })
7834 }
7835 Event::Empty(start) => {
7836 let deserializer = Self::from_bytes_start(reader, &start)?;
7837 let data = deserializer.finish(reader)?;
7838 Ok(DeserializerOutput {
7839 data: Some(data),
7840 deserializer: None,
7841 event: None,
7842 allow_any: false,
7843 })
7844 }
7845 event => Ok(DeserializerOutput {
7846 data: None,
7847 deserializer: None,
7848 event: Some(event),
7849 allow_any: false,
7850 }),
7851 }
7852 }
7853 fn next<R>(
7854 mut self,
7855 reader: &R,
7856 event: crate::quick_xml::Event<'de>,
7857 ) -> crate::quick_xml::DeserializerResult<'de, super::Restriction, Self>
7858 where
7859 R: crate::quick_xml::XmlReader,
7860 {
7861 use crate::quick_xml::{
7862 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
7863 };
7864 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
7865 match (
7866 core::mem::replace(&mut *self.state, RestrictionDeserializerState::Next__),
7867 &event,
7868 ) {
7869 (RestrictionDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
7870 if matches!(
7871 reader.resolve_local_name(x.name(), NS_XS),
7872 Some(b"annotation")
7873 ) {
7874 let DeserializerOutput {
7875 data,
7876 deserializer,
7877 event,
7878 allow_any,
7879 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
7880 if let Some(data) = data {
7881 self.content.push(RestrictionContent::Annotation(data));
7882 }
7883 if let Some(deserializer) = deserializer {
7884 *self.state = RestrictionDeserializerState::Annotation(deserializer);
7885 }
7886 Ok(DeserializerOutput {
7887 data: None,
7888 deserializer: Some(self),
7889 event,
7890 allow_any,
7891 })
7892 } else if matches!(
7893 reader.resolve_local_name(x.name(), NS_XS),
7894 Some(b"simpleType")
7895 ) {
7896 let DeserializerOutput {
7897 data,
7898 deserializer,
7899 event,
7900 allow_any,
7901 } = <SimpleBaseType as WithDeserializer>::Deserializer::init(
7902 reader, event,
7903 )?;
7904 if let Some(data) = data {
7905 self.content.push(RestrictionContent::SimpleType(data));
7906 }
7907 if let Some(deserializer) = deserializer {
7908 *self.state = RestrictionDeserializerState::SimpleType(deserializer);
7909 }
7910 Ok(DeserializerOutput {
7911 data: None,
7912 deserializer: Some(self),
7913 event,
7914 allow_any,
7915 })
7916 } else {
7917 {
7918 let mut allow_any_element = false;
7919 let event = {
7920 let DeserializerOutput {
7921 data,
7922 deserializer,
7923 event,
7924 allow_any,
7925 } = <Facet as WithDeserializer>::Deserializer::init(reader, event)?;
7926 if let Some(data) = data {
7927 self.content.push(RestrictionContent::Facet(data));
7928 }
7929 if let Some(deserializer) = deserializer {
7930 *self.state = RestrictionDeserializerState::Facet(deserializer);
7931 }
7932 let Some(event) = event else {
7933 return Ok(DeserializerOutput {
7934 data: None,
7935 deserializer: Some(self),
7936 event: None,
7937 allow_any,
7938 });
7939 };
7940 if allow_any {
7941 allow_any_element = true;
7942 }
7943 event
7944 };
7945 Ok(DeserializerOutput {
7946 data: None,
7947 deserializer: Some(self),
7948 event: Some(event),
7949 allow_any: allow_any_element,
7950 })
7951 }
7952 }
7953 }
7954 (RestrictionDeserializerState::Next__, Event::End(_)) => {
7955 let data = self.finish(reader)?;
7956 Ok(DeserializerOutput {
7957 data: Some(data),
7958 deserializer: None,
7959 event: None,
7960 allow_any: false,
7961 })
7962 }
7963 (RestrictionDeserializerState::Next__, _) => Ok(DeserializerOutput {
7964 data: None,
7965 deserializer: Some(self),
7966 event: None,
7967 allow_any: false,
7968 }),
7969 (RestrictionDeserializerState::Annotation(deserializer), _) => {
7970 let DeserializerOutput {
7971 data,
7972 deserializer,
7973 event,
7974 allow_any,
7975 } = deserializer.next(reader, event)?;
7976 if let Some(data) = data {
7977 self.content.push(RestrictionContent::Annotation(data));
7978 }
7979 if let Some(deserializer) = deserializer {
7980 *self.state = RestrictionDeserializerState::Annotation(deserializer);
7981 }
7982 Ok(DeserializerOutput {
7983 data: None,
7984 deserializer: Some(self),
7985 event,
7986 allow_any,
7987 })
7988 }
7989 (RestrictionDeserializerState::SimpleType(deserializer), _) => {
7990 let DeserializerOutput {
7991 data,
7992 deserializer,
7993 event,
7994 allow_any,
7995 } = deserializer.next(reader, event)?;
7996 if let Some(data) = data {
7997 self.content.push(RestrictionContent::SimpleType(data));
7998 }
7999 if let Some(deserializer) = deserializer {
8000 *self.state = RestrictionDeserializerState::SimpleType(deserializer);
8001 }
8002 Ok(DeserializerOutput {
8003 data: None,
8004 deserializer: Some(self),
8005 event,
8006 allow_any,
8007 })
8008 }
8009 (RestrictionDeserializerState::Facet(deserializer), _) => {
8010 let DeserializerOutput {
8011 data,
8012 deserializer,
8013 event,
8014 allow_any,
8015 } = deserializer.next(reader, event)?;
8016 if let Some(data) = data {
8017 self.content.push(RestrictionContent::Facet(data));
8018 }
8019 if let Some(deserializer) = deserializer {
8020 *self.state = RestrictionDeserializerState::Facet(deserializer);
8021 }
8022 Ok(DeserializerOutput {
8023 data: None,
8024 deserializer: Some(self),
8025 event,
8026 allow_any,
8027 })
8028 }
8029 }
8030 }
8031 fn finish<R>(self, _reader: &R) -> Result<super::Restriction, crate::quick_xml::Error>
8032 where
8033 R: crate::quick_xml::XmlReader,
8034 {
8035 use crate::quick_xml::ErrorKind;
8036 Ok(super::Restriction {
8037 id: self.id,
8038 base: self.base,
8039 content: self.content,
8040 })
8041 }
8042 }
8043 #[derive(Debug)]
8044 pub struct ListDeserializer {
8045 id: Option<String>,
8046 item_type: Option<super::QName>,
8047 annotation: Option<super::Annotation>,
8048 simple_type: Option<super::SimpleBaseType>,
8049 state: Box<ListDeserializerState>,
8050 }
8051 #[derive(Debug)]
8052 enum ListDeserializerState {
8053 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
8054 SimpleType(Option<<SimpleBaseType as crate::quick_xml::WithDeserializer>::Deserializer>),
8055 Done__,
8056 }
8057 impl ListDeserializer {
8058 fn from_bytes_start<R>(
8059 reader: &R,
8060 bytes_start: &crate::quick_xml::BytesStart<'_>,
8061 ) -> Result<Self, crate::quick_xml::Error>
8062 where
8063 R: crate::quick_xml::XmlReader,
8064 {
8065 use crate::quick_xml::ErrorKind;
8066 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
8067 let mut id: Option<String> = None;
8068 let mut item_type: Option<QName> = None;
8069 for attrib in bytes_start.attributes() {
8070 let attrib = attrib?;
8071 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
8072 continue;
8073 }
8074 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
8075 reader.read_attrib(&mut id, b"id", &attrib.value)?;
8076 } else if matches!(
8077 reader.resolve_local_name(attrib.key, NS_XS),
8078 Some(b"itemType")
8079 ) {
8080 reader.read_attrib(&mut item_type, b"itemType", &attrib.value)?;
8081 }
8082 }
8083 Ok(Self {
8084 id: id,
8085 item_type: item_type,
8086 annotation: None,
8087 simple_type: None,
8088 state: Box::new(ListDeserializerState::Annotation(None)),
8089 })
8090 }
8091 }
8092 impl<'de> crate::quick_xml::Deserializer<'de, super::List> for ListDeserializer {
8093 fn init<R>(
8094 reader: &R,
8095 event: crate::quick_xml::Event<'de>,
8096 ) -> crate::quick_xml::DeserializerResult<'de, super::List, Self>
8097 where
8098 R: crate::quick_xml::XmlReader,
8099 {
8100 use crate::quick_xml::{DeserializerOutput, Event};
8101 match event {
8102 Event::Start(start) => {
8103 let deserializer = Self::from_bytes_start(reader, &start)?;
8104 Ok(DeserializerOutput {
8105 data: None,
8106 deserializer: Some(deserializer),
8107 event: None,
8108 allow_any: false,
8109 })
8110 }
8111 Event::Empty(start) => {
8112 let deserializer = Self::from_bytes_start(reader, &start)?;
8113 let data = deserializer.finish(reader)?;
8114 Ok(DeserializerOutput {
8115 data: Some(data),
8116 deserializer: None,
8117 event: None,
8118 allow_any: false,
8119 })
8120 }
8121 event => Ok(DeserializerOutput {
8122 data: None,
8123 deserializer: None,
8124 event: Some(event),
8125 allow_any: false,
8126 }),
8127 }
8128 }
8129 fn next<R>(
8130 mut self,
8131 reader: &R,
8132 event: crate::quick_xml::Event<'de>,
8133 ) -> crate::quick_xml::DeserializerResult<'de, super::List, Self>
8134 where
8135 R: crate::quick_xml::XmlReader,
8136 {
8137 use crate::quick_xml::{
8138 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
8139 };
8140 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
8141 let mut event = event;
8142 let mut allow_any_fallback = None;
8143 loop {
8144 event = match (
8145 core::mem::replace(&mut *self.state, ListDeserializerState::Done__),
8146 event,
8147 ) {
8148 (ListDeserializerState::Annotation(Some(deserializer)), event) => {
8149 let DeserializerOutput {
8150 data,
8151 deserializer,
8152 event,
8153 allow_any,
8154 } = deserializer.next(reader, event)?;
8155 if let Some(data) = data {
8156 if self.annotation.is_some() {
8157 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8158 b"annotation",
8159 )))?;
8160 }
8161 self.annotation = Some(data);
8162 }
8163 let event = match event {
8164 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
8165 event
8166 }
8167 event => {
8168 *self.state = ListDeserializerState::Annotation(deserializer);
8169 return Ok(DeserializerOutput {
8170 data: None,
8171 deserializer: Some(self),
8172 event: event,
8173 allow_any: false,
8174 });
8175 }
8176 };
8177 if allow_any {
8178 allow_any_fallback
8179 .get_or_insert(ListDeserializerState::Annotation(deserializer));
8180 } else if let Some(deserializer) = deserializer {
8181 let data = deserializer.finish(reader)?;
8182 if self.annotation.is_some() {
8183 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8184 b"annotation",
8185 )))?;
8186 }
8187 self.annotation = Some(data);
8188 }
8189 *self.state = ListDeserializerState::Annotation(None);
8190 event
8191 }
8192 (ListDeserializerState::Annotation(None), event) => match &event {
8193 Event::Start(x) | Event::Empty(x)
8194 if matches!(
8195 reader.resolve_local_name(x.name(), NS_XS),
8196 Some(b"annotation")
8197 ) =>
8198 {
8199 let DeserializerOutput {
8200 data,
8201 deserializer,
8202 event,
8203 allow_any,
8204 } = <Annotation as WithDeserializer>::Deserializer::init(
8205 reader, event,
8206 )?;
8207 if let Some(data) = data {
8208 if self.annotation.is_some() {
8209 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8210 b"annotation",
8211 )))?;
8212 }
8213 self.annotation = Some(data);
8214 }
8215 *self.state = ListDeserializerState::Annotation(deserializer);
8216 match event {
8217 Some(event @ (Event::Start(_) | Event::End(_))) => {
8218 *self.state = ListDeserializerState::SimpleType(None);
8219 if allow_any {
8220 allow_any_fallback
8221 .get_or_insert(ListDeserializerState::Annotation(None));
8222 }
8223 event
8224 }
8225 event @ (None | Some(_)) => {
8226 return Ok(DeserializerOutput {
8227 data: None,
8228 deserializer: Some(self),
8229 event,
8230 allow_any: false,
8231 })
8232 }
8233 }
8234 }
8235 Event::Start(_) | Event::Empty(_) => {
8236 *self.state = ListDeserializerState::SimpleType(None);
8237 allow_any_fallback
8238 .get_or_insert(ListDeserializerState::Annotation(None));
8239 event
8240 }
8241 Event::End(_) => {
8242 let data = self.finish(reader)?;
8243 return Ok(DeserializerOutput {
8244 data: Some(data),
8245 deserializer: None,
8246 event: None,
8247 allow_any: false,
8248 });
8249 }
8250 _ => {
8251 *self.state = ListDeserializerState::Annotation(None);
8252 return Ok(DeserializerOutput {
8253 data: None,
8254 deserializer: Some(self),
8255 event: Some(event),
8256 allow_any: false,
8257 });
8258 }
8259 },
8260 (ListDeserializerState::SimpleType(Some(deserializer)), event) => {
8261 let DeserializerOutput {
8262 data,
8263 deserializer,
8264 event,
8265 allow_any,
8266 } = deserializer.next(reader, event)?;
8267 if let Some(data) = data {
8268 if self.simple_type.is_some() {
8269 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8270 b"simpleType",
8271 )))?;
8272 }
8273 self.simple_type = Some(data);
8274 }
8275 let event = match event {
8276 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
8277 event
8278 }
8279 event => {
8280 *self.state = ListDeserializerState::SimpleType(deserializer);
8281 return Ok(DeserializerOutput {
8282 data: None,
8283 deserializer: Some(self),
8284 event: event,
8285 allow_any: false,
8286 });
8287 }
8288 };
8289 if allow_any {
8290 allow_any_fallback
8291 .get_or_insert(ListDeserializerState::SimpleType(deserializer));
8292 } else if let Some(deserializer) = deserializer {
8293 let data = deserializer.finish(reader)?;
8294 if self.simple_type.is_some() {
8295 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8296 b"simpleType",
8297 )))?;
8298 }
8299 self.simple_type = Some(data);
8300 }
8301 *self.state = ListDeserializerState::SimpleType(None);
8302 event
8303 }
8304 (ListDeserializerState::SimpleType(None), event) => match &event {
8305 Event::Start(x) | Event::Empty(x)
8306 if matches!(
8307 reader.resolve_local_name(x.name(), NS_XS),
8308 Some(b"simpleType")
8309 ) =>
8310 {
8311 let DeserializerOutput {
8312 data,
8313 deserializer,
8314 event,
8315 allow_any,
8316 } = <SimpleBaseType as WithDeserializer>::Deserializer::init(
8317 reader, event,
8318 )?;
8319 if let Some(data) = data {
8320 if self.simple_type.is_some() {
8321 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8322 b"simpleType",
8323 )))?;
8324 }
8325 self.simple_type = Some(data);
8326 }
8327 *self.state = ListDeserializerState::SimpleType(deserializer);
8328 match event {
8329 Some(event @ (Event::Start(_) | Event::End(_))) => {
8330 *self.state = ListDeserializerState::Done__;
8331 if allow_any {
8332 allow_any_fallback
8333 .get_or_insert(ListDeserializerState::SimpleType(None));
8334 }
8335 event
8336 }
8337 event @ (None | Some(_)) => {
8338 return Ok(DeserializerOutput {
8339 data: None,
8340 deserializer: Some(self),
8341 event,
8342 allow_any: false,
8343 })
8344 }
8345 }
8346 }
8347 Event::Start(_) | Event::Empty(_) => {
8348 *self.state = ListDeserializerState::Done__;
8349 allow_any_fallback
8350 .get_or_insert(ListDeserializerState::SimpleType(None));
8351 event
8352 }
8353 Event::End(_) => {
8354 let data = self.finish(reader)?;
8355 return Ok(DeserializerOutput {
8356 data: Some(data),
8357 deserializer: None,
8358 event: None,
8359 allow_any: false,
8360 });
8361 }
8362 _ => {
8363 *self.state = ListDeserializerState::SimpleType(None);
8364 return Ok(DeserializerOutput {
8365 data: None,
8366 deserializer: Some(self),
8367 event: Some(event),
8368 allow_any: false,
8369 });
8370 }
8371 },
8372 (ListDeserializerState::Done__, event) => {
8373 let allow_any = if let Some(fallback) = allow_any_fallback {
8374 *self.state = fallback;
8375 true
8376 } else {
8377 false
8378 };
8379 return Ok(DeserializerOutput {
8380 data: None,
8381 deserializer: Some(self),
8382 event: Some(event),
8383 allow_any,
8384 });
8385 }
8386 }
8387 }
8388 }
8389 fn finish<R>(self, _reader: &R) -> Result<super::List, crate::quick_xml::Error>
8390 where
8391 R: crate::quick_xml::XmlReader,
8392 {
8393 use crate::quick_xml::ErrorKind;
8394 Ok(super::List {
8395 id: self.id,
8396 item_type: self.item_type,
8397 annotation: self.annotation,
8398 simple_type: self.simple_type,
8399 })
8400 }
8401 }
8402 #[derive(Debug)]
8403 pub struct UnionDeserializer {
8404 id: Option<String>,
8405 member_types: Option<super::UnionMemberTypesType>,
8406 annotation: Option<super::Annotation>,
8407 simple_type: Vec<super::SimpleBaseType>,
8408 state: Box<UnionDeserializerState>,
8409 }
8410 #[derive(Debug)]
8411 enum UnionDeserializerState {
8412 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
8413 SimpleType(Option<<SimpleBaseType as crate::quick_xml::WithDeserializer>::Deserializer>),
8414 Done__,
8415 }
8416 impl UnionDeserializer {
8417 fn from_bytes_start<R>(
8418 reader: &R,
8419 bytes_start: &crate::quick_xml::BytesStart<'_>,
8420 ) -> Result<Self, crate::quick_xml::Error>
8421 where
8422 R: crate::quick_xml::XmlReader,
8423 {
8424 use crate::quick_xml::ErrorKind;
8425 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
8426 let mut id: Option<String> = None;
8427 let mut member_types: Option<UnionMemberTypesType> = None;
8428 for attrib in bytes_start.attributes() {
8429 let attrib = attrib?;
8430 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
8431 continue;
8432 }
8433 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
8434 reader.read_attrib(&mut id, b"id", &attrib.value)?;
8435 } else if matches!(
8436 reader.resolve_local_name(attrib.key, NS_XS),
8437 Some(b"memberTypes")
8438 ) {
8439 reader.read_attrib(&mut member_types, b"memberTypes", &attrib.value)?;
8440 }
8441 }
8442 Ok(Self {
8443 id: id,
8444 member_types: member_types,
8445 annotation: None,
8446 simple_type: Vec::new(),
8447 state: Box::new(UnionDeserializerState::Annotation(None)),
8448 })
8449 }
8450 }
8451 impl<'de> crate::quick_xml::Deserializer<'de, super::Union> for UnionDeserializer {
8452 fn init<R>(
8453 reader: &R,
8454 event: crate::quick_xml::Event<'de>,
8455 ) -> crate::quick_xml::DeserializerResult<'de, super::Union, Self>
8456 where
8457 R: crate::quick_xml::XmlReader,
8458 {
8459 use crate::quick_xml::{DeserializerOutput, Event};
8460 match event {
8461 Event::Start(start) => {
8462 let deserializer = Self::from_bytes_start(reader, &start)?;
8463 Ok(DeserializerOutput {
8464 data: None,
8465 deserializer: Some(deserializer),
8466 event: None,
8467 allow_any: false,
8468 })
8469 }
8470 Event::Empty(start) => {
8471 let deserializer = Self::from_bytes_start(reader, &start)?;
8472 let data = deserializer.finish(reader)?;
8473 Ok(DeserializerOutput {
8474 data: Some(data),
8475 deserializer: None,
8476 event: None,
8477 allow_any: false,
8478 })
8479 }
8480 event => Ok(DeserializerOutput {
8481 data: None,
8482 deserializer: None,
8483 event: Some(event),
8484 allow_any: false,
8485 }),
8486 }
8487 }
8488 fn next<R>(
8489 mut self,
8490 reader: &R,
8491 event: crate::quick_xml::Event<'de>,
8492 ) -> crate::quick_xml::DeserializerResult<'de, super::Union, Self>
8493 where
8494 R: crate::quick_xml::XmlReader,
8495 {
8496 use crate::quick_xml::{
8497 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
8498 };
8499 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
8500 let mut event = event;
8501 let mut allow_any_fallback = None;
8502 loop {
8503 event = match (
8504 core::mem::replace(&mut *self.state, UnionDeserializerState::Done__),
8505 event,
8506 ) {
8507 (UnionDeserializerState::Annotation(Some(deserializer)), event) => {
8508 let DeserializerOutput {
8509 data,
8510 deserializer,
8511 event,
8512 allow_any,
8513 } = deserializer.next(reader, event)?;
8514 if let Some(data) = data {
8515 if self.annotation.is_some() {
8516 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8517 b"annotation",
8518 )))?;
8519 }
8520 self.annotation = Some(data);
8521 }
8522 let event = match event {
8523 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
8524 event
8525 }
8526 event => {
8527 *self.state = UnionDeserializerState::Annotation(deserializer);
8528 return Ok(DeserializerOutput {
8529 data: None,
8530 deserializer: Some(self),
8531 event: event,
8532 allow_any: false,
8533 });
8534 }
8535 };
8536 if allow_any {
8537 allow_any_fallback
8538 .get_or_insert(UnionDeserializerState::Annotation(deserializer));
8539 } else if let Some(deserializer) = deserializer {
8540 let data = deserializer.finish(reader)?;
8541 if self.annotation.is_some() {
8542 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8543 b"annotation",
8544 )))?;
8545 }
8546 self.annotation = Some(data);
8547 }
8548 *self.state = UnionDeserializerState::Annotation(None);
8549 event
8550 }
8551 (UnionDeserializerState::Annotation(None), event) => match &event {
8552 Event::Start(x) | Event::Empty(x)
8553 if matches!(
8554 reader.resolve_local_name(x.name(), NS_XS),
8555 Some(b"annotation")
8556 ) =>
8557 {
8558 let DeserializerOutput {
8559 data,
8560 deserializer,
8561 event,
8562 allow_any,
8563 } = <Annotation as WithDeserializer>::Deserializer::init(
8564 reader, event,
8565 )?;
8566 if let Some(data) = data {
8567 if self.annotation.is_some() {
8568 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8569 b"annotation",
8570 )))?;
8571 }
8572 self.annotation = Some(data);
8573 }
8574 *self.state = UnionDeserializerState::Annotation(deserializer);
8575 match event {
8576 Some(event @ (Event::Start(_) | Event::End(_))) => {
8577 *self.state = UnionDeserializerState::SimpleType(None);
8578 if allow_any {
8579 allow_any_fallback.get_or_insert(
8580 UnionDeserializerState::Annotation(None),
8581 );
8582 }
8583 event
8584 }
8585 event @ (None | Some(_)) => {
8586 return Ok(DeserializerOutput {
8587 data: None,
8588 deserializer: Some(self),
8589 event,
8590 allow_any: false,
8591 })
8592 }
8593 }
8594 }
8595 Event::Start(_) | Event::Empty(_) => {
8596 *self.state = UnionDeserializerState::SimpleType(None);
8597 allow_any_fallback
8598 .get_or_insert(UnionDeserializerState::Annotation(None));
8599 event
8600 }
8601 Event::End(_) => {
8602 let data = self.finish(reader)?;
8603 return Ok(DeserializerOutput {
8604 data: Some(data),
8605 deserializer: None,
8606 event: None,
8607 allow_any: false,
8608 });
8609 }
8610 _ => {
8611 *self.state = UnionDeserializerState::Annotation(None);
8612 return Ok(DeserializerOutput {
8613 data: None,
8614 deserializer: Some(self),
8615 event: Some(event),
8616 allow_any: false,
8617 });
8618 }
8619 },
8620 (UnionDeserializerState::SimpleType(Some(deserializer)), event) => {
8621 let DeserializerOutput {
8622 data,
8623 deserializer,
8624 event,
8625 allow_any,
8626 } = deserializer.next(reader, event)?;
8627 if let Some(data) = data {
8628 self.simple_type.push(data);
8629 }
8630 let event = match event {
8631 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
8632 event
8633 }
8634 event => {
8635 *self.state = UnionDeserializerState::SimpleType(deserializer);
8636 return Ok(DeserializerOutput {
8637 data: None,
8638 deserializer: Some(self),
8639 event: event,
8640 allow_any: false,
8641 });
8642 }
8643 };
8644 if allow_any {
8645 allow_any_fallback
8646 .get_or_insert(UnionDeserializerState::SimpleType(deserializer));
8647 } else if let Some(deserializer) = deserializer {
8648 let data = deserializer.finish(reader)?;
8649 self.simple_type.push(data);
8650 }
8651 *self.state = UnionDeserializerState::SimpleType(None);
8652 event
8653 }
8654 (UnionDeserializerState::SimpleType(None), event) => match &event {
8655 Event::Start(x) | Event::Empty(x)
8656 if matches!(
8657 reader.resolve_local_name(x.name(), NS_XS),
8658 Some(b"simpleType")
8659 ) =>
8660 {
8661 let DeserializerOutput {
8662 data,
8663 deserializer,
8664 event,
8665 allow_any,
8666 } = <SimpleBaseType as WithDeserializer>::Deserializer::init(
8667 reader, event,
8668 )?;
8669 if let Some(data) = data {
8670 self.simple_type.push(data);
8671 }
8672 *self.state = UnionDeserializerState::SimpleType(deserializer);
8673 match event {
8674 Some(event @ (Event::Start(_) | Event::End(_))) => {
8675 *self.state = UnionDeserializerState::Done__;
8676 if allow_any {
8677 allow_any_fallback.get_or_insert(
8678 UnionDeserializerState::SimpleType(None),
8679 );
8680 }
8681 event
8682 }
8683 event @ (None | Some(_)) => {
8684 return Ok(DeserializerOutput {
8685 data: None,
8686 deserializer: Some(self),
8687 event,
8688 allow_any: false,
8689 })
8690 }
8691 }
8692 }
8693 Event::Start(_) | Event::Empty(_) => {
8694 *self.state = UnionDeserializerState::Done__;
8695 allow_any_fallback
8696 .get_or_insert(UnionDeserializerState::SimpleType(None));
8697 event
8698 }
8699 Event::End(_) => {
8700 let data = self.finish(reader)?;
8701 return Ok(DeserializerOutput {
8702 data: Some(data),
8703 deserializer: None,
8704 event: None,
8705 allow_any: false,
8706 });
8707 }
8708 _ => {
8709 *self.state = UnionDeserializerState::SimpleType(None);
8710 return Ok(DeserializerOutput {
8711 data: None,
8712 deserializer: Some(self),
8713 event: Some(event),
8714 allow_any: false,
8715 });
8716 }
8717 },
8718 (UnionDeserializerState::Done__, event) => {
8719 let allow_any = if let Some(fallback) = allow_any_fallback {
8720 *self.state = fallback;
8721 true
8722 } else {
8723 false
8724 };
8725 return Ok(DeserializerOutput {
8726 data: None,
8727 deserializer: Some(self),
8728 event: Some(event),
8729 allow_any,
8730 });
8731 }
8732 }
8733 }
8734 }
8735 fn finish<R>(self, _reader: &R) -> Result<super::Union, crate::quick_xml::Error>
8736 where
8737 R: crate::quick_xml::XmlReader,
8738 {
8739 use crate::quick_xml::ErrorKind;
8740 Ok(super::Union {
8741 id: self.id,
8742 member_types: self.member_types,
8743 annotation: self.annotation,
8744 simple_type: self.simple_type,
8745 })
8746 }
8747 }
8748 #[derive(Debug)]
8749 pub struct SimpleContentDeserializer {
8750 id: Option<String>,
8751 content: Vec<super::SimpleContentContent>,
8752 state: Box<SimpleContentDeserializerState>,
8753 }
8754 #[derive(Debug)]
8755 enum SimpleContentDeserializerState {
8756 Next__,
8757 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
8758 Restriction(<RestrictionType as crate::quick_xml::WithDeserializer>::Deserializer),
8759 Extension(<ExtensionType as crate::quick_xml::WithDeserializer>::Deserializer),
8760 }
8761 impl SimpleContentDeserializer {
8762 fn from_bytes_start<R>(
8763 reader: &R,
8764 bytes_start: &crate::quick_xml::BytesStart<'_>,
8765 ) -> Result<Self, crate::quick_xml::Error>
8766 where
8767 R: crate::quick_xml::XmlReader,
8768 {
8769 use crate::quick_xml::ErrorKind;
8770 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
8771 let mut id: Option<String> = None;
8772 for attrib in bytes_start.attributes() {
8773 let attrib = attrib?;
8774 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
8775 continue;
8776 }
8777 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
8778 reader.read_attrib(&mut id, b"id", &attrib.value)?;
8779 }
8780 }
8781 Ok(Self {
8782 id: id,
8783 content: Vec::new(),
8784 state: Box::new(SimpleContentDeserializerState::Next__),
8785 })
8786 }
8787 }
8788 impl<'de> crate::quick_xml::Deserializer<'de, super::SimpleContent> for SimpleContentDeserializer {
8789 fn init<R>(
8790 reader: &R,
8791 event: crate::quick_xml::Event<'de>,
8792 ) -> crate::quick_xml::DeserializerResult<'de, super::SimpleContent, Self>
8793 where
8794 R: crate::quick_xml::XmlReader,
8795 {
8796 use crate::quick_xml::{DeserializerOutput, Event};
8797 match event {
8798 Event::Start(start) => {
8799 let deserializer = Self::from_bytes_start(reader, &start)?;
8800 Ok(DeserializerOutput {
8801 data: None,
8802 deserializer: Some(deserializer),
8803 event: None,
8804 allow_any: false,
8805 })
8806 }
8807 Event::Empty(start) => {
8808 let deserializer = Self::from_bytes_start(reader, &start)?;
8809 let data = deserializer.finish(reader)?;
8810 Ok(DeserializerOutput {
8811 data: Some(data),
8812 deserializer: None,
8813 event: None,
8814 allow_any: false,
8815 })
8816 }
8817 event => Ok(DeserializerOutput {
8818 data: None,
8819 deserializer: None,
8820 event: Some(event),
8821 allow_any: false,
8822 }),
8823 }
8824 }
8825 fn next<R>(
8826 mut self,
8827 reader: &R,
8828 event: crate::quick_xml::Event<'de>,
8829 ) -> crate::quick_xml::DeserializerResult<'de, super::SimpleContent, Self>
8830 where
8831 R: crate::quick_xml::XmlReader,
8832 {
8833 use crate::quick_xml::{
8834 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
8835 };
8836 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
8837 match (
8838 core::mem::replace(&mut *self.state, SimpleContentDeserializerState::Next__),
8839 &event,
8840 ) {
8841 (SimpleContentDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
8842 if matches!(
8843 reader.resolve_local_name(x.name(), NS_XS),
8844 Some(b"annotation")
8845 ) {
8846 let DeserializerOutput {
8847 data,
8848 deserializer,
8849 event,
8850 allow_any,
8851 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
8852 if let Some(data) = data {
8853 self.content.push(SimpleContentContent::Annotation(data));
8854 }
8855 if let Some(deserializer) = deserializer {
8856 *self.state = SimpleContentDeserializerState::Annotation(deserializer);
8857 }
8858 Ok(DeserializerOutput {
8859 data: None,
8860 deserializer: Some(self),
8861 event,
8862 allow_any,
8863 })
8864 } else if matches!(
8865 reader.resolve_local_name(x.name(), NS_XS),
8866 Some(b"restriction")
8867 ) {
8868 let DeserializerOutput {
8869 data,
8870 deserializer,
8871 event,
8872 allow_any,
8873 } = <RestrictionType as WithDeserializer>::Deserializer::init(
8874 reader, event,
8875 )?;
8876 if let Some(data) = data {
8877 self.content.push(SimpleContentContent::Restriction(data));
8878 }
8879 if let Some(deserializer) = deserializer {
8880 *self.state = SimpleContentDeserializerState::Restriction(deserializer);
8881 }
8882 Ok(DeserializerOutput {
8883 data: None,
8884 deserializer: Some(self),
8885 event,
8886 allow_any,
8887 })
8888 } else if matches!(
8889 reader.resolve_local_name(x.name(), NS_XS),
8890 Some(b"extension")
8891 ) {
8892 let DeserializerOutput {
8893 data,
8894 deserializer,
8895 event,
8896 allow_any,
8897 } = <ExtensionType as WithDeserializer>::Deserializer::init(reader, event)?;
8898 if let Some(data) = data {
8899 self.content.push(SimpleContentContent::Extension(data));
8900 }
8901 if let Some(deserializer) = deserializer {
8902 *self.state = SimpleContentDeserializerState::Extension(deserializer);
8903 }
8904 Ok(DeserializerOutput {
8905 data: None,
8906 deserializer: Some(self),
8907 event,
8908 allow_any,
8909 })
8910 } else {
8911 Ok(DeserializerOutput {
8912 data: None,
8913 deserializer: Some(self),
8914 event: Some(event),
8915 allow_any: false,
8916 })
8917 }
8918 }
8919 (SimpleContentDeserializerState::Next__, Event::End(_)) => {
8920 let data = self.finish(reader)?;
8921 Ok(DeserializerOutput {
8922 data: Some(data),
8923 deserializer: None,
8924 event: None,
8925 allow_any: false,
8926 })
8927 }
8928 (SimpleContentDeserializerState::Next__, _) => Ok(DeserializerOutput {
8929 data: None,
8930 deserializer: Some(self),
8931 event: None,
8932 allow_any: false,
8933 }),
8934 (SimpleContentDeserializerState::Annotation(deserializer), _) => {
8935 let DeserializerOutput {
8936 data,
8937 deserializer,
8938 event,
8939 allow_any,
8940 } = deserializer.next(reader, event)?;
8941 if let Some(data) = data {
8942 self.content.push(SimpleContentContent::Annotation(data));
8943 }
8944 if let Some(deserializer) = deserializer {
8945 *self.state = SimpleContentDeserializerState::Annotation(deserializer);
8946 }
8947 Ok(DeserializerOutput {
8948 data: None,
8949 deserializer: Some(self),
8950 event,
8951 allow_any,
8952 })
8953 }
8954 (SimpleContentDeserializerState::Restriction(deserializer), _) => {
8955 let DeserializerOutput {
8956 data,
8957 deserializer,
8958 event,
8959 allow_any,
8960 } = deserializer.next(reader, event)?;
8961 if let Some(data) = data {
8962 self.content.push(SimpleContentContent::Restriction(data));
8963 }
8964 if let Some(deserializer) = deserializer {
8965 *self.state = SimpleContentDeserializerState::Restriction(deserializer);
8966 }
8967 Ok(DeserializerOutput {
8968 data: None,
8969 deserializer: Some(self),
8970 event,
8971 allow_any,
8972 })
8973 }
8974 (SimpleContentDeserializerState::Extension(deserializer), _) => {
8975 let DeserializerOutput {
8976 data,
8977 deserializer,
8978 event,
8979 allow_any,
8980 } = deserializer.next(reader, event)?;
8981 if let Some(data) = data {
8982 self.content.push(SimpleContentContent::Extension(data));
8983 }
8984 if let Some(deserializer) = deserializer {
8985 *self.state = SimpleContentDeserializerState::Extension(deserializer);
8986 }
8987 Ok(DeserializerOutput {
8988 data: None,
8989 deserializer: Some(self),
8990 event,
8991 allow_any,
8992 })
8993 }
8994 }
8995 }
8996 fn finish<R>(self, _reader: &R) -> Result<super::SimpleContent, crate::quick_xml::Error>
8997 where
8998 R: crate::quick_xml::XmlReader,
8999 {
9000 use crate::quick_xml::ErrorKind;
9001 Ok(super::SimpleContent {
9002 id: self.id,
9003 content: self.content,
9004 })
9005 }
9006 }
9007 #[derive(Debug)]
9008 pub struct ComplexContentDeserializer {
9009 id: Option<String>,
9010 mixed: Option<bool>,
9011 content: Vec<super::ComplexContentContent>,
9012 state: Box<ComplexContentDeserializerState>,
9013 }
9014 #[derive(Debug)]
9015 enum ComplexContentDeserializerState {
9016 Next__,
9017 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
9018 Restriction(<RestrictionType as crate::quick_xml::WithDeserializer>::Deserializer),
9019 Extension(<ExtensionType as crate::quick_xml::WithDeserializer>::Deserializer),
9020 }
9021 impl ComplexContentDeserializer {
9022 fn from_bytes_start<R>(
9023 reader: &R,
9024 bytes_start: &crate::quick_xml::BytesStart<'_>,
9025 ) -> Result<Self, crate::quick_xml::Error>
9026 where
9027 R: crate::quick_xml::XmlReader,
9028 {
9029 use crate::quick_xml::ErrorKind;
9030 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
9031 let mut id: Option<String> = None;
9032 let mut mixed: Option<bool> = None;
9033 for attrib in bytes_start.attributes() {
9034 let attrib = attrib?;
9035 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
9036 continue;
9037 }
9038 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
9039 reader.read_attrib(&mut id, b"id", &attrib.value)?;
9040 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"mixed")) {
9041 reader.read_attrib(&mut mixed, b"mixed", &attrib.value)?;
9042 }
9043 }
9044 Ok(Self {
9045 id: id,
9046 mixed: mixed,
9047 content: Vec::new(),
9048 state: Box::new(ComplexContentDeserializerState::Next__),
9049 })
9050 }
9051 }
9052 impl<'de> crate::quick_xml::Deserializer<'de, super::ComplexContent>
9053 for ComplexContentDeserializer
9054 {
9055 fn init<R>(
9056 reader: &R,
9057 event: crate::quick_xml::Event<'de>,
9058 ) -> crate::quick_xml::DeserializerResult<'de, super::ComplexContent, Self>
9059 where
9060 R: crate::quick_xml::XmlReader,
9061 {
9062 use crate::quick_xml::{DeserializerOutput, Event};
9063 match event {
9064 Event::Start(start) => {
9065 let deserializer = Self::from_bytes_start(reader, &start)?;
9066 Ok(DeserializerOutput {
9067 data: None,
9068 deserializer: Some(deserializer),
9069 event: None,
9070 allow_any: false,
9071 })
9072 }
9073 Event::Empty(start) => {
9074 let deserializer = Self::from_bytes_start(reader, &start)?;
9075 let data = deserializer.finish(reader)?;
9076 Ok(DeserializerOutput {
9077 data: Some(data),
9078 deserializer: None,
9079 event: None,
9080 allow_any: false,
9081 })
9082 }
9083 event => Ok(DeserializerOutput {
9084 data: None,
9085 deserializer: None,
9086 event: Some(event),
9087 allow_any: false,
9088 }),
9089 }
9090 }
9091 fn next<R>(
9092 mut self,
9093 reader: &R,
9094 event: crate::quick_xml::Event<'de>,
9095 ) -> crate::quick_xml::DeserializerResult<'de, super::ComplexContent, Self>
9096 where
9097 R: crate::quick_xml::XmlReader,
9098 {
9099 use crate::quick_xml::{
9100 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
9101 };
9102 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
9103 match (
9104 core::mem::replace(&mut *self.state, ComplexContentDeserializerState::Next__),
9105 &event,
9106 ) {
9107 (ComplexContentDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
9108 if matches!(
9109 reader.resolve_local_name(x.name(), NS_XS),
9110 Some(b"annotation")
9111 ) {
9112 let DeserializerOutput {
9113 data,
9114 deserializer,
9115 event,
9116 allow_any,
9117 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
9118 if let Some(data) = data {
9119 self.content.push(ComplexContentContent::Annotation(data));
9120 }
9121 if let Some(deserializer) = deserializer {
9122 *self.state = ComplexContentDeserializerState::Annotation(deserializer);
9123 }
9124 Ok(DeserializerOutput {
9125 data: None,
9126 deserializer: Some(self),
9127 event,
9128 allow_any,
9129 })
9130 } else if matches!(
9131 reader.resolve_local_name(x.name(), NS_XS),
9132 Some(b"restriction")
9133 ) {
9134 let DeserializerOutput {
9135 data,
9136 deserializer,
9137 event,
9138 allow_any,
9139 } = <RestrictionType as WithDeserializer>::Deserializer::init(
9140 reader, event,
9141 )?;
9142 if let Some(data) = data {
9143 self.content.push(ComplexContentContent::Restriction(data));
9144 }
9145 if let Some(deserializer) = deserializer {
9146 *self.state =
9147 ComplexContentDeserializerState::Restriction(deserializer);
9148 }
9149 Ok(DeserializerOutput {
9150 data: None,
9151 deserializer: Some(self),
9152 event,
9153 allow_any,
9154 })
9155 } else if matches!(
9156 reader.resolve_local_name(x.name(), NS_XS),
9157 Some(b"extension")
9158 ) {
9159 let DeserializerOutput {
9160 data,
9161 deserializer,
9162 event,
9163 allow_any,
9164 } = <ExtensionType as WithDeserializer>::Deserializer::init(reader, event)?;
9165 if let Some(data) = data {
9166 self.content.push(ComplexContentContent::Extension(data));
9167 }
9168 if let Some(deserializer) = deserializer {
9169 *self.state = ComplexContentDeserializerState::Extension(deserializer);
9170 }
9171 Ok(DeserializerOutput {
9172 data: None,
9173 deserializer: Some(self),
9174 event,
9175 allow_any,
9176 })
9177 } else {
9178 Ok(DeserializerOutput {
9179 data: None,
9180 deserializer: Some(self),
9181 event: Some(event),
9182 allow_any: false,
9183 })
9184 }
9185 }
9186 (ComplexContentDeserializerState::Next__, Event::End(_)) => {
9187 let data = self.finish(reader)?;
9188 Ok(DeserializerOutput {
9189 data: Some(data),
9190 deserializer: None,
9191 event: None,
9192 allow_any: false,
9193 })
9194 }
9195 (ComplexContentDeserializerState::Next__, _) => Ok(DeserializerOutput {
9196 data: None,
9197 deserializer: Some(self),
9198 event: None,
9199 allow_any: false,
9200 }),
9201 (ComplexContentDeserializerState::Annotation(deserializer), _) => {
9202 let DeserializerOutput {
9203 data,
9204 deserializer,
9205 event,
9206 allow_any,
9207 } = deserializer.next(reader, event)?;
9208 if let Some(data) = data {
9209 self.content.push(ComplexContentContent::Annotation(data));
9210 }
9211 if let Some(deserializer) = deserializer {
9212 *self.state = ComplexContentDeserializerState::Annotation(deserializer);
9213 }
9214 Ok(DeserializerOutput {
9215 data: None,
9216 deserializer: Some(self),
9217 event,
9218 allow_any,
9219 })
9220 }
9221 (ComplexContentDeserializerState::Restriction(deserializer), _) => {
9222 let DeserializerOutput {
9223 data,
9224 deserializer,
9225 event,
9226 allow_any,
9227 } = deserializer.next(reader, event)?;
9228 if let Some(data) = data {
9229 self.content.push(ComplexContentContent::Restriction(data));
9230 }
9231 if let Some(deserializer) = deserializer {
9232 *self.state = ComplexContentDeserializerState::Restriction(deserializer);
9233 }
9234 Ok(DeserializerOutput {
9235 data: None,
9236 deserializer: Some(self),
9237 event,
9238 allow_any,
9239 })
9240 }
9241 (ComplexContentDeserializerState::Extension(deserializer), _) => {
9242 let DeserializerOutput {
9243 data,
9244 deserializer,
9245 event,
9246 allow_any,
9247 } = deserializer.next(reader, event)?;
9248 if let Some(data) = data {
9249 self.content.push(ComplexContentContent::Extension(data));
9250 }
9251 if let Some(deserializer) = deserializer {
9252 *self.state = ComplexContentDeserializerState::Extension(deserializer);
9253 }
9254 Ok(DeserializerOutput {
9255 data: None,
9256 deserializer: Some(self),
9257 event,
9258 allow_any,
9259 })
9260 }
9261 }
9262 }
9263 fn finish<R>(self, _reader: &R) -> Result<super::ComplexContent, crate::quick_xml::Error>
9264 where
9265 R: crate::quick_xml::XmlReader,
9266 {
9267 use crate::quick_xml::ErrorKind;
9268 Ok(super::ComplexContent {
9269 id: self.id,
9270 mixed: self.mixed,
9271 content: self.content,
9272 })
9273 }
9274 }
9275 #[derive(Debug)]
9276 pub struct OpenContentDeserializer {
9277 id: Option<String>,
9278 mode: super::OpenContentModeType,
9279 annotation: Option<super::Annotation>,
9280 any: Option<super::WildcardType>,
9281 state: Box<OpenContentDeserializerState>,
9282 }
9283 #[derive(Debug)]
9284 enum OpenContentDeserializerState {
9285 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
9286 Any(Option<<WildcardType as crate::quick_xml::WithDeserializer>::Deserializer>),
9287 Done__,
9288 }
9289 impl OpenContentDeserializer {
9290 fn from_bytes_start<R>(
9291 reader: &R,
9292 bytes_start: &crate::quick_xml::BytesStart<'_>,
9293 ) -> Result<Self, crate::quick_xml::Error>
9294 where
9295 R: crate::quick_xml::XmlReader,
9296 {
9297 use crate::quick_xml::ErrorKind;
9298 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
9299 let mut id: Option<String> = None;
9300 let mut mode: Option<OpenContentModeType> = None;
9301 for attrib in bytes_start.attributes() {
9302 let attrib = attrib?;
9303 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
9304 continue;
9305 }
9306 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
9307 reader.read_attrib(&mut id, b"id", &attrib.value)?;
9308 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"mode")) {
9309 reader.read_attrib(&mut mode, b"mode", &attrib.value)?;
9310 }
9311 }
9312 Ok(Self {
9313 id: id,
9314 mode: mode.unwrap_or_else(super::OpenContent::default_mode),
9315 annotation: None,
9316 any: None,
9317 state: Box::new(OpenContentDeserializerState::Annotation(None)),
9318 })
9319 }
9320 }
9321 impl<'de> crate::quick_xml::Deserializer<'de, super::OpenContent> for OpenContentDeserializer {
9322 fn init<R>(
9323 reader: &R,
9324 event: crate::quick_xml::Event<'de>,
9325 ) -> crate::quick_xml::DeserializerResult<'de, super::OpenContent, Self>
9326 where
9327 R: crate::quick_xml::XmlReader,
9328 {
9329 use crate::quick_xml::{DeserializerOutput, Event};
9330 match event {
9331 Event::Start(start) => {
9332 let deserializer = Self::from_bytes_start(reader, &start)?;
9333 Ok(DeserializerOutput {
9334 data: None,
9335 deserializer: Some(deserializer),
9336 event: None,
9337 allow_any: false,
9338 })
9339 }
9340 Event::Empty(start) => {
9341 let deserializer = Self::from_bytes_start(reader, &start)?;
9342 let data = deserializer.finish(reader)?;
9343 Ok(DeserializerOutput {
9344 data: Some(data),
9345 deserializer: None,
9346 event: None,
9347 allow_any: false,
9348 })
9349 }
9350 event => Ok(DeserializerOutput {
9351 data: None,
9352 deserializer: None,
9353 event: Some(event),
9354 allow_any: false,
9355 }),
9356 }
9357 }
9358 fn next<R>(
9359 mut self,
9360 reader: &R,
9361 event: crate::quick_xml::Event<'de>,
9362 ) -> crate::quick_xml::DeserializerResult<'de, super::OpenContent, Self>
9363 where
9364 R: crate::quick_xml::XmlReader,
9365 {
9366 use crate::quick_xml::{
9367 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
9368 };
9369 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
9370 let mut event = event;
9371 let mut allow_any_fallback = None;
9372 loop {
9373 event = match (
9374 core::mem::replace(&mut *self.state, OpenContentDeserializerState::Done__),
9375 event,
9376 ) {
9377 (OpenContentDeserializerState::Annotation(Some(deserializer)), event) => {
9378 let DeserializerOutput {
9379 data,
9380 deserializer,
9381 event,
9382 allow_any,
9383 } = deserializer.next(reader, event)?;
9384 if let Some(data) = data {
9385 if self.annotation.is_some() {
9386 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9387 b"annotation",
9388 )))?;
9389 }
9390 self.annotation = Some(data);
9391 }
9392 let event = match event {
9393 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
9394 event
9395 }
9396 event => {
9397 *self.state =
9398 OpenContentDeserializerState::Annotation(deserializer);
9399 return Ok(DeserializerOutput {
9400 data: None,
9401 deserializer: Some(self),
9402 event: event,
9403 allow_any: false,
9404 });
9405 }
9406 };
9407 if allow_any {
9408 allow_any_fallback.get_or_insert(
9409 OpenContentDeserializerState::Annotation(deserializer),
9410 );
9411 } else if let Some(deserializer) = deserializer {
9412 let data = deserializer.finish(reader)?;
9413 if self.annotation.is_some() {
9414 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9415 b"annotation",
9416 )))?;
9417 }
9418 self.annotation = Some(data);
9419 }
9420 *self.state = OpenContentDeserializerState::Annotation(None);
9421 event
9422 }
9423 (OpenContentDeserializerState::Annotation(None), event) => match &event {
9424 Event::Start(x) | Event::Empty(x)
9425 if matches!(
9426 reader.resolve_local_name(x.name(), NS_XS),
9427 Some(b"annotation")
9428 ) =>
9429 {
9430 let DeserializerOutput {
9431 data,
9432 deserializer,
9433 event,
9434 allow_any,
9435 } = <Annotation as WithDeserializer>::Deserializer::init(
9436 reader, event,
9437 )?;
9438 if let Some(data) = data {
9439 if self.annotation.is_some() {
9440 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9441 b"annotation",
9442 )))?;
9443 }
9444 self.annotation = Some(data);
9445 }
9446 *self.state = OpenContentDeserializerState::Annotation(deserializer);
9447 match event {
9448 Some(event @ (Event::Start(_) | Event::End(_))) => {
9449 *self.state = OpenContentDeserializerState::Any(None);
9450 if allow_any {
9451 allow_any_fallback.get_or_insert(
9452 OpenContentDeserializerState::Annotation(None),
9453 );
9454 }
9455 event
9456 }
9457 event @ (None | Some(_)) => {
9458 return Ok(DeserializerOutput {
9459 data: None,
9460 deserializer: Some(self),
9461 event,
9462 allow_any: false,
9463 })
9464 }
9465 }
9466 }
9467 Event::Start(_) | Event::Empty(_) => {
9468 *self.state = OpenContentDeserializerState::Any(None);
9469 allow_any_fallback
9470 .get_or_insert(OpenContentDeserializerState::Annotation(None));
9471 event
9472 }
9473 Event::End(_) => {
9474 let data = self.finish(reader)?;
9475 return Ok(DeserializerOutput {
9476 data: Some(data),
9477 deserializer: None,
9478 event: None,
9479 allow_any: false,
9480 });
9481 }
9482 _ => {
9483 *self.state = OpenContentDeserializerState::Annotation(None);
9484 return Ok(DeserializerOutput {
9485 data: None,
9486 deserializer: Some(self),
9487 event: Some(event),
9488 allow_any: false,
9489 });
9490 }
9491 },
9492 (OpenContentDeserializerState::Any(Some(deserializer)), event) => {
9493 let DeserializerOutput {
9494 data,
9495 deserializer,
9496 event,
9497 allow_any,
9498 } = deserializer.next(reader, event)?;
9499 if let Some(data) = data {
9500 if self.any.is_some() {
9501 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"any")))?;
9502 }
9503 self.any = Some(data);
9504 }
9505 let event = match event {
9506 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
9507 event
9508 }
9509 event => {
9510 *self.state = OpenContentDeserializerState::Any(deserializer);
9511 return Ok(DeserializerOutput {
9512 data: None,
9513 deserializer: Some(self),
9514 event: event,
9515 allow_any: false,
9516 });
9517 }
9518 };
9519 if allow_any {
9520 allow_any_fallback
9521 .get_or_insert(OpenContentDeserializerState::Any(deserializer));
9522 } else if let Some(deserializer) = deserializer {
9523 let data = deserializer.finish(reader)?;
9524 if self.any.is_some() {
9525 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"any")))?;
9526 }
9527 self.any = Some(data);
9528 }
9529 *self.state = OpenContentDeserializerState::Any(None);
9530 event
9531 }
9532 (OpenContentDeserializerState::Any(None), event) => match &event {
9533 Event::Start(x) | Event::Empty(x)
9534 if matches!(
9535 reader.resolve_local_name(x.name(), NS_XS),
9536 Some(b"any")
9537 ) =>
9538 {
9539 let DeserializerOutput {
9540 data,
9541 deserializer,
9542 event,
9543 allow_any,
9544 } = <WildcardType as WithDeserializer>::Deserializer::init(
9545 reader, event,
9546 )?;
9547 if let Some(data) = data {
9548 if self.any.is_some() {
9549 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9550 b"any",
9551 )))?;
9552 }
9553 self.any = Some(data);
9554 }
9555 *self.state = OpenContentDeserializerState::Any(deserializer);
9556 match event {
9557 Some(event @ (Event::Start(_) | Event::End(_))) => {
9558 *self.state = OpenContentDeserializerState::Done__;
9559 if allow_any {
9560 allow_any_fallback
9561 .get_or_insert(OpenContentDeserializerState::Any(None));
9562 }
9563 event
9564 }
9565 event @ (None | Some(_)) => {
9566 return Ok(DeserializerOutput {
9567 data: None,
9568 deserializer: Some(self),
9569 event,
9570 allow_any: false,
9571 })
9572 }
9573 }
9574 }
9575 Event::Start(_) | Event::Empty(_) => {
9576 *self.state = OpenContentDeserializerState::Done__;
9577 allow_any_fallback
9578 .get_or_insert(OpenContentDeserializerState::Any(None));
9579 event
9580 }
9581 Event::End(_) => {
9582 let data = self.finish(reader)?;
9583 return Ok(DeserializerOutput {
9584 data: Some(data),
9585 deserializer: None,
9586 event: None,
9587 allow_any: false,
9588 });
9589 }
9590 _ => {
9591 *self.state = OpenContentDeserializerState::Any(None);
9592 return Ok(DeserializerOutput {
9593 data: None,
9594 deserializer: Some(self),
9595 event: Some(event),
9596 allow_any: false,
9597 });
9598 }
9599 },
9600 (OpenContentDeserializerState::Done__, event) => {
9601 let allow_any = if let Some(fallback) = allow_any_fallback {
9602 *self.state = fallback;
9603 true
9604 } else {
9605 false
9606 };
9607 return Ok(DeserializerOutput {
9608 data: None,
9609 deserializer: Some(self),
9610 event: Some(event),
9611 allow_any,
9612 });
9613 }
9614 }
9615 }
9616 }
9617 fn finish<R>(self, _reader: &R) -> Result<super::OpenContent, crate::quick_xml::Error>
9618 where
9619 R: crate::quick_xml::XmlReader,
9620 {
9621 use crate::quick_xml::ErrorKind;
9622 Ok(super::OpenContent {
9623 id: self.id,
9624 mode: self.mode,
9625 annotation: self.annotation,
9626 any: self.any,
9627 })
9628 }
9629 }
9630 #[derive(Debug)]
9631 pub struct AnyAttributeDeserializer {
9632 id: Option<String>,
9633 namespace: Option<super::NamespaceListType>,
9634 not_namespace: Option<super::NotNamespaceType>,
9635 process_contents: super::ProcessContentsType,
9636 not_q_name: Option<super::QnameListAType>,
9637 annotation: Option<super::Annotation>,
9638 state: Box<AnyAttributeDeserializerState>,
9639 }
9640 #[derive(Debug)]
9641 enum AnyAttributeDeserializerState {
9642 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
9643 Done__,
9644 }
9645 impl AnyAttributeDeserializer {
9646 fn from_bytes_start<R>(
9647 reader: &R,
9648 bytes_start: &crate::quick_xml::BytesStart<'_>,
9649 ) -> Result<Self, crate::quick_xml::Error>
9650 where
9651 R: crate::quick_xml::XmlReader,
9652 {
9653 use crate::quick_xml::ErrorKind;
9654 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
9655 let mut id: Option<String> = None;
9656 let mut namespace: Option<NamespaceListType> = None;
9657 let mut not_namespace: Option<NotNamespaceType> = None;
9658 let mut process_contents: Option<ProcessContentsType> = None;
9659 let mut not_q_name: Option<QnameListAType> = None;
9660 for attrib in bytes_start.attributes() {
9661 let attrib = attrib?;
9662 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
9663 continue;
9664 }
9665 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
9666 reader.read_attrib(&mut id, b"id", &attrib.value)?;
9667 } else if matches!(
9668 reader.resolve_local_name(attrib.key, NS_XS),
9669 Some(b"namespace")
9670 ) {
9671 reader.read_attrib(&mut namespace, b"namespace", &attrib.value)?;
9672 } else if matches!(
9673 reader.resolve_local_name(attrib.key, NS_XS),
9674 Some(b"notNamespace")
9675 ) {
9676 reader.read_attrib(&mut not_namespace, b"notNamespace", &attrib.value)?;
9677 } else if matches!(
9678 reader.resolve_local_name(attrib.key, NS_XS),
9679 Some(b"processContents")
9680 ) {
9681 reader.read_attrib(&mut process_contents, b"processContents", &attrib.value)?;
9682 } else if matches!(
9683 reader.resolve_local_name(attrib.key, NS_XS),
9684 Some(b"notQName")
9685 ) {
9686 reader.read_attrib(&mut not_q_name, b"notQName", &attrib.value)?;
9687 }
9688 }
9689 Ok(Self {
9690 id: id,
9691 namespace: namespace,
9692 not_namespace: not_namespace,
9693 process_contents: process_contents
9694 .unwrap_or_else(super::AnyAttribute::default_process_contents),
9695 not_q_name: not_q_name,
9696 annotation: None,
9697 state: Box::new(AnyAttributeDeserializerState::Annotation(None)),
9698 })
9699 }
9700 }
9701 impl<'de> crate::quick_xml::Deserializer<'de, super::AnyAttribute> for AnyAttributeDeserializer {
9702 fn init<R>(
9703 reader: &R,
9704 event: crate::quick_xml::Event<'de>,
9705 ) -> crate::quick_xml::DeserializerResult<'de, super::AnyAttribute, Self>
9706 where
9707 R: crate::quick_xml::XmlReader,
9708 {
9709 use crate::quick_xml::{DeserializerOutput, Event};
9710 match event {
9711 Event::Start(start) => {
9712 let deserializer = Self::from_bytes_start(reader, &start)?;
9713 Ok(DeserializerOutput {
9714 data: None,
9715 deserializer: Some(deserializer),
9716 event: None,
9717 allow_any: false,
9718 })
9719 }
9720 Event::Empty(start) => {
9721 let deserializer = Self::from_bytes_start(reader, &start)?;
9722 let data = deserializer.finish(reader)?;
9723 Ok(DeserializerOutput {
9724 data: Some(data),
9725 deserializer: None,
9726 event: None,
9727 allow_any: false,
9728 })
9729 }
9730 event => Ok(DeserializerOutput {
9731 data: None,
9732 deserializer: None,
9733 event: Some(event),
9734 allow_any: false,
9735 }),
9736 }
9737 }
9738 fn next<R>(
9739 mut self,
9740 reader: &R,
9741 event: crate::quick_xml::Event<'de>,
9742 ) -> crate::quick_xml::DeserializerResult<'de, super::AnyAttribute, Self>
9743 where
9744 R: crate::quick_xml::XmlReader,
9745 {
9746 use crate::quick_xml::{
9747 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
9748 };
9749 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
9750 let mut event = event;
9751 let mut allow_any_fallback = None;
9752 loop {
9753 event = match (
9754 core::mem::replace(&mut *self.state, AnyAttributeDeserializerState::Done__),
9755 event,
9756 ) {
9757 (AnyAttributeDeserializerState::Annotation(Some(deserializer)), event) => {
9758 let DeserializerOutput {
9759 data,
9760 deserializer,
9761 event,
9762 allow_any,
9763 } = deserializer.next(reader, event)?;
9764 if let Some(data) = data {
9765 if self.annotation.is_some() {
9766 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9767 b"annotation",
9768 )))?;
9769 }
9770 self.annotation = Some(data);
9771 }
9772 let event = match event {
9773 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
9774 event
9775 }
9776 event => {
9777 *self.state =
9778 AnyAttributeDeserializerState::Annotation(deserializer);
9779 return Ok(DeserializerOutput {
9780 data: None,
9781 deserializer: Some(self),
9782 event: event,
9783 allow_any: false,
9784 });
9785 }
9786 };
9787 if allow_any {
9788 allow_any_fallback.get_or_insert(
9789 AnyAttributeDeserializerState::Annotation(deserializer),
9790 );
9791 } else if let Some(deserializer) = deserializer {
9792 let data = deserializer.finish(reader)?;
9793 if self.annotation.is_some() {
9794 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9795 b"annotation",
9796 )))?;
9797 }
9798 self.annotation = Some(data);
9799 }
9800 *self.state = AnyAttributeDeserializerState::Annotation(None);
9801 event
9802 }
9803 (AnyAttributeDeserializerState::Annotation(None), event) => match &event {
9804 Event::Start(x) | Event::Empty(x)
9805 if matches!(
9806 reader.resolve_local_name(x.name(), NS_XS),
9807 Some(b"annotation")
9808 ) =>
9809 {
9810 let DeserializerOutput {
9811 data,
9812 deserializer,
9813 event,
9814 allow_any,
9815 } = <Annotation as WithDeserializer>::Deserializer::init(
9816 reader, event,
9817 )?;
9818 if let Some(data) = data {
9819 if self.annotation.is_some() {
9820 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9821 b"annotation",
9822 )))?;
9823 }
9824 self.annotation = Some(data);
9825 }
9826 *self.state = AnyAttributeDeserializerState::Annotation(deserializer);
9827 match event {
9828 Some(event @ (Event::Start(_) | Event::End(_))) => {
9829 *self.state = AnyAttributeDeserializerState::Done__;
9830 if allow_any {
9831 allow_any_fallback.get_or_insert(
9832 AnyAttributeDeserializerState::Annotation(None),
9833 );
9834 }
9835 event
9836 }
9837 event @ (None | Some(_)) => {
9838 return Ok(DeserializerOutput {
9839 data: None,
9840 deserializer: Some(self),
9841 event,
9842 allow_any: false,
9843 })
9844 }
9845 }
9846 }
9847 Event::Start(_) | Event::Empty(_) => {
9848 *self.state = AnyAttributeDeserializerState::Done__;
9849 allow_any_fallback
9850 .get_or_insert(AnyAttributeDeserializerState::Annotation(None));
9851 event
9852 }
9853 Event::End(_) => {
9854 let data = self.finish(reader)?;
9855 return Ok(DeserializerOutput {
9856 data: Some(data),
9857 deserializer: None,
9858 event: None,
9859 allow_any: false,
9860 });
9861 }
9862 _ => {
9863 *self.state = AnyAttributeDeserializerState::Annotation(None);
9864 return Ok(DeserializerOutput {
9865 data: None,
9866 deserializer: Some(self),
9867 event: Some(event),
9868 allow_any: false,
9869 });
9870 }
9871 },
9872 (AnyAttributeDeserializerState::Done__, event) => {
9873 let allow_any = if let Some(fallback) = allow_any_fallback {
9874 *self.state = fallback;
9875 true
9876 } else {
9877 false
9878 };
9879 return Ok(DeserializerOutput {
9880 data: None,
9881 deserializer: Some(self),
9882 event: Some(event),
9883 allow_any,
9884 });
9885 }
9886 }
9887 }
9888 }
9889 fn finish<R>(self, _reader: &R) -> Result<super::AnyAttribute, crate::quick_xml::Error>
9890 where
9891 R: crate::quick_xml::XmlReader,
9892 {
9893 use crate::quick_xml::ErrorKind;
9894 Ok(super::AnyAttribute {
9895 id: self.id,
9896 namespace: self.namespace,
9897 not_namespace: self.not_namespace,
9898 process_contents: self.process_contents,
9899 not_q_name: self.not_q_name,
9900 annotation: self.annotation,
9901 })
9902 }
9903 }
9904 #[derive(Debug)]
9905 pub struct AssertionTypeDeserializer {
9906 id: Option<String>,
9907 test: Option<String>,
9908 xpath_default_namespace: Option<super::XpathDefaultNamespaceType>,
9909 annotation: Option<super::Annotation>,
9910 state: Box<AssertionTypeDeserializerState>,
9911 }
9912 #[derive(Debug)]
9913 enum AssertionTypeDeserializerState {
9914 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
9915 Done__,
9916 }
9917 impl AssertionTypeDeserializer {
9918 fn from_bytes_start<R>(
9919 reader: &R,
9920 bytes_start: &crate::quick_xml::BytesStart<'_>,
9921 ) -> Result<Self, crate::quick_xml::Error>
9922 where
9923 R: crate::quick_xml::XmlReader,
9924 {
9925 use crate::quick_xml::ErrorKind;
9926 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
9927 let mut id: Option<String> = None;
9928 let mut test: Option<String> = None;
9929 let mut xpath_default_namespace: Option<XpathDefaultNamespaceType> = None;
9930 for attrib in bytes_start.attributes() {
9931 let attrib = attrib?;
9932 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
9933 continue;
9934 }
9935 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
9936 reader.read_attrib(&mut id, b"id", &attrib.value)?;
9937 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"test")) {
9938 reader.read_attrib(&mut test, b"test", &attrib.value)?;
9939 } else if matches!(
9940 reader.resolve_local_name(attrib.key, NS_XS),
9941 Some(b"xpathDefaultNamespace")
9942 ) {
9943 reader.read_attrib(
9944 &mut xpath_default_namespace,
9945 b"xpathDefaultNamespace",
9946 &attrib.value,
9947 )?;
9948 }
9949 }
9950 Ok(Self {
9951 id: id,
9952 test: test,
9953 xpath_default_namespace: xpath_default_namespace,
9954 annotation: None,
9955 state: Box::new(AssertionTypeDeserializerState::Annotation(None)),
9956 })
9957 }
9958 }
9959 impl<'de> crate::quick_xml::Deserializer<'de, super::AssertionType> for AssertionTypeDeserializer {
9960 fn init<R>(
9961 reader: &R,
9962 event: crate::quick_xml::Event<'de>,
9963 ) -> crate::quick_xml::DeserializerResult<'de, super::AssertionType, Self>
9964 where
9965 R: crate::quick_xml::XmlReader,
9966 {
9967 use crate::quick_xml::{DeserializerOutput, Event};
9968 match event {
9969 Event::Start(start) => {
9970 let deserializer = Self::from_bytes_start(reader, &start)?;
9971 Ok(DeserializerOutput {
9972 data: None,
9973 deserializer: Some(deserializer),
9974 event: None,
9975 allow_any: false,
9976 })
9977 }
9978 Event::Empty(start) => {
9979 let deserializer = Self::from_bytes_start(reader, &start)?;
9980 let data = deserializer.finish(reader)?;
9981 Ok(DeserializerOutput {
9982 data: Some(data),
9983 deserializer: None,
9984 event: None,
9985 allow_any: false,
9986 })
9987 }
9988 event => Ok(DeserializerOutput {
9989 data: None,
9990 deserializer: None,
9991 event: Some(event),
9992 allow_any: false,
9993 }),
9994 }
9995 }
9996 fn next<R>(
9997 mut self,
9998 reader: &R,
9999 event: crate::quick_xml::Event<'de>,
10000 ) -> crate::quick_xml::DeserializerResult<'de, super::AssertionType, Self>
10001 where
10002 R: crate::quick_xml::XmlReader,
10003 {
10004 use crate::quick_xml::{
10005 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
10006 };
10007 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
10008 let mut event = event;
10009 let mut allow_any_fallback = None;
10010 loop {
10011 event = match (
10012 core::mem::replace(&mut *self.state, AssertionTypeDeserializerState::Done__),
10013 event,
10014 ) {
10015 (AssertionTypeDeserializerState::Annotation(Some(deserializer)), event) => {
10016 let DeserializerOutput {
10017 data,
10018 deserializer,
10019 event,
10020 allow_any,
10021 } = deserializer.next(reader, event)?;
10022 if let Some(data) = data {
10023 if self.annotation.is_some() {
10024 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10025 b"annotation",
10026 )))?;
10027 }
10028 self.annotation = Some(data);
10029 }
10030 let event = match event {
10031 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
10032 event
10033 }
10034 event => {
10035 *self.state =
10036 AssertionTypeDeserializerState::Annotation(deserializer);
10037 return Ok(DeserializerOutput {
10038 data: None,
10039 deserializer: Some(self),
10040 event: event,
10041 allow_any: false,
10042 });
10043 }
10044 };
10045 if allow_any {
10046 allow_any_fallback.get_or_insert(
10047 AssertionTypeDeserializerState::Annotation(deserializer),
10048 );
10049 } else if let Some(deserializer) = deserializer {
10050 let data = deserializer.finish(reader)?;
10051 if self.annotation.is_some() {
10052 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10053 b"annotation",
10054 )))?;
10055 }
10056 self.annotation = Some(data);
10057 }
10058 *self.state = AssertionTypeDeserializerState::Annotation(None);
10059 event
10060 }
10061 (AssertionTypeDeserializerState::Annotation(None), event) => match &event {
10062 Event::Start(x) | Event::Empty(x)
10063 if matches!(
10064 reader.resolve_local_name(x.name(), NS_XS),
10065 Some(b"annotation")
10066 ) =>
10067 {
10068 let DeserializerOutput {
10069 data,
10070 deserializer,
10071 event,
10072 allow_any,
10073 } = <Annotation as WithDeserializer>::Deserializer::init(
10074 reader, event,
10075 )?;
10076 if let Some(data) = data {
10077 if self.annotation.is_some() {
10078 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10079 b"annotation",
10080 )))?;
10081 }
10082 self.annotation = Some(data);
10083 }
10084 *self.state = AssertionTypeDeserializerState::Annotation(deserializer);
10085 match event {
10086 Some(event @ (Event::Start(_) | Event::End(_))) => {
10087 *self.state = AssertionTypeDeserializerState::Done__;
10088 if allow_any {
10089 allow_any_fallback.get_or_insert(
10090 AssertionTypeDeserializerState::Annotation(None),
10091 );
10092 }
10093 event
10094 }
10095 event @ (None | Some(_)) => {
10096 return Ok(DeserializerOutput {
10097 data: None,
10098 deserializer: Some(self),
10099 event,
10100 allow_any: false,
10101 })
10102 }
10103 }
10104 }
10105 Event::Start(_) | Event::Empty(_) => {
10106 *self.state = AssertionTypeDeserializerState::Done__;
10107 allow_any_fallback
10108 .get_or_insert(AssertionTypeDeserializerState::Annotation(None));
10109 event
10110 }
10111 Event::End(_) => {
10112 let data = self.finish(reader)?;
10113 return Ok(DeserializerOutput {
10114 data: Some(data),
10115 deserializer: None,
10116 event: None,
10117 allow_any: false,
10118 });
10119 }
10120 _ => {
10121 *self.state = AssertionTypeDeserializerState::Annotation(None);
10122 return Ok(DeserializerOutput {
10123 data: None,
10124 deserializer: Some(self),
10125 event: Some(event),
10126 allow_any: false,
10127 });
10128 }
10129 },
10130 (AssertionTypeDeserializerState::Done__, event) => {
10131 let allow_any = if let Some(fallback) = allow_any_fallback {
10132 *self.state = fallback;
10133 true
10134 } else {
10135 false
10136 };
10137 return Ok(DeserializerOutput {
10138 data: None,
10139 deserializer: Some(self),
10140 event: Some(event),
10141 allow_any,
10142 });
10143 }
10144 }
10145 }
10146 }
10147 fn finish<R>(self, _reader: &R) -> Result<super::AssertionType, crate::quick_xml::Error>
10148 where
10149 R: crate::quick_xml::XmlReader,
10150 {
10151 use crate::quick_xml::ErrorKind;
10152 Ok(super::AssertionType {
10153 id: self.id,
10154 test: self.test,
10155 xpath_default_namespace: self.xpath_default_namespace,
10156 annotation: self.annotation,
10157 })
10158 }
10159 }
10160 #[derive(Debug)]
10161 pub struct AnyDeserializer {
10162 id: Option<String>,
10163 namespace: Option<super::NamespaceListType>,
10164 not_namespace: Option<super::NotNamespaceType>,
10165 process_contents: super::ProcessContentsType,
10166 not_q_name: Option<super::QnameListType>,
10167 min_occurs: usize,
10168 max_occurs: super::MaxOccurs,
10169 annotation: Option<super::Annotation>,
10170 state: Box<AnyDeserializerState>,
10171 }
10172 #[derive(Debug)]
10173 enum AnyDeserializerState {
10174 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
10175 Done__,
10176 }
10177 impl AnyDeserializer {
10178 fn from_bytes_start<R>(
10179 reader: &R,
10180 bytes_start: &crate::quick_xml::BytesStart<'_>,
10181 ) -> Result<Self, crate::quick_xml::Error>
10182 where
10183 R: crate::quick_xml::XmlReader,
10184 {
10185 use crate::quick_xml::ErrorKind;
10186 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
10187 let mut id: Option<String> = None;
10188 let mut namespace: Option<NamespaceListType> = None;
10189 let mut not_namespace: Option<NotNamespaceType> = None;
10190 let mut process_contents: Option<ProcessContentsType> = None;
10191 let mut not_q_name: Option<QnameListType> = None;
10192 let mut min_occurs: Option<usize> = None;
10193 let mut max_occurs: Option<MaxOccurs> = None;
10194 for attrib in bytes_start.attributes() {
10195 let attrib = attrib?;
10196 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
10197 continue;
10198 }
10199 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
10200 reader.read_attrib(&mut id, b"id", &attrib.value)?;
10201 } else if matches!(
10202 reader.resolve_local_name(attrib.key, NS_XS),
10203 Some(b"namespace")
10204 ) {
10205 reader.read_attrib(&mut namespace, b"namespace", &attrib.value)?;
10206 } else if matches!(
10207 reader.resolve_local_name(attrib.key, NS_XS),
10208 Some(b"notNamespace")
10209 ) {
10210 reader.read_attrib(&mut not_namespace, b"notNamespace", &attrib.value)?;
10211 } else if matches!(
10212 reader.resolve_local_name(attrib.key, NS_XS),
10213 Some(b"processContents")
10214 ) {
10215 reader.read_attrib(&mut process_contents, b"processContents", &attrib.value)?;
10216 } else if matches!(
10217 reader.resolve_local_name(attrib.key, NS_XS),
10218 Some(b"notQName")
10219 ) {
10220 reader.read_attrib(&mut not_q_name, b"notQName", &attrib.value)?;
10221 } else if matches!(
10222 reader.resolve_local_name(attrib.key, NS_XS),
10223 Some(b"minOccurs")
10224 ) {
10225 reader.read_attrib(&mut min_occurs, b"minOccurs", &attrib.value)?;
10226 } else if matches!(
10227 reader.resolve_local_name(attrib.key, NS_XS),
10228 Some(b"maxOccurs")
10229 ) {
10230 reader.read_attrib(&mut max_occurs, b"maxOccurs", &attrib.value)?;
10231 }
10232 }
10233 Ok(Self {
10234 id: id,
10235 namespace: namespace,
10236 not_namespace: not_namespace,
10237 process_contents: process_contents
10238 .unwrap_or_else(super::Any::default_process_contents),
10239 not_q_name: not_q_name,
10240 min_occurs: min_occurs.unwrap_or_else(super::Any::default_min_occurs),
10241 max_occurs: max_occurs.unwrap_or_else(super::Any::default_max_occurs),
10242 annotation: None,
10243 state: Box::new(AnyDeserializerState::Annotation(None)),
10244 })
10245 }
10246 }
10247 impl<'de> crate::quick_xml::Deserializer<'de, super::Any> for AnyDeserializer {
10248 fn init<R>(
10249 reader: &R,
10250 event: crate::quick_xml::Event<'de>,
10251 ) -> crate::quick_xml::DeserializerResult<'de, super::Any, Self>
10252 where
10253 R: crate::quick_xml::XmlReader,
10254 {
10255 use crate::quick_xml::{DeserializerOutput, Event};
10256 match event {
10257 Event::Start(start) => {
10258 let deserializer = Self::from_bytes_start(reader, &start)?;
10259 Ok(DeserializerOutput {
10260 data: None,
10261 deserializer: Some(deserializer),
10262 event: None,
10263 allow_any: false,
10264 })
10265 }
10266 Event::Empty(start) => {
10267 let deserializer = Self::from_bytes_start(reader, &start)?;
10268 let data = deserializer.finish(reader)?;
10269 Ok(DeserializerOutput {
10270 data: Some(data),
10271 deserializer: None,
10272 event: None,
10273 allow_any: false,
10274 })
10275 }
10276 event => Ok(DeserializerOutput {
10277 data: None,
10278 deserializer: None,
10279 event: Some(event),
10280 allow_any: false,
10281 }),
10282 }
10283 }
10284 fn next<R>(
10285 mut self,
10286 reader: &R,
10287 event: crate::quick_xml::Event<'de>,
10288 ) -> crate::quick_xml::DeserializerResult<'de, super::Any, Self>
10289 where
10290 R: crate::quick_xml::XmlReader,
10291 {
10292 use crate::quick_xml::{
10293 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
10294 };
10295 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
10296 let mut event = event;
10297 let mut allow_any_fallback = None;
10298 loop {
10299 event = match (
10300 core::mem::replace(&mut *self.state, AnyDeserializerState::Done__),
10301 event,
10302 ) {
10303 (AnyDeserializerState::Annotation(Some(deserializer)), event) => {
10304 let DeserializerOutput {
10305 data,
10306 deserializer,
10307 event,
10308 allow_any,
10309 } = deserializer.next(reader, event)?;
10310 if let Some(data) = data {
10311 if self.annotation.is_some() {
10312 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10313 b"annotation",
10314 )))?;
10315 }
10316 self.annotation = Some(data);
10317 }
10318 let event = match event {
10319 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
10320 event
10321 }
10322 event => {
10323 *self.state = AnyDeserializerState::Annotation(deserializer);
10324 return Ok(DeserializerOutput {
10325 data: None,
10326 deserializer: Some(self),
10327 event: event,
10328 allow_any: false,
10329 });
10330 }
10331 };
10332 if allow_any {
10333 allow_any_fallback
10334 .get_or_insert(AnyDeserializerState::Annotation(deserializer));
10335 } else if let Some(deserializer) = deserializer {
10336 let data = deserializer.finish(reader)?;
10337 if self.annotation.is_some() {
10338 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10339 b"annotation",
10340 )))?;
10341 }
10342 self.annotation = Some(data);
10343 }
10344 *self.state = AnyDeserializerState::Annotation(None);
10345 event
10346 }
10347 (AnyDeserializerState::Annotation(None), event) => match &event {
10348 Event::Start(x) | Event::Empty(x)
10349 if matches!(
10350 reader.resolve_local_name(x.name(), NS_XS),
10351 Some(b"annotation")
10352 ) =>
10353 {
10354 let DeserializerOutput {
10355 data,
10356 deserializer,
10357 event,
10358 allow_any,
10359 } = <Annotation as WithDeserializer>::Deserializer::init(
10360 reader, event,
10361 )?;
10362 if let Some(data) = data {
10363 if self.annotation.is_some() {
10364 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10365 b"annotation",
10366 )))?;
10367 }
10368 self.annotation = Some(data);
10369 }
10370 *self.state = AnyDeserializerState::Annotation(deserializer);
10371 match event {
10372 Some(event @ (Event::Start(_) | Event::End(_))) => {
10373 *self.state = AnyDeserializerState::Done__;
10374 if allow_any {
10375 allow_any_fallback
10376 .get_or_insert(AnyDeserializerState::Annotation(None));
10377 }
10378 event
10379 }
10380 event @ (None | Some(_)) => {
10381 return Ok(DeserializerOutput {
10382 data: None,
10383 deserializer: Some(self),
10384 event,
10385 allow_any: false,
10386 })
10387 }
10388 }
10389 }
10390 Event::Start(_) | Event::Empty(_) => {
10391 *self.state = AnyDeserializerState::Done__;
10392 allow_any_fallback
10393 .get_or_insert(AnyDeserializerState::Annotation(None));
10394 event
10395 }
10396 Event::End(_) => {
10397 let data = self.finish(reader)?;
10398 return Ok(DeserializerOutput {
10399 data: Some(data),
10400 deserializer: None,
10401 event: None,
10402 allow_any: false,
10403 });
10404 }
10405 _ => {
10406 *self.state = AnyDeserializerState::Annotation(None);
10407 return Ok(DeserializerOutput {
10408 data: None,
10409 deserializer: Some(self),
10410 event: Some(event),
10411 allow_any: false,
10412 });
10413 }
10414 },
10415 (AnyDeserializerState::Done__, event) => {
10416 let allow_any = if let Some(fallback) = allow_any_fallback {
10417 *self.state = fallback;
10418 true
10419 } else {
10420 false
10421 };
10422 return Ok(DeserializerOutput {
10423 data: None,
10424 deserializer: Some(self),
10425 event: Some(event),
10426 allow_any,
10427 });
10428 }
10429 }
10430 }
10431 }
10432 fn finish<R>(self, _reader: &R) -> Result<super::Any, crate::quick_xml::Error>
10433 where
10434 R: crate::quick_xml::XmlReader,
10435 {
10436 use crate::quick_xml::ErrorKind;
10437 Ok(super::Any {
10438 id: self.id,
10439 namespace: self.namespace,
10440 not_namespace: self.not_namespace,
10441 process_contents: self.process_contents,
10442 not_q_name: self.not_q_name,
10443 min_occurs: self.min_occurs,
10444 max_occurs: self.max_occurs,
10445 annotation: self.annotation,
10446 })
10447 }
10448 }
10449 #[derive(Debug)]
10450 pub struct AltTypeDeserializer {
10451 id: Option<String>,
10452 test: Option<String>,
10453 type_: Option<super::QName>,
10454 xpath_default_namespace: Option<super::XpathDefaultNamespaceType>,
10455 content: Vec<super::AltTypeContent>,
10456 state: Box<AltTypeDeserializerState>,
10457 }
10458 #[derive(Debug)]
10459 enum AltTypeDeserializerState {
10460 Next__,
10461 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
10462 SimpleType(<SimpleBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
10463 ComplexType(<ComplexBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
10464 }
10465 impl AltTypeDeserializer {
10466 fn from_bytes_start<R>(
10467 reader: &R,
10468 bytes_start: &crate::quick_xml::BytesStart<'_>,
10469 ) -> Result<Self, crate::quick_xml::Error>
10470 where
10471 R: crate::quick_xml::XmlReader,
10472 {
10473 use crate::quick_xml::ErrorKind;
10474 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
10475 let mut id: Option<String> = None;
10476 let mut test: Option<String> = None;
10477 let mut type_: Option<QName> = None;
10478 let mut xpath_default_namespace: Option<XpathDefaultNamespaceType> = None;
10479 for attrib in bytes_start.attributes() {
10480 let attrib = attrib?;
10481 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
10482 continue;
10483 }
10484 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
10485 reader.read_attrib(&mut id, b"id", &attrib.value)?;
10486 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"test")) {
10487 reader.read_attrib(&mut test, b"test", &attrib.value)?;
10488 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"type")) {
10489 reader.read_attrib(&mut type_, b"type", &attrib.value)?;
10490 } else if matches!(
10491 reader.resolve_local_name(attrib.key, NS_XS),
10492 Some(b"xpathDefaultNamespace")
10493 ) {
10494 reader.read_attrib(
10495 &mut xpath_default_namespace,
10496 b"xpathDefaultNamespace",
10497 &attrib.value,
10498 )?;
10499 }
10500 }
10501 Ok(Self {
10502 id: id,
10503 test: test,
10504 type_: type_,
10505 xpath_default_namespace: xpath_default_namespace,
10506 content: Vec::new(),
10507 state: Box::new(AltTypeDeserializerState::Next__),
10508 })
10509 }
10510 }
10511 impl<'de> crate::quick_xml::Deserializer<'de, super::AltType> for AltTypeDeserializer {
10512 fn init<R>(
10513 reader: &R,
10514 event: crate::quick_xml::Event<'de>,
10515 ) -> crate::quick_xml::DeserializerResult<'de, super::AltType, Self>
10516 where
10517 R: crate::quick_xml::XmlReader,
10518 {
10519 use crate::quick_xml::{DeserializerOutput, Event};
10520 match event {
10521 Event::Start(start) => {
10522 let deserializer = Self::from_bytes_start(reader, &start)?;
10523 Ok(DeserializerOutput {
10524 data: None,
10525 deserializer: Some(deserializer),
10526 event: None,
10527 allow_any: false,
10528 })
10529 }
10530 Event::Empty(start) => {
10531 let deserializer = Self::from_bytes_start(reader, &start)?;
10532 let data = deserializer.finish(reader)?;
10533 Ok(DeserializerOutput {
10534 data: Some(data),
10535 deserializer: None,
10536 event: None,
10537 allow_any: false,
10538 })
10539 }
10540 event => Ok(DeserializerOutput {
10541 data: None,
10542 deserializer: None,
10543 event: Some(event),
10544 allow_any: false,
10545 }),
10546 }
10547 }
10548 fn next<R>(
10549 mut self,
10550 reader: &R,
10551 event: crate::quick_xml::Event<'de>,
10552 ) -> crate::quick_xml::DeserializerResult<'de, super::AltType, Self>
10553 where
10554 R: crate::quick_xml::XmlReader,
10555 {
10556 use crate::quick_xml::{
10557 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
10558 };
10559 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
10560 match (
10561 core::mem::replace(&mut *self.state, AltTypeDeserializerState::Next__),
10562 &event,
10563 ) {
10564 (AltTypeDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
10565 if matches!(
10566 reader.resolve_local_name(x.name(), NS_XS),
10567 Some(b"annotation")
10568 ) {
10569 let DeserializerOutput {
10570 data,
10571 deserializer,
10572 event,
10573 allow_any,
10574 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
10575 if let Some(data) = data {
10576 self.content.push(AltTypeContent::Annotation(data));
10577 }
10578 if let Some(deserializer) = deserializer {
10579 *self.state = AltTypeDeserializerState::Annotation(deserializer);
10580 }
10581 Ok(DeserializerOutput {
10582 data: None,
10583 deserializer: Some(self),
10584 event,
10585 allow_any,
10586 })
10587 } else if matches!(
10588 reader.resolve_local_name(x.name(), NS_XS),
10589 Some(b"simpleType")
10590 ) {
10591 let DeserializerOutput {
10592 data,
10593 deserializer,
10594 event,
10595 allow_any,
10596 } = <SimpleBaseType as WithDeserializer>::Deserializer::init(
10597 reader, event,
10598 )?;
10599 if let Some(data) = data {
10600 self.content.push(AltTypeContent::SimpleType(data));
10601 }
10602 if let Some(deserializer) = deserializer {
10603 *self.state = AltTypeDeserializerState::SimpleType(deserializer);
10604 }
10605 Ok(DeserializerOutput {
10606 data: None,
10607 deserializer: Some(self),
10608 event,
10609 allow_any,
10610 })
10611 } else if matches!(
10612 reader.resolve_local_name(x.name(), NS_XS),
10613 Some(b"complexType")
10614 ) {
10615 let DeserializerOutput {
10616 data,
10617 deserializer,
10618 event,
10619 allow_any,
10620 } = <ComplexBaseType as WithDeserializer>::Deserializer::init(
10621 reader, event,
10622 )?;
10623 if let Some(data) = data {
10624 self.content.push(AltTypeContent::ComplexType(data));
10625 }
10626 if let Some(deserializer) = deserializer {
10627 *self.state = AltTypeDeserializerState::ComplexType(deserializer);
10628 }
10629 Ok(DeserializerOutput {
10630 data: None,
10631 deserializer: Some(self),
10632 event,
10633 allow_any,
10634 })
10635 } else {
10636 Ok(DeserializerOutput {
10637 data: None,
10638 deserializer: Some(self),
10639 event: Some(event),
10640 allow_any: false,
10641 })
10642 }
10643 }
10644 (AltTypeDeserializerState::Next__, Event::End(_)) => {
10645 let data = self.finish(reader)?;
10646 Ok(DeserializerOutput {
10647 data: Some(data),
10648 deserializer: None,
10649 event: None,
10650 allow_any: false,
10651 })
10652 }
10653 (AltTypeDeserializerState::Next__, _) => Ok(DeserializerOutput {
10654 data: None,
10655 deserializer: Some(self),
10656 event: None,
10657 allow_any: false,
10658 }),
10659 (AltTypeDeserializerState::Annotation(deserializer), _) => {
10660 let DeserializerOutput {
10661 data,
10662 deserializer,
10663 event,
10664 allow_any,
10665 } = deserializer.next(reader, event)?;
10666 if let Some(data) = data {
10667 self.content.push(AltTypeContent::Annotation(data));
10668 }
10669 if let Some(deserializer) = deserializer {
10670 *self.state = AltTypeDeserializerState::Annotation(deserializer);
10671 }
10672 Ok(DeserializerOutput {
10673 data: None,
10674 deserializer: Some(self),
10675 event,
10676 allow_any,
10677 })
10678 }
10679 (AltTypeDeserializerState::SimpleType(deserializer), _) => {
10680 let DeserializerOutput {
10681 data,
10682 deserializer,
10683 event,
10684 allow_any,
10685 } = deserializer.next(reader, event)?;
10686 if let Some(data) = data {
10687 self.content.push(AltTypeContent::SimpleType(data));
10688 }
10689 if let Some(deserializer) = deserializer {
10690 *self.state = AltTypeDeserializerState::SimpleType(deserializer);
10691 }
10692 Ok(DeserializerOutput {
10693 data: None,
10694 deserializer: Some(self),
10695 event,
10696 allow_any,
10697 })
10698 }
10699 (AltTypeDeserializerState::ComplexType(deserializer), _) => {
10700 let DeserializerOutput {
10701 data,
10702 deserializer,
10703 event,
10704 allow_any,
10705 } = deserializer.next(reader, event)?;
10706 if let Some(data) = data {
10707 self.content.push(AltTypeContent::ComplexType(data));
10708 }
10709 if let Some(deserializer) = deserializer {
10710 *self.state = AltTypeDeserializerState::ComplexType(deserializer);
10711 }
10712 Ok(DeserializerOutput {
10713 data: None,
10714 deserializer: Some(self),
10715 event,
10716 allow_any,
10717 })
10718 }
10719 }
10720 }
10721 fn finish<R>(self, _reader: &R) -> Result<super::AltType, crate::quick_xml::Error>
10722 where
10723 R: crate::quick_xml::XmlReader,
10724 {
10725 use crate::quick_xml::ErrorKind;
10726 Ok(super::AltType {
10727 id: self.id,
10728 test: self.test,
10729 type_: self.type_,
10730 xpath_default_namespace: self.xpath_default_namespace,
10731 content: self.content,
10732 })
10733 }
10734 }
10735 #[derive(Debug)]
10736 pub struct KeybaseTypeDeserializer {
10737 id: Option<String>,
10738 name: Option<String>,
10739 ref_: Option<super::QName>,
10740 annotation: Option<super::Annotation>,
10741 selector: Option<super::Field>,
10742 field: Vec<super::Field>,
10743 state: Box<KeybaseTypeDeserializerState>,
10744 }
10745 #[derive(Debug)]
10746 enum KeybaseTypeDeserializerState {
10747 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
10748 Selector(Option<<Field as crate::quick_xml::WithDeserializer>::Deserializer>),
10749 Field(Option<<Field as crate::quick_xml::WithDeserializer>::Deserializer>),
10750 Done__,
10751 }
10752 impl KeybaseTypeDeserializer {
10753 fn from_bytes_start<R>(
10754 reader: &R,
10755 bytes_start: &crate::quick_xml::BytesStart<'_>,
10756 ) -> Result<Self, crate::quick_xml::Error>
10757 where
10758 R: crate::quick_xml::XmlReader,
10759 {
10760 use crate::quick_xml::ErrorKind;
10761 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
10762 let mut id: Option<String> = None;
10763 let mut name: Option<String> = None;
10764 let mut ref_: Option<QName> = None;
10765 for attrib in bytes_start.attributes() {
10766 let attrib = attrib?;
10767 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
10768 continue;
10769 }
10770 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
10771 reader.read_attrib(&mut id, b"id", &attrib.value)?;
10772 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"name")) {
10773 reader.read_attrib(&mut name, b"name", &attrib.value)?;
10774 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"ref")) {
10775 reader.read_attrib(&mut ref_, b"ref", &attrib.value)?;
10776 }
10777 }
10778 Ok(Self {
10779 id: id,
10780 name: name,
10781 ref_: ref_,
10782 annotation: None,
10783 selector: None,
10784 field: Vec::new(),
10785 state: Box::new(KeybaseTypeDeserializerState::Annotation(None)),
10786 })
10787 }
10788 }
10789 impl<'de> crate::quick_xml::Deserializer<'de, super::KeybaseType> for KeybaseTypeDeserializer {
10790 fn init<R>(
10791 reader: &R,
10792 event: crate::quick_xml::Event<'de>,
10793 ) -> crate::quick_xml::DeserializerResult<'de, super::KeybaseType, Self>
10794 where
10795 R: crate::quick_xml::XmlReader,
10796 {
10797 use crate::quick_xml::{DeserializerOutput, Event};
10798 match event {
10799 Event::Start(start) => {
10800 let deserializer = Self::from_bytes_start(reader, &start)?;
10801 Ok(DeserializerOutput {
10802 data: None,
10803 deserializer: Some(deserializer),
10804 event: None,
10805 allow_any: false,
10806 })
10807 }
10808 Event::Empty(start) => {
10809 let deserializer = Self::from_bytes_start(reader, &start)?;
10810 let data = deserializer.finish(reader)?;
10811 Ok(DeserializerOutput {
10812 data: Some(data),
10813 deserializer: None,
10814 event: None,
10815 allow_any: false,
10816 })
10817 }
10818 event => Ok(DeserializerOutput {
10819 data: None,
10820 deserializer: None,
10821 event: Some(event),
10822 allow_any: false,
10823 }),
10824 }
10825 }
10826 fn next<R>(
10827 mut self,
10828 reader: &R,
10829 event: crate::quick_xml::Event<'de>,
10830 ) -> crate::quick_xml::DeserializerResult<'de, super::KeybaseType, Self>
10831 where
10832 R: crate::quick_xml::XmlReader,
10833 {
10834 use crate::quick_xml::{
10835 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
10836 };
10837 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
10838 let mut event = event;
10839 let mut allow_any_fallback = None;
10840 loop {
10841 event = match (
10842 core::mem::replace(&mut *self.state, KeybaseTypeDeserializerState::Done__),
10843 event,
10844 ) {
10845 (KeybaseTypeDeserializerState::Annotation(Some(deserializer)), event) => {
10846 let DeserializerOutput {
10847 data,
10848 deserializer,
10849 event,
10850 allow_any,
10851 } = deserializer.next(reader, event)?;
10852 if let Some(data) = data {
10853 if self.annotation.is_some() {
10854 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10855 b"annotation",
10856 )))?;
10857 }
10858 self.annotation = Some(data);
10859 }
10860 let event = match event {
10861 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
10862 event
10863 }
10864 event => {
10865 *self.state =
10866 KeybaseTypeDeserializerState::Annotation(deserializer);
10867 return Ok(DeserializerOutput {
10868 data: None,
10869 deserializer: Some(self),
10870 event: event,
10871 allow_any: false,
10872 });
10873 }
10874 };
10875 if allow_any {
10876 allow_any_fallback.get_or_insert(
10877 KeybaseTypeDeserializerState::Annotation(deserializer),
10878 );
10879 } else if let Some(deserializer) = deserializer {
10880 let data = deserializer.finish(reader)?;
10881 if self.annotation.is_some() {
10882 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10883 b"annotation",
10884 )))?;
10885 }
10886 self.annotation = Some(data);
10887 }
10888 *self.state = KeybaseTypeDeserializerState::Annotation(None);
10889 event
10890 }
10891 (KeybaseTypeDeserializerState::Annotation(None), event) => match &event {
10892 Event::Start(x) | Event::Empty(x)
10893 if matches!(
10894 reader.resolve_local_name(x.name(), NS_XS),
10895 Some(b"annotation")
10896 ) =>
10897 {
10898 let DeserializerOutput {
10899 data,
10900 deserializer,
10901 event,
10902 allow_any,
10903 } = <Annotation as WithDeserializer>::Deserializer::init(
10904 reader, event,
10905 )?;
10906 if let Some(data) = data {
10907 if self.annotation.is_some() {
10908 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10909 b"annotation",
10910 )))?;
10911 }
10912 self.annotation = Some(data);
10913 }
10914 *self.state = KeybaseTypeDeserializerState::Annotation(deserializer);
10915 match event {
10916 Some(event @ (Event::Start(_) | Event::End(_))) => {
10917 *self.state = KeybaseTypeDeserializerState::Selector(None);
10918 if allow_any {
10919 allow_any_fallback.get_or_insert(
10920 KeybaseTypeDeserializerState::Annotation(None),
10921 );
10922 }
10923 event
10924 }
10925 event @ (None | Some(_)) => {
10926 return Ok(DeserializerOutput {
10927 data: None,
10928 deserializer: Some(self),
10929 event,
10930 allow_any: false,
10931 })
10932 }
10933 }
10934 }
10935 Event::Start(_) | Event::Empty(_) => {
10936 *self.state = KeybaseTypeDeserializerState::Selector(None);
10937 allow_any_fallback
10938 .get_or_insert(KeybaseTypeDeserializerState::Annotation(None));
10939 event
10940 }
10941 Event::End(_) => {
10942 let data = self.finish(reader)?;
10943 return Ok(DeserializerOutput {
10944 data: Some(data),
10945 deserializer: None,
10946 event: None,
10947 allow_any: false,
10948 });
10949 }
10950 _ => {
10951 *self.state = KeybaseTypeDeserializerState::Annotation(None);
10952 return Ok(DeserializerOutput {
10953 data: None,
10954 deserializer: Some(self),
10955 event: Some(event),
10956 allow_any: false,
10957 });
10958 }
10959 },
10960 (KeybaseTypeDeserializerState::Selector(Some(deserializer)), event) => {
10961 let DeserializerOutput {
10962 data,
10963 deserializer,
10964 event,
10965 allow_any,
10966 } = deserializer.next(reader, event)?;
10967 if let Some(data) = data {
10968 if self.selector.is_some() {
10969 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10970 b"selector",
10971 )))?;
10972 }
10973 self.selector = Some(data);
10974 }
10975 let event = match event {
10976 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
10977 event
10978 }
10979 event => {
10980 *self.state = KeybaseTypeDeserializerState::Selector(deserializer);
10981 return Ok(DeserializerOutput {
10982 data: None,
10983 deserializer: Some(self),
10984 event: event,
10985 allow_any: false,
10986 });
10987 }
10988 };
10989 if allow_any {
10990 allow_any_fallback.get_or_insert(
10991 KeybaseTypeDeserializerState::Selector(deserializer),
10992 );
10993 } else if let Some(deserializer) = deserializer {
10994 let data = deserializer.finish(reader)?;
10995 if self.selector.is_some() {
10996 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10997 b"selector",
10998 )))?;
10999 }
11000 self.selector = Some(data);
11001 }
11002 *self.state = KeybaseTypeDeserializerState::Selector(None);
11003 event
11004 }
11005 (KeybaseTypeDeserializerState::Selector(None), event) => match &event {
11006 Event::Start(x) | Event::Empty(x)
11007 if matches!(
11008 reader.resolve_local_name(x.name(), NS_XS),
11009 Some(b"selector")
11010 ) =>
11011 {
11012 let DeserializerOutput {
11013 data,
11014 deserializer,
11015 event,
11016 allow_any,
11017 } = <Field as WithDeserializer>::Deserializer::init(reader, event)?;
11018 if let Some(data) = data {
11019 if self.selector.is_some() {
11020 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11021 b"selector",
11022 )))?;
11023 }
11024 self.selector = Some(data);
11025 }
11026 *self.state = KeybaseTypeDeserializerState::Selector(deserializer);
11027 match event {
11028 Some(event @ (Event::Start(_) | Event::End(_))) => {
11029 *self.state = KeybaseTypeDeserializerState::Field(None);
11030 if allow_any {
11031 allow_any_fallback.get_or_insert(
11032 KeybaseTypeDeserializerState::Selector(None),
11033 );
11034 }
11035 event
11036 }
11037 event @ (None | Some(_)) => {
11038 return Ok(DeserializerOutput {
11039 data: None,
11040 deserializer: Some(self),
11041 event,
11042 allow_any: false,
11043 })
11044 }
11045 }
11046 }
11047 Event::Start(_) | Event::Empty(_) => {
11048 *self.state = KeybaseTypeDeserializerState::Field(None);
11049 allow_any_fallback
11050 .get_or_insert(KeybaseTypeDeserializerState::Selector(None));
11051 event
11052 }
11053 Event::End(_) => {
11054 let data = self.finish(reader)?;
11055 return Ok(DeserializerOutput {
11056 data: Some(data),
11057 deserializer: None,
11058 event: None,
11059 allow_any: false,
11060 });
11061 }
11062 _ => {
11063 *self.state = KeybaseTypeDeserializerState::Selector(None);
11064 return Ok(DeserializerOutput {
11065 data: None,
11066 deserializer: Some(self),
11067 event: Some(event),
11068 allow_any: false,
11069 });
11070 }
11071 },
11072 (KeybaseTypeDeserializerState::Field(Some(deserializer)), event) => {
11073 let DeserializerOutput {
11074 data,
11075 deserializer,
11076 event,
11077 allow_any,
11078 } = deserializer.next(reader, event)?;
11079 if let Some(data) = data {
11080 self.field.push(data);
11081 }
11082 let event = match event {
11083 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
11084 event
11085 }
11086 event => {
11087 *self.state = KeybaseTypeDeserializerState::Field(deserializer);
11088 return Ok(DeserializerOutput {
11089 data: None,
11090 deserializer: Some(self),
11091 event: event,
11092 allow_any: false,
11093 });
11094 }
11095 };
11096 if allow_any {
11097 allow_any_fallback
11098 .get_or_insert(KeybaseTypeDeserializerState::Field(deserializer));
11099 } else if let Some(deserializer) = deserializer {
11100 let data = deserializer.finish(reader)?;
11101 self.field.push(data);
11102 }
11103 *self.state = KeybaseTypeDeserializerState::Field(None);
11104 event
11105 }
11106 (KeybaseTypeDeserializerState::Field(None), event) => match &event {
11107 Event::Start(x) | Event::Empty(x)
11108 if matches!(
11109 reader.resolve_local_name(x.name(), NS_XS),
11110 Some(b"field")
11111 ) =>
11112 {
11113 let DeserializerOutput {
11114 data,
11115 deserializer,
11116 event,
11117 allow_any,
11118 } = <Field as WithDeserializer>::Deserializer::init(reader, event)?;
11119 if let Some(data) = data {
11120 self.field.push(data);
11121 }
11122 *self.state = KeybaseTypeDeserializerState::Field(deserializer);
11123 match event {
11124 Some(event @ (Event::Start(_) | Event::End(_))) => {
11125 *self.state = KeybaseTypeDeserializerState::Done__;
11126 if allow_any {
11127 allow_any_fallback.get_or_insert(
11128 KeybaseTypeDeserializerState::Field(None),
11129 );
11130 }
11131 event
11132 }
11133 event @ (None | Some(_)) => {
11134 return Ok(DeserializerOutput {
11135 data: None,
11136 deserializer: Some(self),
11137 event,
11138 allow_any: false,
11139 })
11140 }
11141 }
11142 }
11143 Event::Start(_) | Event::Empty(_) => {
11144 *self.state = KeybaseTypeDeserializerState::Done__;
11145 allow_any_fallback
11146 .get_or_insert(KeybaseTypeDeserializerState::Field(None));
11147 event
11148 }
11149 Event::End(_) => {
11150 let data = self.finish(reader)?;
11151 return Ok(DeserializerOutput {
11152 data: Some(data),
11153 deserializer: None,
11154 event: None,
11155 allow_any: false,
11156 });
11157 }
11158 _ => {
11159 *self.state = KeybaseTypeDeserializerState::Field(None);
11160 return Ok(DeserializerOutput {
11161 data: None,
11162 deserializer: Some(self),
11163 event: Some(event),
11164 allow_any: false,
11165 });
11166 }
11167 },
11168 (KeybaseTypeDeserializerState::Done__, event) => {
11169 let allow_any = if let Some(fallback) = allow_any_fallback {
11170 *self.state = fallback;
11171 true
11172 } else {
11173 false
11174 };
11175 return Ok(DeserializerOutput {
11176 data: None,
11177 deserializer: Some(self),
11178 event: Some(event),
11179 allow_any,
11180 });
11181 }
11182 }
11183 }
11184 }
11185 fn finish<R>(self, _reader: &R) -> Result<super::KeybaseType, crate::quick_xml::Error>
11186 where
11187 R: crate::quick_xml::XmlReader,
11188 {
11189 use crate::quick_xml::ErrorKind;
11190 Ok(super::KeybaseType {
11191 id: self.id,
11192 name: self.name,
11193 ref_: self.ref_,
11194 annotation: self.annotation,
11195 selector: self
11196 .selector
11197 .ok_or_else(|| ErrorKind::MissingElement("selector".into()))?,
11198 field: self.field,
11199 })
11200 }
11201 }
11202 #[derive(Debug)]
11203 pub struct KeyrefDeserializer {
11204 id: Option<String>,
11205 name: Option<String>,
11206 ref_: Option<super::QName>,
11207 refer: Option<super::QName>,
11208 annotation: Option<super::Annotation>,
11209 selector: Option<super::Field>,
11210 field: Vec<super::Field>,
11211 state: Box<KeyrefDeserializerState>,
11212 }
11213 #[derive(Debug)]
11214 enum KeyrefDeserializerState {
11215 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
11216 Selector(Option<<Field as crate::quick_xml::WithDeserializer>::Deserializer>),
11217 Field(Option<<Field as crate::quick_xml::WithDeserializer>::Deserializer>),
11218 Done__,
11219 }
11220 impl KeyrefDeserializer {
11221 fn from_bytes_start<R>(
11222 reader: &R,
11223 bytes_start: &crate::quick_xml::BytesStart<'_>,
11224 ) -> Result<Self, crate::quick_xml::Error>
11225 where
11226 R: crate::quick_xml::XmlReader,
11227 {
11228 use crate::quick_xml::ErrorKind;
11229 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
11230 let mut id: Option<String> = None;
11231 let mut name: Option<String> = None;
11232 let mut ref_: Option<QName> = None;
11233 let mut refer: Option<QName> = None;
11234 for attrib in bytes_start.attributes() {
11235 let attrib = attrib?;
11236 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
11237 continue;
11238 }
11239 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
11240 reader.read_attrib(&mut id, b"id", &attrib.value)?;
11241 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"name")) {
11242 reader.read_attrib(&mut name, b"name", &attrib.value)?;
11243 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"ref")) {
11244 reader.read_attrib(&mut ref_, b"ref", &attrib.value)?;
11245 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"refer")) {
11246 reader.read_attrib(&mut refer, b"refer", &attrib.value)?;
11247 }
11248 }
11249 Ok(Self {
11250 id: id,
11251 name: name,
11252 ref_: ref_,
11253 refer: refer,
11254 annotation: None,
11255 selector: None,
11256 field: Vec::new(),
11257 state: Box::new(KeyrefDeserializerState::Annotation(None)),
11258 })
11259 }
11260 }
11261 impl<'de> crate::quick_xml::Deserializer<'de, super::Keyref> for KeyrefDeserializer {
11262 fn init<R>(
11263 reader: &R,
11264 event: crate::quick_xml::Event<'de>,
11265 ) -> crate::quick_xml::DeserializerResult<'de, super::Keyref, Self>
11266 where
11267 R: crate::quick_xml::XmlReader,
11268 {
11269 use crate::quick_xml::{DeserializerOutput, Event};
11270 match event {
11271 Event::Start(start) => {
11272 let deserializer = Self::from_bytes_start(reader, &start)?;
11273 Ok(DeserializerOutput {
11274 data: None,
11275 deserializer: Some(deserializer),
11276 event: None,
11277 allow_any: false,
11278 })
11279 }
11280 Event::Empty(start) => {
11281 let deserializer = Self::from_bytes_start(reader, &start)?;
11282 let data = deserializer.finish(reader)?;
11283 Ok(DeserializerOutput {
11284 data: Some(data),
11285 deserializer: None,
11286 event: None,
11287 allow_any: false,
11288 })
11289 }
11290 event => Ok(DeserializerOutput {
11291 data: None,
11292 deserializer: None,
11293 event: Some(event),
11294 allow_any: false,
11295 }),
11296 }
11297 }
11298 fn next<R>(
11299 mut self,
11300 reader: &R,
11301 event: crate::quick_xml::Event<'de>,
11302 ) -> crate::quick_xml::DeserializerResult<'de, super::Keyref, Self>
11303 where
11304 R: crate::quick_xml::XmlReader,
11305 {
11306 use crate::quick_xml::{
11307 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
11308 };
11309 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
11310 let mut event = event;
11311 let mut allow_any_fallback = None;
11312 loop {
11313 event = match (
11314 core::mem::replace(&mut *self.state, KeyrefDeserializerState::Done__),
11315 event,
11316 ) {
11317 (KeyrefDeserializerState::Annotation(Some(deserializer)), event) => {
11318 let DeserializerOutput {
11319 data,
11320 deserializer,
11321 event,
11322 allow_any,
11323 } = deserializer.next(reader, event)?;
11324 if let Some(data) = data {
11325 if self.annotation.is_some() {
11326 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11327 b"annotation",
11328 )))?;
11329 }
11330 self.annotation = Some(data);
11331 }
11332 let event = match event {
11333 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
11334 event
11335 }
11336 event => {
11337 *self.state = KeyrefDeserializerState::Annotation(deserializer);
11338 return Ok(DeserializerOutput {
11339 data: None,
11340 deserializer: Some(self),
11341 event: event,
11342 allow_any: false,
11343 });
11344 }
11345 };
11346 if allow_any {
11347 allow_any_fallback
11348 .get_or_insert(KeyrefDeserializerState::Annotation(deserializer));
11349 } else if let Some(deserializer) = deserializer {
11350 let data = deserializer.finish(reader)?;
11351 if self.annotation.is_some() {
11352 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11353 b"annotation",
11354 )))?;
11355 }
11356 self.annotation = Some(data);
11357 }
11358 *self.state = KeyrefDeserializerState::Annotation(None);
11359 event
11360 }
11361 (KeyrefDeserializerState::Annotation(None), event) => match &event {
11362 Event::Start(x) | Event::Empty(x)
11363 if matches!(
11364 reader.resolve_local_name(x.name(), NS_XS),
11365 Some(b"annotation")
11366 ) =>
11367 {
11368 let DeserializerOutput {
11369 data,
11370 deserializer,
11371 event,
11372 allow_any,
11373 } = <Annotation as WithDeserializer>::Deserializer::init(
11374 reader, event,
11375 )?;
11376 if let Some(data) = data {
11377 if self.annotation.is_some() {
11378 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11379 b"annotation",
11380 )))?;
11381 }
11382 self.annotation = Some(data);
11383 }
11384 *self.state = KeyrefDeserializerState::Annotation(deserializer);
11385 match event {
11386 Some(event @ (Event::Start(_) | Event::End(_))) => {
11387 *self.state = KeyrefDeserializerState::Selector(None);
11388 if allow_any {
11389 allow_any_fallback.get_or_insert(
11390 KeyrefDeserializerState::Annotation(None),
11391 );
11392 }
11393 event
11394 }
11395 event @ (None | Some(_)) => {
11396 return Ok(DeserializerOutput {
11397 data: None,
11398 deserializer: Some(self),
11399 event,
11400 allow_any: false,
11401 })
11402 }
11403 }
11404 }
11405 Event::Start(_) | Event::Empty(_) => {
11406 *self.state = KeyrefDeserializerState::Selector(None);
11407 allow_any_fallback
11408 .get_or_insert(KeyrefDeserializerState::Annotation(None));
11409 event
11410 }
11411 Event::End(_) => {
11412 let data = self.finish(reader)?;
11413 return Ok(DeserializerOutput {
11414 data: Some(data),
11415 deserializer: None,
11416 event: None,
11417 allow_any: false,
11418 });
11419 }
11420 _ => {
11421 *self.state = KeyrefDeserializerState::Annotation(None);
11422 return Ok(DeserializerOutput {
11423 data: None,
11424 deserializer: Some(self),
11425 event: Some(event),
11426 allow_any: false,
11427 });
11428 }
11429 },
11430 (KeyrefDeserializerState::Selector(Some(deserializer)), event) => {
11431 let DeserializerOutput {
11432 data,
11433 deserializer,
11434 event,
11435 allow_any,
11436 } = deserializer.next(reader, event)?;
11437 if let Some(data) = data {
11438 if self.selector.is_some() {
11439 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11440 b"selector",
11441 )))?;
11442 }
11443 self.selector = Some(data);
11444 }
11445 let event = match event {
11446 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
11447 event
11448 }
11449 event => {
11450 *self.state = KeyrefDeserializerState::Selector(deserializer);
11451 return Ok(DeserializerOutput {
11452 data: None,
11453 deserializer: Some(self),
11454 event: event,
11455 allow_any: false,
11456 });
11457 }
11458 };
11459 if allow_any {
11460 allow_any_fallback
11461 .get_or_insert(KeyrefDeserializerState::Selector(deserializer));
11462 } else if let Some(deserializer) = deserializer {
11463 let data = deserializer.finish(reader)?;
11464 if self.selector.is_some() {
11465 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11466 b"selector",
11467 )))?;
11468 }
11469 self.selector = Some(data);
11470 }
11471 *self.state = KeyrefDeserializerState::Selector(None);
11472 event
11473 }
11474 (KeyrefDeserializerState::Selector(None), event) => match &event {
11475 Event::Start(x) | Event::Empty(x)
11476 if matches!(
11477 reader.resolve_local_name(x.name(), NS_XS),
11478 Some(b"selector")
11479 ) =>
11480 {
11481 let DeserializerOutput {
11482 data,
11483 deserializer,
11484 event,
11485 allow_any,
11486 } = <Field as WithDeserializer>::Deserializer::init(reader, event)?;
11487 if let Some(data) = data {
11488 if self.selector.is_some() {
11489 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11490 b"selector",
11491 )))?;
11492 }
11493 self.selector = Some(data);
11494 }
11495 *self.state = KeyrefDeserializerState::Selector(deserializer);
11496 match event {
11497 Some(event @ (Event::Start(_) | Event::End(_))) => {
11498 *self.state = KeyrefDeserializerState::Field(None);
11499 if allow_any {
11500 allow_any_fallback
11501 .get_or_insert(KeyrefDeserializerState::Selector(None));
11502 }
11503 event
11504 }
11505 event @ (None | Some(_)) => {
11506 return Ok(DeserializerOutput {
11507 data: None,
11508 deserializer: Some(self),
11509 event,
11510 allow_any: false,
11511 })
11512 }
11513 }
11514 }
11515 Event::Start(_) | Event::Empty(_) => {
11516 *self.state = KeyrefDeserializerState::Field(None);
11517 allow_any_fallback
11518 .get_or_insert(KeyrefDeserializerState::Selector(None));
11519 event
11520 }
11521 Event::End(_) => {
11522 let data = self.finish(reader)?;
11523 return Ok(DeserializerOutput {
11524 data: Some(data),
11525 deserializer: None,
11526 event: None,
11527 allow_any: false,
11528 });
11529 }
11530 _ => {
11531 *self.state = KeyrefDeserializerState::Selector(None);
11532 return Ok(DeserializerOutput {
11533 data: None,
11534 deserializer: Some(self),
11535 event: Some(event),
11536 allow_any: false,
11537 });
11538 }
11539 },
11540 (KeyrefDeserializerState::Field(Some(deserializer)), event) => {
11541 let DeserializerOutput {
11542 data,
11543 deserializer,
11544 event,
11545 allow_any,
11546 } = deserializer.next(reader, event)?;
11547 if let Some(data) = data {
11548 self.field.push(data);
11549 }
11550 let event = match event {
11551 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
11552 event
11553 }
11554 event => {
11555 *self.state = KeyrefDeserializerState::Field(deserializer);
11556 return Ok(DeserializerOutput {
11557 data: None,
11558 deserializer: Some(self),
11559 event: event,
11560 allow_any: false,
11561 });
11562 }
11563 };
11564 if allow_any {
11565 allow_any_fallback
11566 .get_or_insert(KeyrefDeserializerState::Field(deserializer));
11567 } else if let Some(deserializer) = deserializer {
11568 let data = deserializer.finish(reader)?;
11569 self.field.push(data);
11570 }
11571 *self.state = KeyrefDeserializerState::Field(None);
11572 event
11573 }
11574 (KeyrefDeserializerState::Field(None), event) => match &event {
11575 Event::Start(x) | Event::Empty(x)
11576 if matches!(
11577 reader.resolve_local_name(x.name(), NS_XS),
11578 Some(b"field")
11579 ) =>
11580 {
11581 let DeserializerOutput {
11582 data,
11583 deserializer,
11584 event,
11585 allow_any,
11586 } = <Field as WithDeserializer>::Deserializer::init(reader, event)?;
11587 if let Some(data) = data {
11588 self.field.push(data);
11589 }
11590 *self.state = KeyrefDeserializerState::Field(deserializer);
11591 match event {
11592 Some(event @ (Event::Start(_) | Event::End(_))) => {
11593 *self.state = KeyrefDeserializerState::Done__;
11594 if allow_any {
11595 allow_any_fallback
11596 .get_or_insert(KeyrefDeserializerState::Field(None));
11597 }
11598 event
11599 }
11600 event @ (None | Some(_)) => {
11601 return Ok(DeserializerOutput {
11602 data: None,
11603 deserializer: Some(self),
11604 event,
11605 allow_any: false,
11606 })
11607 }
11608 }
11609 }
11610 Event::Start(_) | Event::Empty(_) => {
11611 *self.state = KeyrefDeserializerState::Done__;
11612 allow_any_fallback.get_or_insert(KeyrefDeserializerState::Field(None));
11613 event
11614 }
11615 Event::End(_) => {
11616 let data = self.finish(reader)?;
11617 return Ok(DeserializerOutput {
11618 data: Some(data),
11619 deserializer: None,
11620 event: None,
11621 allow_any: false,
11622 });
11623 }
11624 _ => {
11625 *self.state = KeyrefDeserializerState::Field(None);
11626 return Ok(DeserializerOutput {
11627 data: None,
11628 deserializer: Some(self),
11629 event: Some(event),
11630 allow_any: false,
11631 });
11632 }
11633 },
11634 (KeyrefDeserializerState::Done__, event) => {
11635 let allow_any = if let Some(fallback) = allow_any_fallback {
11636 *self.state = fallback;
11637 true
11638 } else {
11639 false
11640 };
11641 return Ok(DeserializerOutput {
11642 data: None,
11643 deserializer: Some(self),
11644 event: Some(event),
11645 allow_any,
11646 });
11647 }
11648 }
11649 }
11650 }
11651 fn finish<R>(self, _reader: &R) -> Result<super::Keyref, crate::quick_xml::Error>
11652 where
11653 R: crate::quick_xml::XmlReader,
11654 {
11655 use crate::quick_xml::ErrorKind;
11656 Ok(super::Keyref {
11657 id: self.id,
11658 name: self.name,
11659 ref_: self.ref_,
11660 refer: self.refer,
11661 annotation: self.annotation,
11662 selector: self
11663 .selector
11664 .ok_or_else(|| ErrorKind::MissingElement("selector".into()))?,
11665 field: self.field,
11666 })
11667 }
11668 }
11669 #[derive(Debug)]
11670 pub struct FacetDeserializer {
11671 content: Option<super::Facet>,
11672 state: Box<FacetDeserializerState>,
11673 }
11674 #[derive(Debug)]
11675 enum FacetDeserializerState {
11676 Next__,
11677 MinExclusive(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11678 MinInclusive(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11679 MaxExclusive(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11680 MaxInclusive(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11681 TotalDigits(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11682 FractionDigits(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11683 Length(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11684 MinLength(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11685 MaxLength(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11686 Enumeration(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11687 WhiteSpace(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11688 Pattern(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11689 Assertion(<AssertionType as crate::quick_xml::WithDeserializer>::Deserializer),
11690 ExplicitTimezone(<FacetType as crate::quick_xml::WithDeserializer>::Deserializer),
11691 }
11692 impl FacetDeserializer {}
11693 impl<'de> crate::quick_xml::Deserializer<'de, super::Facet> for FacetDeserializer {
11694 fn init<R>(
11695 reader: &R,
11696 event: crate::quick_xml::Event<'de>,
11697 ) -> crate::quick_xml::DeserializerResult<'de, super::Facet, Self>
11698 where
11699 R: crate::quick_xml::XmlReader,
11700 {
11701 use crate::quick_xml::{DeserializerOutput, Event};
11702 let deserializer = Self {
11703 content: None,
11704 state: Box::new(FacetDeserializerState::Next__),
11705 };
11706 let is_empty = matches!(event, Event::Empty(_));
11707 let mut out = deserializer.next(reader, event)?;
11708 if out.event.is_some() {
11709 out.deserializer = None;
11710 } else if is_empty && out.data.is_none() {
11711 if let Some(deserializer) = out.deserializer.take() {
11712 out.data = Some(deserializer.finish(reader)?);
11713 }
11714 }
11715 Ok(out)
11716 }
11717 fn next<R>(
11718 mut self,
11719 reader: &R,
11720 event: crate::quick_xml::Event<'de>,
11721 ) -> crate::quick_xml::DeserializerResult<'de, super::Facet, Self>
11722 where
11723 R: crate::quick_xml::XmlReader,
11724 {
11725 use crate::quick_xml::{
11726 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
11727 };
11728 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
11729 match (
11730 core::mem::replace(&mut *self.state, FacetDeserializerState::Next__),
11731 &event,
11732 ) {
11733 (FacetDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
11734 if matches!(
11735 reader.resolve_local_name(x.name(), NS_XS),
11736 Some(b"minExclusive")
11737 ) {
11738 let DeserializerOutput {
11739 data,
11740 deserializer,
11741 event,
11742 allow_any,
11743 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
11744 if let Some(data) = data {
11745 if self.content.is_some() {
11746 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11747 b"minExclusive",
11748 )))?;
11749 }
11750 self.content = Some(Facet::MinExclusive(data));
11751 }
11752 if let Some(deserializer) = deserializer {
11753 *self.state = FacetDeserializerState::MinExclusive(deserializer);
11754 }
11755 Ok(DeserializerOutput {
11756 data: None,
11757 deserializer: Some(self),
11758 event,
11759 allow_any,
11760 })
11761 } else if matches!(
11762 reader.resolve_local_name(x.name(), NS_XS),
11763 Some(b"minInclusive")
11764 ) {
11765 let DeserializerOutput {
11766 data,
11767 deserializer,
11768 event,
11769 allow_any,
11770 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
11771 if let Some(data) = data {
11772 if self.content.is_some() {
11773 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11774 b"minInclusive",
11775 )))?;
11776 }
11777 self.content = Some(Facet::MinInclusive(data));
11778 }
11779 if let Some(deserializer) = deserializer {
11780 *self.state = FacetDeserializerState::MinInclusive(deserializer);
11781 }
11782 Ok(DeserializerOutput {
11783 data: None,
11784 deserializer: Some(self),
11785 event,
11786 allow_any,
11787 })
11788 } else if matches!(
11789 reader.resolve_local_name(x.name(), NS_XS),
11790 Some(b"maxExclusive")
11791 ) {
11792 let DeserializerOutput {
11793 data,
11794 deserializer,
11795 event,
11796 allow_any,
11797 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
11798 if let Some(data) = data {
11799 if self.content.is_some() {
11800 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11801 b"maxExclusive",
11802 )))?;
11803 }
11804 self.content = Some(Facet::MaxExclusive(data));
11805 }
11806 if let Some(deserializer) = deserializer {
11807 *self.state = FacetDeserializerState::MaxExclusive(deserializer);
11808 }
11809 Ok(DeserializerOutput {
11810 data: None,
11811 deserializer: Some(self),
11812 event,
11813 allow_any,
11814 })
11815 } else if matches!(
11816 reader.resolve_local_name(x.name(), NS_XS),
11817 Some(b"maxInclusive")
11818 ) {
11819 let DeserializerOutput {
11820 data,
11821 deserializer,
11822 event,
11823 allow_any,
11824 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
11825 if let Some(data) = data {
11826 if self.content.is_some() {
11827 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11828 b"maxInclusive",
11829 )))?;
11830 }
11831 self.content = Some(Facet::MaxInclusive(data));
11832 }
11833 if let Some(deserializer) = deserializer {
11834 *self.state = FacetDeserializerState::MaxInclusive(deserializer);
11835 }
11836 Ok(DeserializerOutput {
11837 data: None,
11838 deserializer: Some(self),
11839 event,
11840 allow_any,
11841 })
11842 } else if matches!(
11843 reader.resolve_local_name(x.name(), NS_XS),
11844 Some(b"totalDigits")
11845 ) {
11846 let DeserializerOutput {
11847 data,
11848 deserializer,
11849 event,
11850 allow_any,
11851 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
11852 if let Some(data) = data {
11853 if self.content.is_some() {
11854 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11855 b"totalDigits",
11856 )))?;
11857 }
11858 self.content = Some(Facet::TotalDigits(data));
11859 }
11860 if let Some(deserializer) = deserializer {
11861 *self.state = FacetDeserializerState::TotalDigits(deserializer);
11862 }
11863 Ok(DeserializerOutput {
11864 data: None,
11865 deserializer: Some(self),
11866 event,
11867 allow_any,
11868 })
11869 } else if matches!(
11870 reader.resolve_local_name(x.name(), NS_XS),
11871 Some(b"fractionDigits")
11872 ) {
11873 let DeserializerOutput {
11874 data,
11875 deserializer,
11876 event,
11877 allow_any,
11878 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
11879 if let Some(data) = data {
11880 if self.content.is_some() {
11881 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11882 b"fractionDigits",
11883 )))?;
11884 }
11885 self.content = Some(Facet::FractionDigits(data));
11886 }
11887 if let Some(deserializer) = deserializer {
11888 *self.state = FacetDeserializerState::FractionDigits(deserializer);
11889 }
11890 Ok(DeserializerOutput {
11891 data: None,
11892 deserializer: Some(self),
11893 event,
11894 allow_any,
11895 })
11896 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"length"))
11897 {
11898 let DeserializerOutput {
11899 data,
11900 deserializer,
11901 event,
11902 allow_any,
11903 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
11904 if let Some(data) = data {
11905 if self.content.is_some() {
11906 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11907 b"length",
11908 )))?;
11909 }
11910 self.content = Some(Facet::Length(data));
11911 }
11912 if let Some(deserializer) = deserializer {
11913 *self.state = FacetDeserializerState::Length(deserializer);
11914 }
11915 Ok(DeserializerOutput {
11916 data: None,
11917 deserializer: Some(self),
11918 event,
11919 allow_any,
11920 })
11921 } else if matches!(
11922 reader.resolve_local_name(x.name(), NS_XS),
11923 Some(b"minLength")
11924 ) {
11925 let DeserializerOutput {
11926 data,
11927 deserializer,
11928 event,
11929 allow_any,
11930 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
11931 if let Some(data) = data {
11932 if self.content.is_some() {
11933 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11934 b"minLength",
11935 )))?;
11936 }
11937 self.content = Some(Facet::MinLength(data));
11938 }
11939 if let Some(deserializer) = deserializer {
11940 *self.state = FacetDeserializerState::MinLength(deserializer);
11941 }
11942 Ok(DeserializerOutput {
11943 data: None,
11944 deserializer: Some(self),
11945 event,
11946 allow_any,
11947 })
11948 } else if matches!(
11949 reader.resolve_local_name(x.name(), NS_XS),
11950 Some(b"maxLength")
11951 ) {
11952 let DeserializerOutput {
11953 data,
11954 deserializer,
11955 event,
11956 allow_any,
11957 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
11958 if let Some(data) = data {
11959 if self.content.is_some() {
11960 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11961 b"maxLength",
11962 )))?;
11963 }
11964 self.content = Some(Facet::MaxLength(data));
11965 }
11966 if let Some(deserializer) = deserializer {
11967 *self.state = FacetDeserializerState::MaxLength(deserializer);
11968 }
11969 Ok(DeserializerOutput {
11970 data: None,
11971 deserializer: Some(self),
11972 event,
11973 allow_any,
11974 })
11975 } else if matches!(
11976 reader.resolve_local_name(x.name(), NS_XS),
11977 Some(b"enumeration")
11978 ) {
11979 let DeserializerOutput {
11980 data,
11981 deserializer,
11982 event,
11983 allow_any,
11984 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
11985 if let Some(data) = data {
11986 if self.content.is_some() {
11987 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11988 b"enumeration",
11989 )))?;
11990 }
11991 self.content = Some(Facet::Enumeration(data));
11992 }
11993 if let Some(deserializer) = deserializer {
11994 *self.state = FacetDeserializerState::Enumeration(deserializer);
11995 }
11996 Ok(DeserializerOutput {
11997 data: None,
11998 deserializer: Some(self),
11999 event,
12000 allow_any,
12001 })
12002 } else if matches!(
12003 reader.resolve_local_name(x.name(), NS_XS),
12004 Some(b"whiteSpace")
12005 ) {
12006 let DeserializerOutput {
12007 data,
12008 deserializer,
12009 event,
12010 allow_any,
12011 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
12012 if let Some(data) = data {
12013 if self.content.is_some() {
12014 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12015 b"whiteSpace",
12016 )))?;
12017 }
12018 self.content = Some(Facet::WhiteSpace(data));
12019 }
12020 if let Some(deserializer) = deserializer {
12021 *self.state = FacetDeserializerState::WhiteSpace(deserializer);
12022 }
12023 Ok(DeserializerOutput {
12024 data: None,
12025 deserializer: Some(self),
12026 event,
12027 allow_any,
12028 })
12029 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"pattern"))
12030 {
12031 let DeserializerOutput {
12032 data,
12033 deserializer,
12034 event,
12035 allow_any,
12036 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
12037 if let Some(data) = data {
12038 if self.content.is_some() {
12039 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12040 b"pattern",
12041 )))?;
12042 }
12043 self.content = Some(Facet::Pattern(data));
12044 }
12045 if let Some(deserializer) = deserializer {
12046 *self.state = FacetDeserializerState::Pattern(deserializer);
12047 }
12048 Ok(DeserializerOutput {
12049 data: None,
12050 deserializer: Some(self),
12051 event,
12052 allow_any,
12053 })
12054 } else if matches!(
12055 reader.resolve_local_name(x.name(), NS_XS),
12056 Some(b"assertion")
12057 ) {
12058 let DeserializerOutput {
12059 data,
12060 deserializer,
12061 event,
12062 allow_any,
12063 } = <AssertionType as WithDeserializer>::Deserializer::init(reader, event)?;
12064 if let Some(data) = data {
12065 if self.content.is_some() {
12066 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12067 b"assertion",
12068 )))?;
12069 }
12070 self.content = Some(Facet::Assertion(data));
12071 }
12072 if let Some(deserializer) = deserializer {
12073 *self.state = FacetDeserializerState::Assertion(deserializer);
12074 }
12075 Ok(DeserializerOutput {
12076 data: None,
12077 deserializer: Some(self),
12078 event,
12079 allow_any,
12080 })
12081 } else if matches!(
12082 reader.resolve_local_name(x.name(), NS_XS),
12083 Some(b"explicitTimezone")
12084 ) {
12085 let DeserializerOutput {
12086 data,
12087 deserializer,
12088 event,
12089 allow_any,
12090 } = <FacetType as WithDeserializer>::Deserializer::init(reader, event)?;
12091 if let Some(data) = data {
12092 if self.content.is_some() {
12093 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12094 b"explicitTimezone",
12095 )))?;
12096 }
12097 self.content = Some(Facet::ExplicitTimezone(data));
12098 }
12099 if let Some(deserializer) = deserializer {
12100 *self.state = FacetDeserializerState::ExplicitTimezone(deserializer);
12101 }
12102 Ok(DeserializerOutput {
12103 data: None,
12104 deserializer: Some(self),
12105 event,
12106 allow_any,
12107 })
12108 } else {
12109 Ok(DeserializerOutput {
12110 data: None,
12111 deserializer: Some(self),
12112 event: Some(event),
12113 allow_any: false,
12114 })
12115 }
12116 }
12117 (FacetDeserializerState::Next__, Event::End(_)) => {
12118 let data = self.finish(reader)?;
12119 Ok(DeserializerOutput {
12120 data: Some(data),
12121 deserializer: None,
12122 event: Some(event),
12123 allow_any: false,
12124 })
12125 }
12126 (FacetDeserializerState::Next__, _) => Ok(DeserializerOutput {
12127 data: None,
12128 deserializer: Some(self),
12129 event: None,
12130 allow_any: false,
12131 }),
12132 (FacetDeserializerState::MinExclusive(deserializer), _) => {
12133 let DeserializerOutput {
12134 data,
12135 deserializer,
12136 event,
12137 allow_any,
12138 } = deserializer.next(reader, event)?;
12139 if let Some(data) = data {
12140 if self.content.is_some() {
12141 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12142 b"minExclusive",
12143 )))?;
12144 }
12145 self.content = Some(Facet::MinExclusive(data));
12146 }
12147 if let Some(deserializer) = deserializer {
12148 *self.state = FacetDeserializerState::MinExclusive(deserializer);
12149 }
12150 Ok(DeserializerOutput {
12151 data: None,
12152 deserializer: Some(self),
12153 event,
12154 allow_any,
12155 })
12156 }
12157 (FacetDeserializerState::MinInclusive(deserializer), _) => {
12158 let DeserializerOutput {
12159 data,
12160 deserializer,
12161 event,
12162 allow_any,
12163 } = deserializer.next(reader, event)?;
12164 if let Some(data) = data {
12165 if self.content.is_some() {
12166 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12167 b"minInclusive",
12168 )))?;
12169 }
12170 self.content = Some(Facet::MinInclusive(data));
12171 }
12172 if let Some(deserializer) = deserializer {
12173 *self.state = FacetDeserializerState::MinInclusive(deserializer);
12174 }
12175 Ok(DeserializerOutput {
12176 data: None,
12177 deserializer: Some(self),
12178 event,
12179 allow_any,
12180 })
12181 }
12182 (FacetDeserializerState::MaxExclusive(deserializer), _) => {
12183 let DeserializerOutput {
12184 data,
12185 deserializer,
12186 event,
12187 allow_any,
12188 } = deserializer.next(reader, event)?;
12189 if let Some(data) = data {
12190 if self.content.is_some() {
12191 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12192 b"maxExclusive",
12193 )))?;
12194 }
12195 self.content = Some(Facet::MaxExclusive(data));
12196 }
12197 if let Some(deserializer) = deserializer {
12198 *self.state = FacetDeserializerState::MaxExclusive(deserializer);
12199 }
12200 Ok(DeserializerOutput {
12201 data: None,
12202 deserializer: Some(self),
12203 event,
12204 allow_any,
12205 })
12206 }
12207 (FacetDeserializerState::MaxInclusive(deserializer), _) => {
12208 let DeserializerOutput {
12209 data,
12210 deserializer,
12211 event,
12212 allow_any,
12213 } = deserializer.next(reader, event)?;
12214 if let Some(data) = data {
12215 if self.content.is_some() {
12216 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12217 b"maxInclusive",
12218 )))?;
12219 }
12220 self.content = Some(Facet::MaxInclusive(data));
12221 }
12222 if let Some(deserializer) = deserializer {
12223 *self.state = FacetDeserializerState::MaxInclusive(deserializer);
12224 }
12225 Ok(DeserializerOutput {
12226 data: None,
12227 deserializer: Some(self),
12228 event,
12229 allow_any,
12230 })
12231 }
12232 (FacetDeserializerState::TotalDigits(deserializer), _) => {
12233 let DeserializerOutput {
12234 data,
12235 deserializer,
12236 event,
12237 allow_any,
12238 } = deserializer.next(reader, event)?;
12239 if let Some(data) = data {
12240 if self.content.is_some() {
12241 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12242 b"totalDigits",
12243 )))?;
12244 }
12245 self.content = Some(Facet::TotalDigits(data));
12246 }
12247 if let Some(deserializer) = deserializer {
12248 *self.state = FacetDeserializerState::TotalDigits(deserializer);
12249 }
12250 Ok(DeserializerOutput {
12251 data: None,
12252 deserializer: Some(self),
12253 event,
12254 allow_any,
12255 })
12256 }
12257 (FacetDeserializerState::FractionDigits(deserializer), _) => {
12258 let DeserializerOutput {
12259 data,
12260 deserializer,
12261 event,
12262 allow_any,
12263 } = deserializer.next(reader, event)?;
12264 if let Some(data) = data {
12265 if self.content.is_some() {
12266 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12267 b"fractionDigits",
12268 )))?;
12269 }
12270 self.content = Some(Facet::FractionDigits(data));
12271 }
12272 if let Some(deserializer) = deserializer {
12273 *self.state = FacetDeserializerState::FractionDigits(deserializer);
12274 }
12275 Ok(DeserializerOutput {
12276 data: None,
12277 deserializer: Some(self),
12278 event,
12279 allow_any,
12280 })
12281 }
12282 (FacetDeserializerState::Length(deserializer), _) => {
12283 let DeserializerOutput {
12284 data,
12285 deserializer,
12286 event,
12287 allow_any,
12288 } = deserializer.next(reader, event)?;
12289 if let Some(data) = data {
12290 if self.content.is_some() {
12291 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12292 b"length",
12293 )))?;
12294 }
12295 self.content = Some(Facet::Length(data));
12296 }
12297 if let Some(deserializer) = deserializer {
12298 *self.state = FacetDeserializerState::Length(deserializer);
12299 }
12300 Ok(DeserializerOutput {
12301 data: None,
12302 deserializer: Some(self),
12303 event,
12304 allow_any,
12305 })
12306 }
12307 (FacetDeserializerState::MinLength(deserializer), _) => {
12308 let DeserializerOutput {
12309 data,
12310 deserializer,
12311 event,
12312 allow_any,
12313 } = deserializer.next(reader, event)?;
12314 if let Some(data) = data {
12315 if self.content.is_some() {
12316 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12317 b"minLength",
12318 )))?;
12319 }
12320 self.content = Some(Facet::MinLength(data));
12321 }
12322 if let Some(deserializer) = deserializer {
12323 *self.state = FacetDeserializerState::MinLength(deserializer);
12324 }
12325 Ok(DeserializerOutput {
12326 data: None,
12327 deserializer: Some(self),
12328 event,
12329 allow_any,
12330 })
12331 }
12332 (FacetDeserializerState::MaxLength(deserializer), _) => {
12333 let DeserializerOutput {
12334 data,
12335 deserializer,
12336 event,
12337 allow_any,
12338 } = deserializer.next(reader, event)?;
12339 if let Some(data) = data {
12340 if self.content.is_some() {
12341 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12342 b"maxLength",
12343 )))?;
12344 }
12345 self.content = Some(Facet::MaxLength(data));
12346 }
12347 if let Some(deserializer) = deserializer {
12348 *self.state = FacetDeserializerState::MaxLength(deserializer);
12349 }
12350 Ok(DeserializerOutput {
12351 data: None,
12352 deserializer: Some(self),
12353 event,
12354 allow_any,
12355 })
12356 }
12357 (FacetDeserializerState::Enumeration(deserializer), _) => {
12358 let DeserializerOutput {
12359 data,
12360 deserializer,
12361 event,
12362 allow_any,
12363 } = deserializer.next(reader, event)?;
12364 if let Some(data) = data {
12365 if self.content.is_some() {
12366 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12367 b"enumeration",
12368 )))?;
12369 }
12370 self.content = Some(Facet::Enumeration(data));
12371 }
12372 if let Some(deserializer) = deserializer {
12373 *self.state = FacetDeserializerState::Enumeration(deserializer);
12374 }
12375 Ok(DeserializerOutput {
12376 data: None,
12377 deserializer: Some(self),
12378 event,
12379 allow_any,
12380 })
12381 }
12382 (FacetDeserializerState::WhiteSpace(deserializer), _) => {
12383 let DeserializerOutput {
12384 data,
12385 deserializer,
12386 event,
12387 allow_any,
12388 } = deserializer.next(reader, event)?;
12389 if let Some(data) = data {
12390 if self.content.is_some() {
12391 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12392 b"whiteSpace",
12393 )))?;
12394 }
12395 self.content = Some(Facet::WhiteSpace(data));
12396 }
12397 if let Some(deserializer) = deserializer {
12398 *self.state = FacetDeserializerState::WhiteSpace(deserializer);
12399 }
12400 Ok(DeserializerOutput {
12401 data: None,
12402 deserializer: Some(self),
12403 event,
12404 allow_any,
12405 })
12406 }
12407 (FacetDeserializerState::Pattern(deserializer), _) => {
12408 let DeserializerOutput {
12409 data,
12410 deserializer,
12411 event,
12412 allow_any,
12413 } = deserializer.next(reader, event)?;
12414 if let Some(data) = data {
12415 if self.content.is_some() {
12416 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12417 b"pattern",
12418 )))?;
12419 }
12420 self.content = Some(Facet::Pattern(data));
12421 }
12422 if let Some(deserializer) = deserializer {
12423 *self.state = FacetDeserializerState::Pattern(deserializer);
12424 }
12425 Ok(DeserializerOutput {
12426 data: None,
12427 deserializer: Some(self),
12428 event,
12429 allow_any,
12430 })
12431 }
12432 (FacetDeserializerState::Assertion(deserializer), _) => {
12433 let DeserializerOutput {
12434 data,
12435 deserializer,
12436 event,
12437 allow_any,
12438 } = deserializer.next(reader, event)?;
12439 if let Some(data) = data {
12440 if self.content.is_some() {
12441 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12442 b"assertion",
12443 )))?;
12444 }
12445 self.content = Some(Facet::Assertion(data));
12446 }
12447 if let Some(deserializer) = deserializer {
12448 *self.state = FacetDeserializerState::Assertion(deserializer);
12449 }
12450 Ok(DeserializerOutput {
12451 data: None,
12452 deserializer: Some(self),
12453 event,
12454 allow_any,
12455 })
12456 }
12457 (FacetDeserializerState::ExplicitTimezone(deserializer), _) => {
12458 let DeserializerOutput {
12459 data,
12460 deserializer,
12461 event,
12462 allow_any,
12463 } = deserializer.next(reader, event)?;
12464 if let Some(data) = data {
12465 if self.content.is_some() {
12466 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12467 b"explicitTimezone",
12468 )))?;
12469 }
12470 self.content = Some(Facet::ExplicitTimezone(data));
12471 }
12472 if let Some(deserializer) = deserializer {
12473 *self.state = FacetDeserializerState::ExplicitTimezone(deserializer);
12474 }
12475 Ok(DeserializerOutput {
12476 data: None,
12477 deserializer: Some(self),
12478 event,
12479 allow_any,
12480 })
12481 }
12482 }
12483 }
12484 fn finish<R>(self, _reader: &R) -> Result<super::Facet, crate::quick_xml::Error>
12485 where
12486 R: crate::quick_xml::XmlReader,
12487 {
12488 use crate::quick_xml::ErrorKind;
12489 Ok(self
12490 .content
12491 .ok_or(crate::quick_xml::ErrorKind::MissingContent)?)
12492 }
12493 }
12494 #[derive(Debug)]
12495 pub struct RestrictionTypeDeserializer {
12496 id: Option<String>,
12497 base: super::QName,
12498 content: Vec<super::RestrictionTypeContent>,
12499 state: Box<RestrictionTypeDeserializerState>,
12500 }
12501 #[derive(Debug)]
12502 enum RestrictionTypeDeserializerState {
12503 Next__,
12504 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
12505 OpenContent(<OpenContent as crate::quick_xml::WithDeserializer>::Deserializer),
12506 Group(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
12507 All(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
12508 Choice(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
12509 Sequence(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
12510 SimpleType(<SimpleBaseType as crate::quick_xml::WithDeserializer>::Deserializer),
12511 Facet(<Facet as crate::quick_xml::WithDeserializer>::Deserializer),
12512 Attribute(<AttributeType as crate::quick_xml::WithDeserializer>::Deserializer),
12513 AttributeGroup(<AttributeGroupType as crate::quick_xml::WithDeserializer>::Deserializer),
12514 AnyAttribute(<AnyAttribute as crate::quick_xml::WithDeserializer>::Deserializer),
12515 Assert(<AssertionType as crate::quick_xml::WithDeserializer>::Deserializer),
12516 }
12517 impl RestrictionTypeDeserializer {
12518 fn from_bytes_start<R>(
12519 reader: &R,
12520 bytes_start: &crate::quick_xml::BytesStart<'_>,
12521 ) -> Result<Self, crate::quick_xml::Error>
12522 where
12523 R: crate::quick_xml::XmlReader,
12524 {
12525 use crate::quick_xml::ErrorKind;
12526 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
12527 let mut id: Option<String> = None;
12528 let mut base: Option<QName> = None;
12529 for attrib in bytes_start.attributes() {
12530 let attrib = attrib?;
12531 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
12532 continue;
12533 }
12534 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
12535 reader.read_attrib(&mut id, b"id", &attrib.value)?;
12536 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"base")) {
12537 reader.read_attrib(&mut base, b"base", &attrib.value)?;
12538 }
12539 }
12540 Ok(Self {
12541 id: id,
12542 base: base.ok_or(ErrorKind::MissingAttribute("base".into()))?,
12543 content: Vec::new(),
12544 state: Box::new(RestrictionTypeDeserializerState::Next__),
12545 })
12546 }
12547 }
12548 impl<'de> crate::quick_xml::Deserializer<'de, super::RestrictionType>
12549 for RestrictionTypeDeserializer
12550 {
12551 fn init<R>(
12552 reader: &R,
12553 event: crate::quick_xml::Event<'de>,
12554 ) -> crate::quick_xml::DeserializerResult<'de, super::RestrictionType, Self>
12555 where
12556 R: crate::quick_xml::XmlReader,
12557 {
12558 use crate::quick_xml::{DeserializerOutput, Event};
12559 match event {
12560 Event::Start(start) => {
12561 let deserializer = Self::from_bytes_start(reader, &start)?;
12562 Ok(DeserializerOutput {
12563 data: None,
12564 deserializer: Some(deserializer),
12565 event: None,
12566 allow_any: false,
12567 })
12568 }
12569 Event::Empty(start) => {
12570 let deserializer = Self::from_bytes_start(reader, &start)?;
12571 let data = deserializer.finish(reader)?;
12572 Ok(DeserializerOutput {
12573 data: Some(data),
12574 deserializer: None,
12575 event: None,
12576 allow_any: false,
12577 })
12578 }
12579 event => Ok(DeserializerOutput {
12580 data: None,
12581 deserializer: None,
12582 event: Some(event),
12583 allow_any: false,
12584 }),
12585 }
12586 }
12587 fn next<R>(
12588 mut self,
12589 reader: &R,
12590 event: crate::quick_xml::Event<'de>,
12591 ) -> crate::quick_xml::DeserializerResult<'de, super::RestrictionType, Self>
12592 where
12593 R: crate::quick_xml::XmlReader,
12594 {
12595 use crate::quick_xml::{
12596 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
12597 };
12598 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
12599 match (
12600 core::mem::replace(&mut *self.state, RestrictionTypeDeserializerState::Next__),
12601 &event,
12602 ) {
12603 (RestrictionTypeDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
12604 if matches!(
12605 reader.resolve_local_name(x.name(), NS_XS),
12606 Some(b"annotation")
12607 ) {
12608 let DeserializerOutput {
12609 data,
12610 deserializer,
12611 event,
12612 allow_any,
12613 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
12614 if let Some(data) = data {
12615 self.content.push(RestrictionTypeContent::Annotation(data));
12616 }
12617 if let Some(deserializer) = deserializer {
12618 *self.state =
12619 RestrictionTypeDeserializerState::Annotation(deserializer);
12620 }
12621 Ok(DeserializerOutput {
12622 data: None,
12623 deserializer: Some(self),
12624 event,
12625 allow_any,
12626 })
12627 } else if matches!(
12628 reader.resolve_local_name(x.name(), NS_XS),
12629 Some(b"openContent")
12630 ) {
12631 let DeserializerOutput {
12632 data,
12633 deserializer,
12634 event,
12635 allow_any,
12636 } = <OpenContent as WithDeserializer>::Deserializer::init(reader, event)?;
12637 if let Some(data) = data {
12638 self.content.push(RestrictionTypeContent::OpenContent(data));
12639 }
12640 if let Some(deserializer) = deserializer {
12641 *self.state =
12642 RestrictionTypeDeserializerState::OpenContent(deserializer);
12643 }
12644 Ok(DeserializerOutput {
12645 data: None,
12646 deserializer: Some(self),
12647 event,
12648 allow_any,
12649 })
12650 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"group")) {
12651 let DeserializerOutput {
12652 data,
12653 deserializer,
12654 event,
12655 allow_any,
12656 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
12657 if let Some(data) = data {
12658 self.content.push(RestrictionTypeContent::Group(data));
12659 }
12660 if let Some(deserializer) = deserializer {
12661 *self.state = RestrictionTypeDeserializerState::Group(deserializer);
12662 }
12663 Ok(DeserializerOutput {
12664 data: None,
12665 deserializer: Some(self),
12666 event,
12667 allow_any,
12668 })
12669 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"all")) {
12670 let DeserializerOutput {
12671 data,
12672 deserializer,
12673 event,
12674 allow_any,
12675 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
12676 if let Some(data) = data {
12677 self.content.push(RestrictionTypeContent::All(data));
12678 }
12679 if let Some(deserializer) = deserializer {
12680 *self.state = RestrictionTypeDeserializerState::All(deserializer);
12681 }
12682 Ok(DeserializerOutput {
12683 data: None,
12684 deserializer: Some(self),
12685 event,
12686 allow_any,
12687 })
12688 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"choice"))
12689 {
12690 let DeserializerOutput {
12691 data,
12692 deserializer,
12693 event,
12694 allow_any,
12695 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
12696 if let Some(data) = data {
12697 self.content.push(RestrictionTypeContent::Choice(data));
12698 }
12699 if let Some(deserializer) = deserializer {
12700 *self.state = RestrictionTypeDeserializerState::Choice(deserializer);
12701 }
12702 Ok(DeserializerOutput {
12703 data: None,
12704 deserializer: Some(self),
12705 event,
12706 allow_any,
12707 })
12708 } else if matches!(
12709 reader.resolve_local_name(x.name(), NS_XS),
12710 Some(b"sequence")
12711 ) {
12712 let DeserializerOutput {
12713 data,
12714 deserializer,
12715 event,
12716 allow_any,
12717 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
12718 if let Some(data) = data {
12719 self.content.push(RestrictionTypeContent::Sequence(data));
12720 }
12721 if let Some(deserializer) = deserializer {
12722 *self.state = RestrictionTypeDeserializerState::Sequence(deserializer);
12723 }
12724 Ok(DeserializerOutput {
12725 data: None,
12726 deserializer: Some(self),
12727 event,
12728 allow_any,
12729 })
12730 } else if matches!(
12731 reader.resolve_local_name(x.name(), NS_XS),
12732 Some(b"simpleType")
12733 ) {
12734 let DeserializerOutput {
12735 data,
12736 deserializer,
12737 event,
12738 allow_any,
12739 } = <SimpleBaseType as WithDeserializer>::Deserializer::init(
12740 reader, event,
12741 )?;
12742 if let Some(data) = data {
12743 self.content.push(RestrictionTypeContent::SimpleType(data));
12744 }
12745 if let Some(deserializer) = deserializer {
12746 *self.state =
12747 RestrictionTypeDeserializerState::SimpleType(deserializer);
12748 }
12749 Ok(DeserializerOutput {
12750 data: None,
12751 deserializer: Some(self),
12752 event,
12753 allow_any,
12754 })
12755 } else if matches!(
12756 reader.resolve_local_name(x.name(), NS_XS),
12757 Some(b"attribute")
12758 ) {
12759 let DeserializerOutput {
12760 data,
12761 deserializer,
12762 event,
12763 allow_any,
12764 } = <AttributeType as WithDeserializer>::Deserializer::init(reader, event)?;
12765 if let Some(data) = data {
12766 self.content.push(RestrictionTypeContent::Attribute(data));
12767 }
12768 if let Some(deserializer) = deserializer {
12769 *self.state = RestrictionTypeDeserializerState::Attribute(deserializer);
12770 }
12771 Ok(DeserializerOutput {
12772 data: None,
12773 deserializer: Some(self),
12774 event,
12775 allow_any,
12776 })
12777 } else if matches!(
12778 reader.resolve_local_name(x.name(), NS_XS),
12779 Some(b"attributeGroup")
12780 ) {
12781 let DeserializerOutput {
12782 data,
12783 deserializer,
12784 event,
12785 allow_any,
12786 } = <AttributeGroupType as WithDeserializer>::Deserializer::init(
12787 reader, event,
12788 )?;
12789 if let Some(data) = data {
12790 self.content
12791 .push(RestrictionTypeContent::AttributeGroup(data));
12792 }
12793 if let Some(deserializer) = deserializer {
12794 *self.state =
12795 RestrictionTypeDeserializerState::AttributeGroup(deserializer);
12796 }
12797 Ok(DeserializerOutput {
12798 data: None,
12799 deserializer: Some(self),
12800 event,
12801 allow_any,
12802 })
12803 } else if matches!(
12804 reader.resolve_local_name(x.name(), NS_XS),
12805 Some(b"anyAttribute")
12806 ) {
12807 let DeserializerOutput {
12808 data,
12809 deserializer,
12810 event,
12811 allow_any,
12812 } = <AnyAttribute as WithDeserializer>::Deserializer::init(reader, event)?;
12813 if let Some(data) = data {
12814 self.content
12815 .push(RestrictionTypeContent::AnyAttribute(data));
12816 }
12817 if let Some(deserializer) = deserializer {
12818 *self.state =
12819 RestrictionTypeDeserializerState::AnyAttribute(deserializer);
12820 }
12821 Ok(DeserializerOutput {
12822 data: None,
12823 deserializer: Some(self),
12824 event,
12825 allow_any,
12826 })
12827 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"assert"))
12828 {
12829 let DeserializerOutput {
12830 data,
12831 deserializer,
12832 event,
12833 allow_any,
12834 } = <AssertionType as WithDeserializer>::Deserializer::init(reader, event)?;
12835 if let Some(data) = data {
12836 self.content.push(RestrictionTypeContent::Assert(data));
12837 }
12838 if let Some(deserializer) = deserializer {
12839 *self.state = RestrictionTypeDeserializerState::Assert(deserializer);
12840 }
12841 Ok(DeserializerOutput {
12842 data: None,
12843 deserializer: Some(self),
12844 event,
12845 allow_any,
12846 })
12847 } else {
12848 {
12849 let mut allow_any_element = false;
12850 let event = {
12851 let DeserializerOutput {
12852 data,
12853 deserializer,
12854 event,
12855 allow_any,
12856 } = <Facet as WithDeserializer>::Deserializer::init(reader, event)?;
12857 if let Some(data) = data {
12858 self.content.push(RestrictionTypeContent::Facet(data));
12859 }
12860 if let Some(deserializer) = deserializer {
12861 *self.state =
12862 RestrictionTypeDeserializerState::Facet(deserializer);
12863 }
12864 let Some(event) = event else {
12865 return Ok(DeserializerOutput {
12866 data: None,
12867 deserializer: Some(self),
12868 event: None,
12869 allow_any,
12870 });
12871 };
12872 if allow_any {
12873 allow_any_element = true;
12874 }
12875 event
12876 };
12877 Ok(DeserializerOutput {
12878 data: None,
12879 deserializer: Some(self),
12880 event: Some(event),
12881 allow_any: allow_any_element,
12882 })
12883 }
12884 }
12885 }
12886 (RestrictionTypeDeserializerState::Next__, Event::End(_)) => {
12887 let data = self.finish(reader)?;
12888 Ok(DeserializerOutput {
12889 data: Some(data),
12890 deserializer: None,
12891 event: None,
12892 allow_any: false,
12893 })
12894 }
12895 (RestrictionTypeDeserializerState::Next__, _) => Ok(DeserializerOutput {
12896 data: None,
12897 deserializer: Some(self),
12898 event: None,
12899 allow_any: false,
12900 }),
12901 (RestrictionTypeDeserializerState::Annotation(deserializer), _) => {
12902 let DeserializerOutput {
12903 data,
12904 deserializer,
12905 event,
12906 allow_any,
12907 } = deserializer.next(reader, event)?;
12908 if let Some(data) = data {
12909 self.content.push(RestrictionTypeContent::Annotation(data));
12910 }
12911 if let Some(deserializer) = deserializer {
12912 *self.state = RestrictionTypeDeserializerState::Annotation(deserializer);
12913 }
12914 Ok(DeserializerOutput {
12915 data: None,
12916 deserializer: Some(self),
12917 event,
12918 allow_any,
12919 })
12920 }
12921 (RestrictionTypeDeserializerState::OpenContent(deserializer), _) => {
12922 let DeserializerOutput {
12923 data,
12924 deserializer,
12925 event,
12926 allow_any,
12927 } = deserializer.next(reader, event)?;
12928 if let Some(data) = data {
12929 self.content.push(RestrictionTypeContent::OpenContent(data));
12930 }
12931 if let Some(deserializer) = deserializer {
12932 *self.state = RestrictionTypeDeserializerState::OpenContent(deserializer);
12933 }
12934 Ok(DeserializerOutput {
12935 data: None,
12936 deserializer: Some(self),
12937 event,
12938 allow_any,
12939 })
12940 }
12941 (RestrictionTypeDeserializerState::Group(deserializer), _) => {
12942 let DeserializerOutput {
12943 data,
12944 deserializer,
12945 event,
12946 allow_any,
12947 } = deserializer.next(reader, event)?;
12948 if let Some(data) = data {
12949 self.content.push(RestrictionTypeContent::Group(data));
12950 }
12951 if let Some(deserializer) = deserializer {
12952 *self.state = RestrictionTypeDeserializerState::Group(deserializer);
12953 }
12954 Ok(DeserializerOutput {
12955 data: None,
12956 deserializer: Some(self),
12957 event,
12958 allow_any,
12959 })
12960 }
12961 (RestrictionTypeDeserializerState::All(deserializer), _) => {
12962 let DeserializerOutput {
12963 data,
12964 deserializer,
12965 event,
12966 allow_any,
12967 } = deserializer.next(reader, event)?;
12968 if let Some(data) = data {
12969 self.content.push(RestrictionTypeContent::All(data));
12970 }
12971 if let Some(deserializer) = deserializer {
12972 *self.state = RestrictionTypeDeserializerState::All(deserializer);
12973 }
12974 Ok(DeserializerOutput {
12975 data: None,
12976 deserializer: Some(self),
12977 event,
12978 allow_any,
12979 })
12980 }
12981 (RestrictionTypeDeserializerState::Choice(deserializer), _) => {
12982 let DeserializerOutput {
12983 data,
12984 deserializer,
12985 event,
12986 allow_any,
12987 } = deserializer.next(reader, event)?;
12988 if let Some(data) = data {
12989 self.content.push(RestrictionTypeContent::Choice(data));
12990 }
12991 if let Some(deserializer) = deserializer {
12992 *self.state = RestrictionTypeDeserializerState::Choice(deserializer);
12993 }
12994 Ok(DeserializerOutput {
12995 data: None,
12996 deserializer: Some(self),
12997 event,
12998 allow_any,
12999 })
13000 }
13001 (RestrictionTypeDeserializerState::Sequence(deserializer), _) => {
13002 let DeserializerOutput {
13003 data,
13004 deserializer,
13005 event,
13006 allow_any,
13007 } = deserializer.next(reader, event)?;
13008 if let Some(data) = data {
13009 self.content.push(RestrictionTypeContent::Sequence(data));
13010 }
13011 if let Some(deserializer) = deserializer {
13012 *self.state = RestrictionTypeDeserializerState::Sequence(deserializer);
13013 }
13014 Ok(DeserializerOutput {
13015 data: None,
13016 deserializer: Some(self),
13017 event,
13018 allow_any,
13019 })
13020 }
13021 (RestrictionTypeDeserializerState::SimpleType(deserializer), _) => {
13022 let DeserializerOutput {
13023 data,
13024 deserializer,
13025 event,
13026 allow_any,
13027 } = deserializer.next(reader, event)?;
13028 if let Some(data) = data {
13029 self.content.push(RestrictionTypeContent::SimpleType(data));
13030 }
13031 if let Some(deserializer) = deserializer {
13032 *self.state = RestrictionTypeDeserializerState::SimpleType(deserializer);
13033 }
13034 Ok(DeserializerOutput {
13035 data: None,
13036 deserializer: Some(self),
13037 event,
13038 allow_any,
13039 })
13040 }
13041 (RestrictionTypeDeserializerState::Facet(deserializer), _) => {
13042 let DeserializerOutput {
13043 data,
13044 deserializer,
13045 event,
13046 allow_any,
13047 } = deserializer.next(reader, event)?;
13048 if let Some(data) = data {
13049 self.content.push(RestrictionTypeContent::Facet(data));
13050 }
13051 if let Some(deserializer) = deserializer {
13052 *self.state = RestrictionTypeDeserializerState::Facet(deserializer);
13053 }
13054 Ok(DeserializerOutput {
13055 data: None,
13056 deserializer: Some(self),
13057 event,
13058 allow_any,
13059 })
13060 }
13061 (RestrictionTypeDeserializerState::Attribute(deserializer), _) => {
13062 let DeserializerOutput {
13063 data,
13064 deserializer,
13065 event,
13066 allow_any,
13067 } = deserializer.next(reader, event)?;
13068 if let Some(data) = data {
13069 self.content.push(RestrictionTypeContent::Attribute(data));
13070 }
13071 if let Some(deserializer) = deserializer {
13072 *self.state = RestrictionTypeDeserializerState::Attribute(deserializer);
13073 }
13074 Ok(DeserializerOutput {
13075 data: None,
13076 deserializer: Some(self),
13077 event,
13078 allow_any,
13079 })
13080 }
13081 (RestrictionTypeDeserializerState::AttributeGroup(deserializer), _) => {
13082 let DeserializerOutput {
13083 data,
13084 deserializer,
13085 event,
13086 allow_any,
13087 } = deserializer.next(reader, event)?;
13088 if let Some(data) = data {
13089 self.content
13090 .push(RestrictionTypeContent::AttributeGroup(data));
13091 }
13092 if let Some(deserializer) = deserializer {
13093 *self.state =
13094 RestrictionTypeDeserializerState::AttributeGroup(deserializer);
13095 }
13096 Ok(DeserializerOutput {
13097 data: None,
13098 deserializer: Some(self),
13099 event,
13100 allow_any,
13101 })
13102 }
13103 (RestrictionTypeDeserializerState::AnyAttribute(deserializer), _) => {
13104 let DeserializerOutput {
13105 data,
13106 deserializer,
13107 event,
13108 allow_any,
13109 } = deserializer.next(reader, event)?;
13110 if let Some(data) = data {
13111 self.content
13112 .push(RestrictionTypeContent::AnyAttribute(data));
13113 }
13114 if let Some(deserializer) = deserializer {
13115 *self.state = RestrictionTypeDeserializerState::AnyAttribute(deserializer);
13116 }
13117 Ok(DeserializerOutput {
13118 data: None,
13119 deserializer: Some(self),
13120 event,
13121 allow_any,
13122 })
13123 }
13124 (RestrictionTypeDeserializerState::Assert(deserializer), _) => {
13125 let DeserializerOutput {
13126 data,
13127 deserializer,
13128 event,
13129 allow_any,
13130 } = deserializer.next(reader, event)?;
13131 if let Some(data) = data {
13132 self.content.push(RestrictionTypeContent::Assert(data));
13133 }
13134 if let Some(deserializer) = deserializer {
13135 *self.state = RestrictionTypeDeserializerState::Assert(deserializer);
13136 }
13137 Ok(DeserializerOutput {
13138 data: None,
13139 deserializer: Some(self),
13140 event,
13141 allow_any,
13142 })
13143 }
13144 }
13145 }
13146 fn finish<R>(self, _reader: &R) -> Result<super::RestrictionType, crate::quick_xml::Error>
13147 where
13148 R: crate::quick_xml::XmlReader,
13149 {
13150 use crate::quick_xml::ErrorKind;
13151 Ok(super::RestrictionType {
13152 id: self.id,
13153 base: self.base,
13154 content: self.content,
13155 })
13156 }
13157 }
13158 #[derive(Debug)]
13159 pub struct ExtensionTypeDeserializer {
13160 id: Option<String>,
13161 base: super::QName,
13162 content: Vec<super::ExtensionTypeContent>,
13163 state: Box<ExtensionTypeDeserializerState>,
13164 }
13165 #[derive(Debug)]
13166 enum ExtensionTypeDeserializerState {
13167 Next__,
13168 Annotation(<Annotation as crate::quick_xml::WithDeserializer>::Deserializer),
13169 OpenContent(<OpenContent as crate::quick_xml::WithDeserializer>::Deserializer),
13170 Group(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
13171 All(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
13172 Choice(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
13173 Sequence(<GroupType as crate::quick_xml::WithDeserializer>::Deserializer),
13174 Attribute(<AttributeType as crate::quick_xml::WithDeserializer>::Deserializer),
13175 AttributeGroup(<AttributeGroupType as crate::quick_xml::WithDeserializer>::Deserializer),
13176 AnyAttribute(<AnyAttribute as crate::quick_xml::WithDeserializer>::Deserializer),
13177 Assert(<AssertionType as crate::quick_xml::WithDeserializer>::Deserializer),
13178 }
13179 impl ExtensionTypeDeserializer {
13180 fn from_bytes_start<R>(
13181 reader: &R,
13182 bytes_start: &crate::quick_xml::BytesStart<'_>,
13183 ) -> Result<Self, crate::quick_xml::Error>
13184 where
13185 R: crate::quick_xml::XmlReader,
13186 {
13187 use crate::quick_xml::ErrorKind;
13188 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
13189 let mut id: Option<String> = None;
13190 let mut base: Option<QName> = None;
13191 for attrib in bytes_start.attributes() {
13192 let attrib = attrib?;
13193 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
13194 continue;
13195 }
13196 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
13197 reader.read_attrib(&mut id, b"id", &attrib.value)?;
13198 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"base")) {
13199 reader.read_attrib(&mut base, b"base", &attrib.value)?;
13200 }
13201 }
13202 Ok(Self {
13203 id: id,
13204 base: base.ok_or(ErrorKind::MissingAttribute("base".into()))?,
13205 content: Vec::new(),
13206 state: Box::new(ExtensionTypeDeserializerState::Next__),
13207 })
13208 }
13209 }
13210 impl<'de> crate::quick_xml::Deserializer<'de, super::ExtensionType> for ExtensionTypeDeserializer {
13211 fn init<R>(
13212 reader: &R,
13213 event: crate::quick_xml::Event<'de>,
13214 ) -> crate::quick_xml::DeserializerResult<'de, super::ExtensionType, Self>
13215 where
13216 R: crate::quick_xml::XmlReader,
13217 {
13218 use crate::quick_xml::{DeserializerOutput, Event};
13219 match event {
13220 Event::Start(start) => {
13221 let deserializer = Self::from_bytes_start(reader, &start)?;
13222 Ok(DeserializerOutput {
13223 data: None,
13224 deserializer: Some(deserializer),
13225 event: None,
13226 allow_any: false,
13227 })
13228 }
13229 Event::Empty(start) => {
13230 let deserializer = Self::from_bytes_start(reader, &start)?;
13231 let data = deserializer.finish(reader)?;
13232 Ok(DeserializerOutput {
13233 data: Some(data),
13234 deserializer: None,
13235 event: None,
13236 allow_any: false,
13237 })
13238 }
13239 event => Ok(DeserializerOutput {
13240 data: None,
13241 deserializer: None,
13242 event: Some(event),
13243 allow_any: false,
13244 }),
13245 }
13246 }
13247 fn next<R>(
13248 mut self,
13249 reader: &R,
13250 event: crate::quick_xml::Event<'de>,
13251 ) -> crate::quick_xml::DeserializerResult<'de, super::ExtensionType, Self>
13252 where
13253 R: crate::quick_xml::XmlReader,
13254 {
13255 use crate::quick_xml::{
13256 DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
13257 };
13258 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
13259 match (
13260 core::mem::replace(&mut *self.state, ExtensionTypeDeserializerState::Next__),
13261 &event,
13262 ) {
13263 (ExtensionTypeDeserializerState::Next__, Event::Start(x) | Event::Empty(x)) => {
13264 if matches!(
13265 reader.resolve_local_name(x.name(), NS_XS),
13266 Some(b"annotation")
13267 ) {
13268 let DeserializerOutput {
13269 data,
13270 deserializer,
13271 event,
13272 allow_any,
13273 } = <Annotation as WithDeserializer>::Deserializer::init(reader, event)?;
13274 if let Some(data) = data {
13275 self.content.push(ExtensionTypeContent::Annotation(data));
13276 }
13277 if let Some(deserializer) = deserializer {
13278 *self.state = ExtensionTypeDeserializerState::Annotation(deserializer);
13279 }
13280 Ok(DeserializerOutput {
13281 data: None,
13282 deserializer: Some(self),
13283 event,
13284 allow_any,
13285 })
13286 } else if matches!(
13287 reader.resolve_local_name(x.name(), NS_XS),
13288 Some(b"openContent")
13289 ) {
13290 let DeserializerOutput {
13291 data,
13292 deserializer,
13293 event,
13294 allow_any,
13295 } = <OpenContent as WithDeserializer>::Deserializer::init(reader, event)?;
13296 if let Some(data) = data {
13297 self.content.push(ExtensionTypeContent::OpenContent(data));
13298 }
13299 if let Some(deserializer) = deserializer {
13300 *self.state = ExtensionTypeDeserializerState::OpenContent(deserializer);
13301 }
13302 Ok(DeserializerOutput {
13303 data: None,
13304 deserializer: Some(self),
13305 event,
13306 allow_any,
13307 })
13308 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"group")) {
13309 let DeserializerOutput {
13310 data,
13311 deserializer,
13312 event,
13313 allow_any,
13314 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
13315 if let Some(data) = data {
13316 self.content.push(ExtensionTypeContent::Group(data));
13317 }
13318 if let Some(deserializer) = deserializer {
13319 *self.state = ExtensionTypeDeserializerState::Group(deserializer);
13320 }
13321 Ok(DeserializerOutput {
13322 data: None,
13323 deserializer: Some(self),
13324 event,
13325 allow_any,
13326 })
13327 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"all")) {
13328 let DeserializerOutput {
13329 data,
13330 deserializer,
13331 event,
13332 allow_any,
13333 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
13334 if let Some(data) = data {
13335 self.content.push(ExtensionTypeContent::All(data));
13336 }
13337 if let Some(deserializer) = deserializer {
13338 *self.state = ExtensionTypeDeserializerState::All(deserializer);
13339 }
13340 Ok(DeserializerOutput {
13341 data: None,
13342 deserializer: Some(self),
13343 event,
13344 allow_any,
13345 })
13346 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"choice"))
13347 {
13348 let DeserializerOutput {
13349 data,
13350 deserializer,
13351 event,
13352 allow_any,
13353 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
13354 if let Some(data) = data {
13355 self.content.push(ExtensionTypeContent::Choice(data));
13356 }
13357 if let Some(deserializer) = deserializer {
13358 *self.state = ExtensionTypeDeserializerState::Choice(deserializer);
13359 }
13360 Ok(DeserializerOutput {
13361 data: None,
13362 deserializer: Some(self),
13363 event,
13364 allow_any,
13365 })
13366 } else if matches!(
13367 reader.resolve_local_name(x.name(), NS_XS),
13368 Some(b"sequence")
13369 ) {
13370 let DeserializerOutput {
13371 data,
13372 deserializer,
13373 event,
13374 allow_any,
13375 } = <GroupType as WithDeserializer>::Deserializer::init(reader, event)?;
13376 if let Some(data) = data {
13377 self.content.push(ExtensionTypeContent::Sequence(data));
13378 }
13379 if let Some(deserializer) = deserializer {
13380 *self.state = ExtensionTypeDeserializerState::Sequence(deserializer);
13381 }
13382 Ok(DeserializerOutput {
13383 data: None,
13384 deserializer: Some(self),
13385 event,
13386 allow_any,
13387 })
13388 } else if matches!(
13389 reader.resolve_local_name(x.name(), NS_XS),
13390 Some(b"attribute")
13391 ) {
13392 let DeserializerOutput {
13393 data,
13394 deserializer,
13395 event,
13396 allow_any,
13397 } = <AttributeType as WithDeserializer>::Deserializer::init(reader, event)?;
13398 if let Some(data) = data {
13399 self.content.push(ExtensionTypeContent::Attribute(data));
13400 }
13401 if let Some(deserializer) = deserializer {
13402 *self.state = ExtensionTypeDeserializerState::Attribute(deserializer);
13403 }
13404 Ok(DeserializerOutput {
13405 data: None,
13406 deserializer: Some(self),
13407 event,
13408 allow_any,
13409 })
13410 } else if matches!(
13411 reader.resolve_local_name(x.name(), NS_XS),
13412 Some(b"attributeGroup")
13413 ) {
13414 let DeserializerOutput {
13415 data,
13416 deserializer,
13417 event,
13418 allow_any,
13419 } = <AttributeGroupType as WithDeserializer>::Deserializer::init(
13420 reader, event,
13421 )?;
13422 if let Some(data) = data {
13423 self.content
13424 .push(ExtensionTypeContent::AttributeGroup(data));
13425 }
13426 if let Some(deserializer) = deserializer {
13427 *self.state =
13428 ExtensionTypeDeserializerState::AttributeGroup(deserializer);
13429 }
13430 Ok(DeserializerOutput {
13431 data: None,
13432 deserializer: Some(self),
13433 event,
13434 allow_any,
13435 })
13436 } else if matches!(
13437 reader.resolve_local_name(x.name(), NS_XS),
13438 Some(b"anyAttribute")
13439 ) {
13440 let DeserializerOutput {
13441 data,
13442 deserializer,
13443 event,
13444 allow_any,
13445 } = <AnyAttribute as WithDeserializer>::Deserializer::init(reader, event)?;
13446 if let Some(data) = data {
13447 self.content.push(ExtensionTypeContent::AnyAttribute(data));
13448 }
13449 if let Some(deserializer) = deserializer {
13450 *self.state =
13451 ExtensionTypeDeserializerState::AnyAttribute(deserializer);
13452 }
13453 Ok(DeserializerOutput {
13454 data: None,
13455 deserializer: Some(self),
13456 event,
13457 allow_any,
13458 })
13459 } else if matches!(reader.resolve_local_name(x.name(), NS_XS), Some(b"assert"))
13460 {
13461 let DeserializerOutput {
13462 data,
13463 deserializer,
13464 event,
13465 allow_any,
13466 } = <AssertionType as WithDeserializer>::Deserializer::init(reader, event)?;
13467 if let Some(data) = data {
13468 self.content.push(ExtensionTypeContent::Assert(data));
13469 }
13470 if let Some(deserializer) = deserializer {
13471 *self.state = ExtensionTypeDeserializerState::Assert(deserializer);
13472 }
13473 Ok(DeserializerOutput {
13474 data: None,
13475 deserializer: Some(self),
13476 event,
13477 allow_any,
13478 })
13479 } else {
13480 Ok(DeserializerOutput {
13481 data: None,
13482 deserializer: Some(self),
13483 event: Some(event),
13484 allow_any: false,
13485 })
13486 }
13487 }
13488 (ExtensionTypeDeserializerState::Next__, Event::End(_)) => {
13489 let data = self.finish(reader)?;
13490 Ok(DeserializerOutput {
13491 data: Some(data),
13492 deserializer: None,
13493 event: None,
13494 allow_any: false,
13495 })
13496 }
13497 (ExtensionTypeDeserializerState::Next__, _) => Ok(DeserializerOutput {
13498 data: None,
13499 deserializer: Some(self),
13500 event: None,
13501 allow_any: false,
13502 }),
13503 (ExtensionTypeDeserializerState::Annotation(deserializer), _) => {
13504 let DeserializerOutput {
13505 data,
13506 deserializer,
13507 event,
13508 allow_any,
13509 } = deserializer.next(reader, event)?;
13510 if let Some(data) = data {
13511 self.content.push(ExtensionTypeContent::Annotation(data));
13512 }
13513 if let Some(deserializer) = deserializer {
13514 *self.state = ExtensionTypeDeserializerState::Annotation(deserializer);
13515 }
13516 Ok(DeserializerOutput {
13517 data: None,
13518 deserializer: Some(self),
13519 event,
13520 allow_any,
13521 })
13522 }
13523 (ExtensionTypeDeserializerState::OpenContent(deserializer), _) => {
13524 let DeserializerOutput {
13525 data,
13526 deserializer,
13527 event,
13528 allow_any,
13529 } = deserializer.next(reader, event)?;
13530 if let Some(data) = data {
13531 self.content.push(ExtensionTypeContent::OpenContent(data));
13532 }
13533 if let Some(deserializer) = deserializer {
13534 *self.state = ExtensionTypeDeserializerState::OpenContent(deserializer);
13535 }
13536 Ok(DeserializerOutput {
13537 data: None,
13538 deserializer: Some(self),
13539 event,
13540 allow_any,
13541 })
13542 }
13543 (ExtensionTypeDeserializerState::Group(deserializer), _) => {
13544 let DeserializerOutput {
13545 data,
13546 deserializer,
13547 event,
13548 allow_any,
13549 } = deserializer.next(reader, event)?;
13550 if let Some(data) = data {
13551 self.content.push(ExtensionTypeContent::Group(data));
13552 }
13553 if let Some(deserializer) = deserializer {
13554 *self.state = ExtensionTypeDeserializerState::Group(deserializer);
13555 }
13556 Ok(DeserializerOutput {
13557 data: None,
13558 deserializer: Some(self),
13559 event,
13560 allow_any,
13561 })
13562 }
13563 (ExtensionTypeDeserializerState::All(deserializer), _) => {
13564 let DeserializerOutput {
13565 data,
13566 deserializer,
13567 event,
13568 allow_any,
13569 } = deserializer.next(reader, event)?;
13570 if let Some(data) = data {
13571 self.content.push(ExtensionTypeContent::All(data));
13572 }
13573 if let Some(deserializer) = deserializer {
13574 *self.state = ExtensionTypeDeserializerState::All(deserializer);
13575 }
13576 Ok(DeserializerOutput {
13577 data: None,
13578 deserializer: Some(self),
13579 event,
13580 allow_any,
13581 })
13582 }
13583 (ExtensionTypeDeserializerState::Choice(deserializer), _) => {
13584 let DeserializerOutput {
13585 data,
13586 deserializer,
13587 event,
13588 allow_any,
13589 } = deserializer.next(reader, event)?;
13590 if let Some(data) = data {
13591 self.content.push(ExtensionTypeContent::Choice(data));
13592 }
13593 if let Some(deserializer) = deserializer {
13594 *self.state = ExtensionTypeDeserializerState::Choice(deserializer);
13595 }
13596 Ok(DeserializerOutput {
13597 data: None,
13598 deserializer: Some(self),
13599 event,
13600 allow_any,
13601 })
13602 }
13603 (ExtensionTypeDeserializerState::Sequence(deserializer), _) => {
13604 let DeserializerOutput {
13605 data,
13606 deserializer,
13607 event,
13608 allow_any,
13609 } = deserializer.next(reader, event)?;
13610 if let Some(data) = data {
13611 self.content.push(ExtensionTypeContent::Sequence(data));
13612 }
13613 if let Some(deserializer) = deserializer {
13614 *self.state = ExtensionTypeDeserializerState::Sequence(deserializer);
13615 }
13616 Ok(DeserializerOutput {
13617 data: None,
13618 deserializer: Some(self),
13619 event,
13620 allow_any,
13621 })
13622 }
13623 (ExtensionTypeDeserializerState::Attribute(deserializer), _) => {
13624 let DeserializerOutput {
13625 data,
13626 deserializer,
13627 event,
13628 allow_any,
13629 } = deserializer.next(reader, event)?;
13630 if let Some(data) = data {
13631 self.content.push(ExtensionTypeContent::Attribute(data));
13632 }
13633 if let Some(deserializer) = deserializer {
13634 *self.state = ExtensionTypeDeserializerState::Attribute(deserializer);
13635 }
13636 Ok(DeserializerOutput {
13637 data: None,
13638 deserializer: Some(self),
13639 event,
13640 allow_any,
13641 })
13642 }
13643 (ExtensionTypeDeserializerState::AttributeGroup(deserializer), _) => {
13644 let DeserializerOutput {
13645 data,
13646 deserializer,
13647 event,
13648 allow_any,
13649 } = deserializer.next(reader, event)?;
13650 if let Some(data) = data {
13651 self.content
13652 .push(ExtensionTypeContent::AttributeGroup(data));
13653 }
13654 if let Some(deserializer) = deserializer {
13655 *self.state = ExtensionTypeDeserializerState::AttributeGroup(deserializer);
13656 }
13657 Ok(DeserializerOutput {
13658 data: None,
13659 deserializer: Some(self),
13660 event,
13661 allow_any,
13662 })
13663 }
13664 (ExtensionTypeDeserializerState::AnyAttribute(deserializer), _) => {
13665 let DeserializerOutput {
13666 data,
13667 deserializer,
13668 event,
13669 allow_any,
13670 } = deserializer.next(reader, event)?;
13671 if let Some(data) = data {
13672 self.content.push(ExtensionTypeContent::AnyAttribute(data));
13673 }
13674 if let Some(deserializer) = deserializer {
13675 *self.state = ExtensionTypeDeserializerState::AnyAttribute(deserializer);
13676 }
13677 Ok(DeserializerOutput {
13678 data: None,
13679 deserializer: Some(self),
13680 event,
13681 allow_any,
13682 })
13683 }
13684 (ExtensionTypeDeserializerState::Assert(deserializer), _) => {
13685 let DeserializerOutput {
13686 data,
13687 deserializer,
13688 event,
13689 allow_any,
13690 } = deserializer.next(reader, event)?;
13691 if let Some(data) = data {
13692 self.content.push(ExtensionTypeContent::Assert(data));
13693 }
13694 if let Some(deserializer) = deserializer {
13695 *self.state = ExtensionTypeDeserializerState::Assert(deserializer);
13696 }
13697 Ok(DeserializerOutput {
13698 data: None,
13699 deserializer: Some(self),
13700 event,
13701 allow_any,
13702 })
13703 }
13704 }
13705 }
13706 fn finish<R>(self, _reader: &R) -> Result<super::ExtensionType, crate::quick_xml::Error>
13707 where
13708 R: crate::quick_xml::XmlReader,
13709 {
13710 use crate::quick_xml::ErrorKind;
13711 Ok(super::ExtensionType {
13712 id: self.id,
13713 base: self.base,
13714 content: self.content,
13715 })
13716 }
13717 }
13718 #[derive(Debug)]
13719 pub struct FieldDeserializer {
13720 id: Option<String>,
13721 xpath: String,
13722 xpath_default_namespace: Option<super::XpathDefaultNamespaceType>,
13723 annotation: Option<super::Annotation>,
13724 state: Box<FieldDeserializerState>,
13725 }
13726 #[derive(Debug)]
13727 enum FieldDeserializerState {
13728 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
13729 Done__,
13730 }
13731 impl FieldDeserializer {
13732 fn from_bytes_start<R>(
13733 reader: &R,
13734 bytes_start: &crate::quick_xml::BytesStart<'_>,
13735 ) -> Result<Self, crate::quick_xml::Error>
13736 where
13737 R: crate::quick_xml::XmlReader,
13738 {
13739 use crate::quick_xml::ErrorKind;
13740 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
13741 let mut id: Option<String> = None;
13742 let mut xpath: Option<String> = None;
13743 let mut xpath_default_namespace: Option<XpathDefaultNamespaceType> = None;
13744 for attrib in bytes_start.attributes() {
13745 let attrib = attrib?;
13746 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
13747 continue;
13748 }
13749 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
13750 reader.read_attrib(&mut id, b"id", &attrib.value)?;
13751 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"xpath")) {
13752 reader.read_attrib(&mut xpath, b"xpath", &attrib.value)?;
13753 } else if matches!(
13754 reader.resolve_local_name(attrib.key, NS_XS),
13755 Some(b"xpathDefaultNamespace")
13756 ) {
13757 reader.read_attrib(
13758 &mut xpath_default_namespace,
13759 b"xpathDefaultNamespace",
13760 &attrib.value,
13761 )?;
13762 }
13763 }
13764 Ok(Self {
13765 id: id,
13766 xpath: xpath.ok_or(ErrorKind::MissingAttribute("xpath".into()))?,
13767 xpath_default_namespace: xpath_default_namespace,
13768 annotation: None,
13769 state: Box::new(FieldDeserializerState::Annotation(None)),
13770 })
13771 }
13772 }
13773 impl<'de> crate::quick_xml::Deserializer<'de, super::Field> for FieldDeserializer {
13774 fn init<R>(
13775 reader: &R,
13776 event: crate::quick_xml::Event<'de>,
13777 ) -> crate::quick_xml::DeserializerResult<'de, super::Field, Self>
13778 where
13779 R: crate::quick_xml::XmlReader,
13780 {
13781 use crate::quick_xml::{DeserializerOutput, Event};
13782 match event {
13783 Event::Start(start) => {
13784 let deserializer = Self::from_bytes_start(reader, &start)?;
13785 Ok(DeserializerOutput {
13786 data: None,
13787 deserializer: Some(deserializer),
13788 event: None,
13789 allow_any: false,
13790 })
13791 }
13792 Event::Empty(start) => {
13793 let deserializer = Self::from_bytes_start(reader, &start)?;
13794 let data = deserializer.finish(reader)?;
13795 Ok(DeserializerOutput {
13796 data: Some(data),
13797 deserializer: None,
13798 event: None,
13799 allow_any: false,
13800 })
13801 }
13802 event => Ok(DeserializerOutput {
13803 data: None,
13804 deserializer: None,
13805 event: Some(event),
13806 allow_any: false,
13807 }),
13808 }
13809 }
13810 fn next<R>(
13811 mut self,
13812 reader: &R,
13813 event: crate::quick_xml::Event<'de>,
13814 ) -> crate::quick_xml::DeserializerResult<'de, super::Field, Self>
13815 where
13816 R: crate::quick_xml::XmlReader,
13817 {
13818 use crate::quick_xml::{
13819 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
13820 };
13821 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
13822 let mut event = event;
13823 let mut allow_any_fallback = None;
13824 loop {
13825 event = match (
13826 core::mem::replace(&mut *self.state, FieldDeserializerState::Done__),
13827 event,
13828 ) {
13829 (FieldDeserializerState::Annotation(Some(deserializer)), event) => {
13830 let DeserializerOutput {
13831 data,
13832 deserializer,
13833 event,
13834 allow_any,
13835 } = deserializer.next(reader, event)?;
13836 if let Some(data) = data {
13837 if self.annotation.is_some() {
13838 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
13839 b"annotation",
13840 )))?;
13841 }
13842 self.annotation = Some(data);
13843 }
13844 let event = match event {
13845 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
13846 event
13847 }
13848 event => {
13849 *self.state = FieldDeserializerState::Annotation(deserializer);
13850 return Ok(DeserializerOutput {
13851 data: None,
13852 deserializer: Some(self),
13853 event: event,
13854 allow_any: false,
13855 });
13856 }
13857 };
13858 if allow_any {
13859 allow_any_fallback
13860 .get_or_insert(FieldDeserializerState::Annotation(deserializer));
13861 } else if let Some(deserializer) = deserializer {
13862 let data = deserializer.finish(reader)?;
13863 if self.annotation.is_some() {
13864 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
13865 b"annotation",
13866 )))?;
13867 }
13868 self.annotation = Some(data);
13869 }
13870 *self.state = FieldDeserializerState::Annotation(None);
13871 event
13872 }
13873 (FieldDeserializerState::Annotation(None), event) => match &event {
13874 Event::Start(x) | Event::Empty(x)
13875 if matches!(
13876 reader.resolve_local_name(x.name(), NS_XS),
13877 Some(b"annotation")
13878 ) =>
13879 {
13880 let DeserializerOutput {
13881 data,
13882 deserializer,
13883 event,
13884 allow_any,
13885 } = <Annotation as WithDeserializer>::Deserializer::init(
13886 reader, event,
13887 )?;
13888 if let Some(data) = data {
13889 if self.annotation.is_some() {
13890 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
13891 b"annotation",
13892 )))?;
13893 }
13894 self.annotation = Some(data);
13895 }
13896 *self.state = FieldDeserializerState::Annotation(deserializer);
13897 match event {
13898 Some(event @ (Event::Start(_) | Event::End(_))) => {
13899 *self.state = FieldDeserializerState::Done__;
13900 if allow_any {
13901 allow_any_fallback.get_or_insert(
13902 FieldDeserializerState::Annotation(None),
13903 );
13904 }
13905 event
13906 }
13907 event @ (None | Some(_)) => {
13908 return Ok(DeserializerOutput {
13909 data: None,
13910 deserializer: Some(self),
13911 event,
13912 allow_any: false,
13913 })
13914 }
13915 }
13916 }
13917 Event::Start(_) | Event::Empty(_) => {
13918 *self.state = FieldDeserializerState::Done__;
13919 allow_any_fallback
13920 .get_or_insert(FieldDeserializerState::Annotation(None));
13921 event
13922 }
13923 Event::End(_) => {
13924 let data = self.finish(reader)?;
13925 return Ok(DeserializerOutput {
13926 data: Some(data),
13927 deserializer: None,
13928 event: None,
13929 allow_any: false,
13930 });
13931 }
13932 _ => {
13933 *self.state = FieldDeserializerState::Annotation(None);
13934 return Ok(DeserializerOutput {
13935 data: None,
13936 deserializer: Some(self),
13937 event: Some(event),
13938 allow_any: false,
13939 });
13940 }
13941 },
13942 (FieldDeserializerState::Done__, event) => {
13943 let allow_any = if let Some(fallback) = allow_any_fallback {
13944 *self.state = fallback;
13945 true
13946 } else {
13947 false
13948 };
13949 return Ok(DeserializerOutput {
13950 data: None,
13951 deserializer: Some(self),
13952 event: Some(event),
13953 allow_any,
13954 });
13955 }
13956 }
13957 }
13958 }
13959 fn finish<R>(self, _reader: &R) -> Result<super::Field, crate::quick_xml::Error>
13960 where
13961 R: crate::quick_xml::XmlReader,
13962 {
13963 use crate::quick_xml::ErrorKind;
13964 Ok(super::Field {
13965 id: self.id,
13966 xpath: self.xpath,
13967 xpath_default_namespace: self.xpath_default_namespace,
13968 annotation: self.annotation,
13969 })
13970 }
13971 }
13972 #[derive(Debug)]
13973 pub struct FacetTypeDeserializer {
13974 id: Option<String>,
13975 value: String,
13976 fixed: bool,
13977 annotation: Option<super::Annotation>,
13978 state: Box<FacetTypeDeserializerState>,
13979 }
13980 #[derive(Debug)]
13981 enum FacetTypeDeserializerState {
13982 Annotation(Option<<Annotation as crate::quick_xml::WithDeserializer>::Deserializer>),
13983 Done__,
13984 }
13985 impl FacetTypeDeserializer {
13986 fn from_bytes_start<R>(
13987 reader: &R,
13988 bytes_start: &crate::quick_xml::BytesStart<'_>,
13989 ) -> Result<Self, crate::quick_xml::Error>
13990 where
13991 R: crate::quick_xml::XmlReader,
13992 {
13993 use crate::quick_xml::ErrorKind;
13994 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
13995 let mut id: Option<String> = None;
13996 let mut value: Option<String> = None;
13997 let mut fixed: Option<bool> = None;
13998 for attrib in bytes_start.attributes() {
13999 let attrib = attrib?;
14000 if matches ! (attrib . key . prefix () , Some (x) if x . as_ref () == b"xmlns") {
14001 continue;
14002 }
14003 if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"id")) {
14004 reader.read_attrib(&mut id, b"id", &attrib.value)?;
14005 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"value")) {
14006 reader.read_attrib(&mut value, b"value", &attrib.value)?;
14007 } else if matches!(reader.resolve_local_name(attrib.key, NS_XS), Some(b"fixed")) {
14008 reader.read_attrib(&mut fixed, b"fixed", &attrib.value)?;
14009 }
14010 }
14011 Ok(Self {
14012 id: id,
14013 value: value.ok_or(ErrorKind::MissingAttribute("value".into()))?,
14014 fixed: fixed.unwrap_or_else(super::FacetType::default_fixed),
14015 annotation: None,
14016 state: Box::new(FacetTypeDeserializerState::Annotation(None)),
14017 })
14018 }
14019 }
14020 impl<'de> crate::quick_xml::Deserializer<'de, super::FacetType> for FacetTypeDeserializer {
14021 fn init<R>(
14022 reader: &R,
14023 event: crate::quick_xml::Event<'de>,
14024 ) -> crate::quick_xml::DeserializerResult<'de, super::FacetType, Self>
14025 where
14026 R: crate::quick_xml::XmlReader,
14027 {
14028 use crate::quick_xml::{DeserializerOutput, Event};
14029 match event {
14030 Event::Start(start) => {
14031 let deserializer = Self::from_bytes_start(reader, &start)?;
14032 Ok(DeserializerOutput {
14033 data: None,
14034 deserializer: Some(deserializer),
14035 event: None,
14036 allow_any: false,
14037 })
14038 }
14039 Event::Empty(start) => {
14040 let deserializer = Self::from_bytes_start(reader, &start)?;
14041 let data = deserializer.finish(reader)?;
14042 Ok(DeserializerOutput {
14043 data: Some(data),
14044 deserializer: None,
14045 event: None,
14046 allow_any: false,
14047 })
14048 }
14049 event => Ok(DeserializerOutput {
14050 data: None,
14051 deserializer: None,
14052 event: Some(event),
14053 allow_any: false,
14054 }),
14055 }
14056 }
14057 fn next<R>(
14058 mut self,
14059 reader: &R,
14060 event: crate::quick_xml::Event<'de>,
14061 ) -> crate::quick_xml::DeserializerResult<'de, super::FacetType, Self>
14062 where
14063 R: crate::quick_xml::XmlReader,
14064 {
14065 use crate::quick_xml::{
14066 Deserializer, DeserializerOutput, ErrorKind, Event, RawByteStr, WithDeserializer,
14067 };
14068 const NS_XS: &[u8] = b"http://www.w3.org/2001/XMLSchema";
14069 let mut event = event;
14070 let mut allow_any_fallback = None;
14071 loop {
14072 event = match (
14073 core::mem::replace(&mut *self.state, FacetTypeDeserializerState::Done__),
14074 event,
14075 ) {
14076 (FacetTypeDeserializerState::Annotation(Some(deserializer)), event) => {
14077 let DeserializerOutput {
14078 data,
14079 deserializer,
14080 event,
14081 allow_any,
14082 } = deserializer.next(reader, event)?;
14083 if let Some(data) = data {
14084 if self.annotation.is_some() {
14085 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
14086 b"annotation",
14087 )))?;
14088 }
14089 self.annotation = Some(data);
14090 }
14091 let event = match event {
14092 Some(event @ (Event::Start(_) | Event::Empty(_) | Event::End(_))) => {
14093 event
14094 }
14095 event => {
14096 *self.state = FacetTypeDeserializerState::Annotation(deserializer);
14097 return Ok(DeserializerOutput {
14098 data: None,
14099 deserializer: Some(self),
14100 event: event,
14101 allow_any: false,
14102 });
14103 }
14104 };
14105 if allow_any {
14106 allow_any_fallback.get_or_insert(
14107 FacetTypeDeserializerState::Annotation(deserializer),
14108 );
14109 } else if let Some(deserializer) = deserializer {
14110 let data = deserializer.finish(reader)?;
14111 if self.annotation.is_some() {
14112 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
14113 b"annotation",
14114 )))?;
14115 }
14116 self.annotation = Some(data);
14117 }
14118 *self.state = FacetTypeDeserializerState::Annotation(None);
14119 event
14120 }
14121 (FacetTypeDeserializerState::Annotation(None), event) => match &event {
14122 Event::Start(x) | Event::Empty(x)
14123 if matches!(
14124 reader.resolve_local_name(x.name(), NS_XS),
14125 Some(b"annotation")
14126 ) =>
14127 {
14128 let DeserializerOutput {
14129 data,
14130 deserializer,
14131 event,
14132 allow_any,
14133 } = <Annotation as WithDeserializer>::Deserializer::init(
14134 reader, event,
14135 )?;
14136 if let Some(data) = data {
14137 if self.annotation.is_some() {
14138 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
14139 b"annotation",
14140 )))?;
14141 }
14142 self.annotation = Some(data);
14143 }
14144 *self.state = FacetTypeDeserializerState::Annotation(deserializer);
14145 match event {
14146 Some(event @ (Event::Start(_) | Event::End(_))) => {
14147 *self.state = FacetTypeDeserializerState::Done__;
14148 if allow_any {
14149 allow_any_fallback.get_or_insert(
14150 FacetTypeDeserializerState::Annotation(None),
14151 );
14152 }
14153 event
14154 }
14155 event @ (None | Some(_)) => {
14156 return Ok(DeserializerOutput {
14157 data: None,
14158 deserializer: Some(self),
14159 event,
14160 allow_any: false,
14161 })
14162 }
14163 }
14164 }
14165 Event::Start(_) | Event::Empty(_) => {
14166 *self.state = FacetTypeDeserializerState::Done__;
14167 allow_any_fallback
14168 .get_or_insert(FacetTypeDeserializerState::Annotation(None));
14169 event
14170 }
14171 Event::End(_) => {
14172 let data = self.finish(reader)?;
14173 return Ok(DeserializerOutput {
14174 data: Some(data),
14175 deserializer: None,
14176 event: None,
14177 allow_any: false,
14178 });
14179 }
14180 _ => {
14181 *self.state = FacetTypeDeserializerState::Annotation(None);
14182 return Ok(DeserializerOutput {
14183 data: None,
14184 deserializer: Some(self),
14185 event: Some(event),
14186 allow_any: false,
14187 });
14188 }
14189 },
14190 (FacetTypeDeserializerState::Done__, event) => {
14191 let allow_any = if let Some(fallback) = allow_any_fallback {
14192 *self.state = fallback;
14193 true
14194 } else {
14195 false
14196 };
14197 return Ok(DeserializerOutput {
14198 data: None,
14199 deserializer: Some(self),
14200 event: Some(event),
14201 allow_any,
14202 });
14203 }
14204 }
14205 }
14206 }
14207 fn finish<R>(self, _reader: &R) -> Result<super::FacetType, crate::quick_xml::Error>
14208 where
14209 R: crate::quick_xml::XmlReader,
14210 {
14211 use crate::quick_xml::ErrorKind;
14212 Ok(super::FacetType {
14213 id: self.id,
14214 value: self.value,
14215 fixed: self.fixed,
14216 annotation: self.annotation,
14217 })
14218 }
14219 }
14220}