1use crate::models::schema::{MaxOccurs, QName};
2use core::ops::Deref;
3use xsd_parser_types::{
4 misc::Namespace,
5 quick_xml::{
6 DeserializeBytes, DeserializeHelper, Error, ErrorKind, RawByteStr, ValidateError,
7 WithDeserializer, WithDeserializerFromBytes,
8 },
9 xml::{AnyElement, NamespaceScope},
10};
11pub const NS_XS: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema");
12pub const NS_XML: Namespace = Namespace::new_const(b"http://www.w3.org/XML/1998/namespace");
13pub const NS_XSI: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema-instance");
14#[derive(Clone, Debug, Eq, PartialEq)]
15pub struct Schema {
16 pub target_namespace: Option<String>,
17 pub version: Option<String>,
18 pub final_default: FullDerivationSetType,
19 pub block_default: BlockSetType,
20 pub attribute_form_default: FormChoiceType,
21 pub element_form_default: FormChoiceType,
22 pub default_attributes: Option<QName>,
23 pub xpath_default_namespace: XpathDefaultNamespaceType,
24 pub id: Option<String>,
25 pub lang: Option<String>,
26 pub content: Vec<SchemaContent>,
27}
28#[derive(Clone, Debug, Eq, PartialEq)]
29pub enum SchemaContent {
30 Include(Include),
31 Import(Import),
32 Redefine(Redefine),
33 Override(Override),
34 Annotation(Annotation),
35 DefaultOpenContent(DefaultOpenContent),
36 SimpleType(SimpleBaseType),
37 ComplexType(ComplexBaseType),
38 Group(GroupType),
39 AttributeGroup(AttributeGroupType),
40 Element(ElementType),
41 Attribute(AttributeType),
42 Notation(Notation),
43}
44impl Schema {
45 #[must_use]
46 pub fn default_final_default() -> FullDerivationSetType {
47 FullDerivationSetType::BlockSetItemList(BlockSetItemList(Vec::new()))
48 }
49 #[must_use]
50 pub fn default_block_default() -> BlockSetType {
51 BlockSetType::BlockSetItemList(BlockSetItemList(Vec::new()))
52 }
53 #[must_use]
54 pub fn default_attribute_form_default() -> FormChoiceType {
55 FormChoiceType::Unqualified
56 }
57 #[must_use]
58 pub fn default_element_form_default() -> FormChoiceType {
59 FormChoiceType::Unqualified
60 }
61 #[must_use]
62 pub fn default_xpath_default_namespace() -> XpathDefaultNamespaceType {
63 XpathDefaultNamespaceType::String(String::from("##local"))
64 }
65}
66impl WithDeserializer for Schema {
67 type Deserializer = Box<quick_xml_deserialize::SchemaDeserializer>;
68}
69impl WithDeserializer for SchemaContent {
70 type Deserializer = Box<quick_xml_deserialize::SchemaContentDeserializer>;
71}
72#[derive(Clone, Debug, Eq, PartialEq)]
73pub enum FullDerivationSetType {
74 All,
75 BlockSetItemList(BlockSetItemList),
76}
77impl DeserializeBytes for FullDerivationSetType {
78 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
79 match bytes {
80 b"#all" => Ok(Self::All),
81 x => Ok(Self::BlockSetItemList(BlockSetItemList::deserialize_bytes(
82 helper, x,
83 )?)),
84 }
85 }
86}
87impl WithDeserializerFromBytes for FullDerivationSetType {}
88#[derive(Clone, Debug, Default, Eq, PartialEq)]
89pub struct BlockSetItemList(pub Vec<BlockSetItemType>);
90impl DeserializeBytes for BlockSetItemList {
91 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
92 Ok(Self(helper.deserialize_list(bytes)?))
93 }
94}
95impl WithDeserializerFromBytes for BlockSetItemList {}
96#[derive(Clone, Debug, Eq, PartialEq)]
97pub enum BlockSetType {
98 All,
99 BlockSetItemList(BlockSetItemList),
100}
101impl DeserializeBytes for BlockSetType {
102 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
103 match bytes {
104 b"#all" => Ok(Self::All),
105 x => Ok(Self::BlockSetItemList(BlockSetItemList::deserialize_bytes(
106 helper, x,
107 )?)),
108 }
109 }
110}
111impl WithDeserializerFromBytes for BlockSetType {}
112#[derive(Clone, Debug, Eq, PartialEq)]
113pub enum FormChoiceType {
114 Qualified,
115 Unqualified,
116}
117impl DeserializeBytes for FormChoiceType {
118 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
119 match bytes {
120 b"qualified" => Ok(Self::Qualified),
121 b"unqualified" => Ok(Self::Unqualified),
122 x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
123 RawByteStr::from_slice(x),
124 ))),
125 }
126 }
127}
128impl WithDeserializerFromBytes for FormChoiceType {}
129#[derive(Clone, Debug, Eq, PartialEq)]
130pub enum XpathDefaultNamespaceType {
131 String(String),
132 DefaultNamespace,
133 TargetNamespace,
134 Local,
135}
136impl DeserializeBytes for XpathDefaultNamespaceType {
137 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
138 match bytes {
139 b"##defaultNamespace" => Ok(Self::DefaultNamespace),
140 b"##targetNamespace" => Ok(Self::TargetNamespace),
141 b"##local" => Ok(Self::Local),
142 x => Ok(Self::String(String::deserialize_bytes(helper, x)?)),
143 }
144 }
145}
146impl WithDeserializerFromBytes for XpathDefaultNamespaceType {}
147#[derive(Clone, Debug, Eq, PartialEq)]
148pub struct Include {
149 pub id: Option<String>,
150 pub schema_location: String,
151 pub annotation: Option<Annotation>,
152}
153impl WithDeserializer for Include {
154 type Deserializer = Box<quick_xml_deserialize::IncludeDeserializer>;
155}
156#[derive(Clone, Debug, Eq, PartialEq)]
157pub struct Import {
158 pub id: Option<String>,
159 pub namespace: Option<String>,
160 pub schema_location: Option<String>,
161 pub annotation: Option<Annotation>,
162}
163impl WithDeserializer for Import {
164 type Deserializer = Box<quick_xml_deserialize::ImportDeserializer>;
165}
166#[derive(Clone, Debug, Eq, PartialEq)]
167pub struct Redefine {
168 pub schema_location: String,
169 pub id: Option<String>,
170 pub content: Vec<RedefineContent>,
171}
172#[derive(Clone, Debug, Eq, PartialEq)]
173pub enum RedefineContent {
174 Annotation(Annotation),
175 SimpleType(SimpleBaseType),
176 ComplexType(ComplexBaseType),
177 Group(GroupType),
178 AttributeGroup(AttributeGroupType),
179}
180impl WithDeserializer for Redefine {
181 type Deserializer = Box<quick_xml_deserialize::RedefineDeserializer>;
182}
183impl WithDeserializer for RedefineContent {
184 type Deserializer = Box<quick_xml_deserialize::RedefineContentDeserializer>;
185}
186#[derive(Clone, Debug, Eq, PartialEq)]
187pub struct Override {
188 pub schema_location: String,
189 pub id: Option<String>,
190 pub content: Vec<OverrideContent>,
191}
192#[derive(Clone, Debug, Eq, PartialEq)]
193pub enum OverrideContent {
194 Annotation(Annotation),
195 SimpleType(SimpleBaseType),
196 ComplexType(ComplexBaseType),
197 Group(GroupType),
198 AttributeGroup(AttributeGroupType),
199 Element(ElementType),
200 Attribute(AttributeType),
201 Notation(Notation),
202}
203impl WithDeserializer for Override {
204 type Deserializer = Box<quick_xml_deserialize::OverrideDeserializer>;
205}
206impl WithDeserializer for OverrideContent {
207 type Deserializer = Box<quick_xml_deserialize::OverrideContentDeserializer>;
208}
209#[derive(Clone, Debug, Eq, PartialEq)]
210pub struct Annotation {
211 pub id: Option<String>,
212 pub content: Vec<AnnotationContent>,
213}
214#[derive(Clone, Debug, Eq, PartialEq)]
215pub enum AnnotationContent {
216 Appinfo(AnyElement),
217 Documentation(AnyElement),
218}
219impl WithDeserializer for Annotation {
220 type Deserializer = Box<quick_xml_deserialize::AnnotationDeserializer>;
221}
222impl WithDeserializer for AnnotationContent {
223 type Deserializer = Box<quick_xml_deserialize::AnnotationContentDeserializer>;
224}
225#[derive(Clone, Debug, Eq, PartialEq)]
226pub struct DefaultOpenContent {
227 pub id: Option<String>,
228 pub applies_to_empty: bool,
229 pub mode: DefaultOpenContentModeType,
230 pub annotation: Option<Annotation>,
231 pub any: WildcardType,
232}
233impl DefaultOpenContent {
234 #[must_use]
235 pub fn default_applies_to_empty() -> bool {
236 false
237 }
238 #[must_use]
239 pub fn default_mode() -> DefaultOpenContentModeType {
240 DefaultOpenContentModeType::Interleave
241 }
242}
243impl WithDeserializer for DefaultOpenContent {
244 type Deserializer = Box<quick_xml_deserialize::DefaultOpenContentDeserializer>;
245}
246#[derive(Clone, Debug, Eq, PartialEq)]
247pub struct SimpleBaseType {
248 pub id: Option<String>,
249 pub final_: Option<SimpleDerivationSetType>,
250 pub name: Option<String>,
251 pub content: Vec<SimpleBaseTypeContent>,
252}
253#[derive(Clone, Debug, Eq, PartialEq)]
254pub enum SimpleBaseTypeContent {
255 Annotation(Annotation),
256 Restriction(Restriction),
257 List(List),
258 Union(Union),
259}
260impl WithDeserializer for SimpleBaseType {
261 type Deserializer = Box<quick_xml_deserialize::SimpleBaseTypeDeserializer>;
262}
263impl WithDeserializer for SimpleBaseTypeContent {
264 type Deserializer = Box<quick_xml_deserialize::SimpleBaseTypeContentDeserializer>;
265}
266#[derive(Clone, Debug, Eq, PartialEq)]
267pub struct ComplexBaseType {
268 pub id: Option<String>,
269 pub name: Option<String>,
270 pub mixed: Option<bool>,
271 pub abstract_: bool,
272 pub final_: Option<DerivationSetType>,
273 pub block: Option<DerivationSetType>,
274 pub default_attributes_apply: bool,
275 pub content: Vec<ComplexBaseTypeContent>,
276}
277#[derive(Clone, Debug, Eq, PartialEq)]
278pub enum ComplexBaseTypeContent {
279 Annotation(Annotation),
280 SimpleContent(SimpleContent),
281 ComplexContent(ComplexContent),
282 OpenContent(OpenContent),
283 Group(GroupType),
284 All(GroupType),
285 Choice(GroupType),
286 Sequence(GroupType),
287 Attribute(AttributeType),
288 AttributeGroup(AttributeGroupType),
289 AnyAttribute(AnyAttribute),
290 Assert(AssertionType),
291}
292impl ComplexBaseType {
293 #[must_use]
294 pub fn default_abstract_() -> bool {
295 false
296 }
297 #[must_use]
298 pub fn default_default_attributes_apply() -> bool {
299 true
300 }
301}
302impl WithDeserializer for ComplexBaseType {
303 type Deserializer = Box<quick_xml_deserialize::ComplexBaseTypeDeserializer>;
304}
305impl WithDeserializer for ComplexBaseTypeContent {
306 type Deserializer = Box<quick_xml_deserialize::ComplexBaseTypeContentDeserializer>;
307}
308#[derive(Clone, Debug, Eq, PartialEq)]
309pub struct GroupType {
310 pub id: Option<String>,
311 pub name: Option<String>,
312 pub ref_: Option<QName>,
313 pub min_occurs: usize,
314 pub max_occurs: MaxOccurs,
315 pub content: Vec<GroupTypeContent>,
316}
317#[derive(Clone, Debug, Eq, PartialEq)]
318pub enum GroupTypeContent {
319 Annotation(Annotation),
320 Element(ElementType),
321 Group(GroupType),
322 All(GroupType),
323 Choice(GroupType),
324 Sequence(GroupType),
325 Any(Any),
326}
327impl GroupType {
328 #[must_use]
329 pub fn default_min_occurs() -> usize {
330 1usize
331 }
332 #[must_use]
333 pub fn default_max_occurs() -> MaxOccurs {
334 MaxOccurs::Bounded(1usize)
335 }
336}
337impl WithDeserializer for GroupType {
338 type Deserializer = Box<quick_xml_deserialize::GroupTypeDeserializer>;
339}
340impl WithDeserializer for GroupTypeContent {
341 type Deserializer = Box<quick_xml_deserialize::GroupTypeContentDeserializer>;
342}
343#[derive(Clone, Debug, Eq, PartialEq)]
344pub struct AttributeGroupType {
345 pub id: Option<String>,
346 pub name: Option<String>,
347 pub ref_: Option<QName>,
348 pub content: Vec<AttributeGroupTypeContent>,
349}
350#[derive(Clone, Debug, Eq, PartialEq)]
351pub enum AttributeGroupTypeContent {
352 Annotation(Annotation),
353 Attribute(AttributeType),
354 AttributeGroup(AttributeGroupType),
355 AnyAttribute(AnyAttribute),
356}
357impl WithDeserializer for AttributeGroupType {
358 type Deserializer = Box<quick_xml_deserialize::AttributeGroupTypeDeserializer>;
359}
360impl WithDeserializer for AttributeGroupTypeContent {
361 type Deserializer = Box<quick_xml_deserialize::AttributeGroupTypeContentDeserializer>;
362}
363#[derive(Clone, Debug, Eq, PartialEq)]
364pub struct ElementType {
365 pub id: Option<String>,
366 pub name: Option<String>,
367 pub ref_: Option<QName>,
368 pub type_: Option<QName>,
369 pub substitution_group: Option<QNameList>,
370 pub min_occurs: usize,
371 pub max_occurs: MaxOccurs,
372 pub default: Option<String>,
373 pub fixed: Option<String>,
374 pub nillable: Option<bool>,
375 pub abstract_: bool,
376 pub final_: Option<DerivationSetType>,
377 pub block: Option<BlockSetType>,
378 pub form: Option<FormChoiceType>,
379 pub target_namespace: Option<String>,
380 pub content: Vec<ElementTypeContent>,
381}
382#[derive(Clone, Debug, Eq, PartialEq)]
383pub enum ElementTypeContent {
384 Annotation(Annotation),
385 SimpleType(SimpleBaseType),
386 ComplexType(ComplexBaseType),
387 Alternative(AltType),
388 Unique(KeybaseType),
389 Key(KeybaseType),
390 Keyref(Keyref),
391}
392impl ElementType {
393 #[must_use]
394 pub fn default_min_occurs() -> usize {
395 1usize
396 }
397 #[must_use]
398 pub fn default_max_occurs() -> MaxOccurs {
399 MaxOccurs::Bounded(1usize)
400 }
401 #[must_use]
402 pub fn default_abstract_() -> bool {
403 false
404 }
405}
406impl WithDeserializer for ElementType {
407 type Deserializer = Box<quick_xml_deserialize::ElementTypeDeserializer>;
408}
409impl WithDeserializer for ElementTypeContent {
410 type Deserializer = Box<quick_xml_deserialize::ElementTypeContentDeserializer>;
411}
412pub type AttributeType = NamespaceScope<AttributeInnerType>;
413#[derive(Clone, Debug, Eq, PartialEq)]
414pub struct AttributeInnerType {
415 pub id: Option<String>,
416 pub name: Option<String>,
417 pub ref_: Option<QName>,
418 pub type_: Option<QName>,
419 pub use_: AttributeUseType,
420 pub default: Option<String>,
421 pub fixed: Option<String>,
422 pub form: Option<FormChoiceType>,
423 pub target_namespace: Option<String>,
424 pub inheritable: Option<bool>,
425 pub annotation: Option<Annotation>,
426 pub simple_type: Option<SimpleBaseType>,
427}
428impl AttributeInnerType {
429 #[must_use]
430 pub fn default_use_() -> AttributeUseType {
431 AttributeUseType::Optional
432 }
433}
434impl WithDeserializer for AttributeInnerType {
435 type Deserializer = Box<quick_xml_deserialize::AttributeInnerTypeDeserializer>;
436}
437#[derive(Clone, Debug, Eq, PartialEq)]
438pub struct Notation {
439 pub id: Option<String>,
440 pub name: String,
441 pub public: Option<String>,
442 pub system: Option<String>,
443 pub annotation: Option<Annotation>,
444}
445impl WithDeserializer for Notation {
446 type Deserializer = Box<quick_xml_deserialize::NotationDeserializer>;
447}
448pub type BlockSetItemType = DerivationControlType;
449#[derive(Clone, Debug, Eq, PartialEq)]
450pub enum DefaultOpenContentModeType {
451 Interleave,
452 Suffix,
453}
454impl DeserializeBytes for DefaultOpenContentModeType {
455 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
456 match bytes {
457 b"interleave" => Ok(Self::Interleave),
458 b"suffix" => Ok(Self::Suffix),
459 x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
460 RawByteStr::from_slice(x),
461 ))),
462 }
463 }
464}
465impl WithDeserializerFromBytes for DefaultOpenContentModeType {}
466#[derive(Clone, Debug, Eq, PartialEq)]
467pub struct WildcardType {
468 pub id: Option<String>,
469 pub namespace: Option<NamespaceListType>,
470 pub not_namespace: Option<NotNamespaceType>,
471 pub process_contents: ProcessContentsType,
472 pub annotation: Option<Annotation>,
473}
474impl WildcardType {
475 #[must_use]
476 pub fn default_process_contents() -> ProcessContentsType {
477 ProcessContentsType::Strict
478 }
479}
480impl WithDeserializer for WildcardType {
481 type Deserializer = Box<quick_xml_deserialize::WildcardTypeDeserializer>;
482}
483#[derive(Clone, Debug, Eq, PartialEq)]
484pub enum SimpleDerivationSetType {
485 All,
486 BlockSetItemList(BlockSetItemList),
487}
488impl DeserializeBytes for SimpleDerivationSetType {
489 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
490 match bytes {
491 b"#all" => Ok(Self::All),
492 x => Ok(Self::BlockSetItemList(BlockSetItemList::deserialize_bytes(
493 helper, x,
494 )?)),
495 }
496 }
497}
498impl WithDeserializerFromBytes for SimpleDerivationSetType {}
499#[derive(Clone, Debug, Eq, PartialEq)]
500pub struct Restriction {
501 pub id: Option<String>,
502 pub base: Option<QName>,
503 pub content: Vec<RestrictionContent>,
504}
505#[derive(Clone, Debug, Eq, PartialEq)]
506pub enum RestrictionContent {
507 Annotation(Annotation),
508 SimpleType(SimpleBaseType),
509 Facet(Facet),
510}
511impl WithDeserializer for Restriction {
512 type Deserializer = Box<quick_xml_deserialize::RestrictionDeserializer>;
513}
514impl WithDeserializer for RestrictionContent {
515 type Deserializer = Box<quick_xml_deserialize::RestrictionContentDeserializer>;
516}
517#[derive(Clone, Debug, Eq, PartialEq)]
518pub struct List {
519 pub id: Option<String>,
520 pub item_type: Option<QName>,
521 pub annotation: Option<Annotation>,
522 pub simple_type: Option<Box<SimpleBaseType>>,
523}
524impl WithDeserializer for List {
525 type Deserializer = Box<quick_xml_deserialize::ListDeserializer>;
526}
527#[derive(Clone, Debug, Eq, PartialEq)]
528pub struct Union {
529 pub id: Option<String>,
530 pub member_types: Option<QNameList>,
531 pub annotation: Option<Annotation>,
532 pub simple_type: Vec<SimpleBaseType>,
533}
534impl WithDeserializer for Union {
535 type Deserializer = Box<quick_xml_deserialize::UnionDeserializer>;
536}
537#[derive(Clone, Debug, Eq, PartialEq)]
538pub enum DerivationSetType {
539 All,
540 BlockSetItemList(BlockSetItemList),
541}
542impl DeserializeBytes for DerivationSetType {
543 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
544 match bytes {
545 b"#all" => Ok(Self::All),
546 x => Ok(Self::BlockSetItemList(BlockSetItemList::deserialize_bytes(
547 helper, x,
548 )?)),
549 }
550 }
551}
552impl WithDeserializerFromBytes for DerivationSetType {}
553#[derive(Clone, Debug, Eq, PartialEq)]
554pub struct SimpleContent {
555 pub id: Option<String>,
556 pub content: Vec<SimpleContentContent>,
557}
558#[derive(Clone, Debug, Eq, PartialEq)]
559pub enum SimpleContentContent {
560 Annotation(Annotation),
561 Restriction(RestrictionType),
562 Extension(ExtensionType),
563}
564impl WithDeserializer for SimpleContent {
565 type Deserializer = Box<quick_xml_deserialize::SimpleContentDeserializer>;
566}
567impl WithDeserializer for SimpleContentContent {
568 type Deserializer = Box<quick_xml_deserialize::SimpleContentContentDeserializer>;
569}
570#[derive(Clone, Debug, Eq, PartialEq)]
571pub struct ComplexContent {
572 pub id: Option<String>,
573 pub mixed: Option<bool>,
574 pub content: Vec<ComplexContentContent>,
575}
576#[derive(Clone, Debug, Eq, PartialEq)]
577pub enum ComplexContentContent {
578 Annotation(Annotation),
579 Restriction(RestrictionType),
580 Extension(ExtensionType),
581}
582impl WithDeserializer for ComplexContent {
583 type Deserializer = Box<quick_xml_deserialize::ComplexContentDeserializer>;
584}
585impl WithDeserializer for ComplexContentContent {
586 type Deserializer = Box<quick_xml_deserialize::ComplexContentContentDeserializer>;
587}
588#[derive(Clone, Debug, Eq, PartialEq)]
589pub struct OpenContent {
590 pub id: Option<String>,
591 pub mode: OpenContentModeType,
592 pub annotation: Option<Annotation>,
593 pub any: Option<WildcardType>,
594}
595impl OpenContent {
596 #[must_use]
597 pub fn default_mode() -> OpenContentModeType {
598 OpenContentModeType::Interleave
599 }
600}
601impl WithDeserializer for OpenContent {
602 type Deserializer = Box<quick_xml_deserialize::OpenContentDeserializer>;
603}
604#[derive(Clone, Debug, Eq, PartialEq)]
605pub struct AnyAttribute {
606 pub id: Option<String>,
607 pub namespace: Option<NamespaceListType>,
608 pub not_namespace: Option<NotNamespaceType>,
609 pub process_contents: ProcessContentsType,
610 pub not_q_name: Option<QnameListAType>,
611 pub annotation: Option<Annotation>,
612}
613impl AnyAttribute {
614 #[must_use]
615 pub fn default_process_contents() -> ProcessContentsType {
616 ProcessContentsType::Strict
617 }
618}
619impl WithDeserializer for AnyAttribute {
620 type Deserializer = Box<quick_xml_deserialize::AnyAttributeDeserializer>;
621}
622#[derive(Clone, Debug, Eq, PartialEq)]
623pub struct AssertionType {
624 pub id: Option<String>,
625 pub test: Option<String>,
626 pub xpath_default_namespace: Option<XpathDefaultNamespaceType>,
627 pub annotation: Option<Annotation>,
628}
629impl WithDeserializer for AssertionType {
630 type Deserializer = Box<quick_xml_deserialize::AssertionTypeDeserializer>;
631}
632#[derive(Clone, Debug, Eq, PartialEq)]
633pub struct Any {
634 pub id: Option<String>,
635 pub namespace: Option<NamespaceListType>,
636 pub not_namespace: Option<NotNamespaceType>,
637 pub process_contents: ProcessContentsType,
638 pub not_q_name: Option<QnameListType>,
639 pub min_occurs: usize,
640 pub max_occurs: MaxOccurs,
641 pub annotation: Option<Annotation>,
642}
643impl Any {
644 #[must_use]
645 pub fn default_process_contents() -> ProcessContentsType {
646 ProcessContentsType::Strict
647 }
648 #[must_use]
649 pub fn default_min_occurs() -> usize {
650 1usize
651 }
652 #[must_use]
653 pub fn default_max_occurs() -> MaxOccurs {
654 MaxOccurs::Bounded(1usize)
655 }
656}
657impl WithDeserializer for Any {
658 type Deserializer = Box<quick_xml_deserialize::AnyDeserializer>;
659}
660#[derive(Clone, Debug, Default, Eq, PartialEq)]
661pub struct QNameList(pub Vec<QName>);
662impl DeserializeBytes for QNameList {
663 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
664 Ok(Self(helper.deserialize_list(bytes)?))
665 }
666}
667impl WithDeserializerFromBytes for QNameList {}
668#[derive(Clone, Debug, Eq, PartialEq)]
669pub struct AltType {
670 pub id: Option<String>,
671 pub test: Option<String>,
672 pub type_: Option<QName>,
673 pub xpath_default_namespace: Option<XpathDefaultNamespaceType>,
674 pub content: Vec<AltTypeContent>,
675}
676#[derive(Clone, Debug, Eq, PartialEq)]
677pub enum AltTypeContent {
678 Annotation(Annotation),
679 SimpleType(SimpleBaseType),
680 ComplexType(ComplexBaseType),
681}
682impl WithDeserializer for AltType {
683 type Deserializer = Box<quick_xml_deserialize::AltTypeDeserializer>;
684}
685impl WithDeserializer for AltTypeContent {
686 type Deserializer = Box<quick_xml_deserialize::AltTypeContentDeserializer>;
687}
688#[derive(Clone, Debug, Eq, PartialEq)]
689pub struct KeybaseType {
690 pub id: Option<String>,
691 pub name: Option<String>,
692 pub ref_: Option<QName>,
693 pub content: Option<KeybaseTypeContent>,
694}
695#[derive(Clone, Debug, Eq, PartialEq)]
696pub struct KeybaseTypeContent {
697 pub annotation: Option<Annotation>,
698 pub selector: Field,
699 pub field: Vec<Field>,
700}
701impl WithDeserializer for KeybaseType {
702 type Deserializer = Box<quick_xml_deserialize::KeybaseTypeDeserializer>;
703}
704impl WithDeserializer for KeybaseTypeContent {
705 type Deserializer = Box<quick_xml_deserialize::KeybaseTypeContentDeserializer>;
706}
707#[derive(Clone, Debug, Eq, PartialEq)]
708pub struct Keyref {
709 pub id: Option<String>,
710 pub name: Option<String>,
711 pub ref_: Option<QName>,
712 pub refer: Option<QName>,
713 pub content: Option<KeyrefContent>,
714}
715#[derive(Clone, Debug, Eq, PartialEq)]
716pub struct KeyrefContent {
717 pub annotation: Option<Annotation>,
718 pub selector: Field,
719 pub field: Vec<Field>,
720}
721impl WithDeserializer for Keyref {
722 type Deserializer = Box<quick_xml_deserialize::KeyrefDeserializer>;
723}
724impl WithDeserializer for KeyrefContent {
725 type Deserializer = Box<quick_xml_deserialize::KeyrefContentDeserializer>;
726}
727#[derive(Clone, Debug, Eq, PartialEq)]
728pub enum AttributeUseType {
729 Prohibited,
730 Optional,
731 Required,
732}
733impl DeserializeBytes for AttributeUseType {
734 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
735 match bytes {
736 b"prohibited" => Ok(Self::Prohibited),
737 b"optional" => Ok(Self::Optional),
738 b"required" => Ok(Self::Required),
739 x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
740 RawByteStr::from_slice(x),
741 ))),
742 }
743 }
744}
745impl WithDeserializerFromBytes for AttributeUseType {}
746#[derive(Clone, Debug, Eq, PartialEq)]
747pub enum DerivationControlType {
748 Substitution,
749 Extension,
750 Restriction,
751 List,
752 Union,
753}
754impl DeserializeBytes for DerivationControlType {
755 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
756 match bytes {
757 b"substitution" => Ok(Self::Substitution),
758 b"extension" => Ok(Self::Extension),
759 b"restriction" => Ok(Self::Restriction),
760 b"list" => Ok(Self::List),
761 b"union" => Ok(Self::Union),
762 x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
763 RawByteStr::from_slice(x),
764 ))),
765 }
766 }
767}
768impl WithDeserializerFromBytes for DerivationControlType {}
769#[derive(Clone, Debug, Eq, PartialEq)]
770pub enum NamespaceListType {
771 Any,
772 Other,
773 BasicNamespaceList(BasicNamespaceListType),
774}
775impl DeserializeBytes for NamespaceListType {
776 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
777 match bytes {
778 b"##any" => Ok(Self::Any),
779 b"##other" => Ok(Self::Other),
780 x => Ok(Self::BasicNamespaceList(
781 BasicNamespaceListType::deserialize_bytes(helper, x)?,
782 )),
783 }
784 }
785}
786impl WithDeserializerFromBytes for NamespaceListType {}
787#[derive(Clone, Debug, Eq, PartialEq)]
788pub struct NotNamespaceType(pub Vec<BasicNamespaceListItemType>);
789impl NotNamespaceType {
790 pub fn new(inner: Vec<BasicNamespaceListItemType>) -> Result<Self, ValidateError> {
791 Self::validate_value(&inner)?;
792 Ok(Self(inner))
793 }
794 #[must_use]
795 pub fn into_inner(self) -> Vec<BasicNamespaceListItemType> {
796 self.0
797 }
798 pub fn validate_value(value: &Vec<BasicNamespaceListItemType>) -> Result<(), ValidateError> {
799 if value.is_empty() {
800 return Err(ValidateError::MinLength(1usize));
801 }
802 Ok(())
803 }
804}
805impl From<NotNamespaceType> for Vec<BasicNamespaceListItemType> {
806 fn from(value: NotNamespaceType) -> Vec<BasicNamespaceListItemType> {
807 value.0
808 }
809}
810impl TryFrom<Vec<BasicNamespaceListItemType>> for NotNamespaceType {
811 type Error = ValidateError;
812 fn try_from(value: Vec<BasicNamespaceListItemType>) -> Result<Self, ValidateError> {
813 Self::new(value)
814 }
815}
816impl Deref for NotNamespaceType {
817 type Target = Vec<BasicNamespaceListItemType>;
818 fn deref(&self) -> &Self::Target {
819 &self.0
820 }
821}
822impl DeserializeBytes for NotNamespaceType {
823 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
824 let inner = helper.deserialize_list(bytes)?;
825 Ok(Self::new(inner).map_err(|error| (bytes, error))?)
826 }
827}
828impl WithDeserializerFromBytes for NotNamespaceType {}
829#[derive(Clone, Debug, Eq, PartialEq)]
830pub enum ProcessContentsType {
831 Skip,
832 Lax,
833 Strict,
834}
835impl DeserializeBytes for ProcessContentsType {
836 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
837 match bytes {
838 b"skip" => Ok(Self::Skip),
839 b"lax" => Ok(Self::Lax),
840 b"strict" => Ok(Self::Strict),
841 x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
842 RawByteStr::from_slice(x),
843 ))),
844 }
845 }
846}
847impl WithDeserializerFromBytes for ProcessContentsType {}
848#[derive(Clone, Debug, Eq, PartialEq)]
849pub enum Facet {
850 MinExclusive(FacetType),
851 MinInclusive(FacetType),
852 MaxExclusive(FacetType),
853 MaxInclusive(FacetType),
854 TotalDigits(FacetType),
855 FractionDigits(FacetType),
856 Length(FacetType),
857 MinLength(FacetType),
858 MaxLength(FacetType),
859 Enumeration(FacetType),
860 WhiteSpace(FacetType),
861 Pattern(FacetType),
862 Assertion(AssertionType),
863 ExplicitTimezone(FacetType),
864}
865impl WithDeserializer for Facet {
866 type Deserializer = Box<quick_xml_deserialize::FacetDeserializer>;
867}
868#[derive(Clone, Debug, Eq, PartialEq)]
869pub struct RestrictionType {
870 pub id: Option<String>,
871 pub base: QName,
872 pub content: Vec<RestrictionTypeContent>,
873}
874#[derive(Clone, Debug, Eq, PartialEq)]
875pub enum RestrictionTypeContent {
876 Annotation(Annotation),
877 OpenContent(OpenContent),
878 Group(GroupType),
879 All(GroupType),
880 Choice(GroupType),
881 Sequence(GroupType),
882 SimpleType(SimpleBaseType),
883 Facet(Facet),
884 Attribute(AttributeType),
885 AttributeGroup(AttributeGroupType),
886 AnyAttribute(AnyAttribute),
887 Assert(AssertionType),
888}
889impl WithDeserializer for RestrictionType {
890 type Deserializer = Box<quick_xml_deserialize::RestrictionTypeDeserializer>;
891}
892impl WithDeserializer for RestrictionTypeContent {
893 type Deserializer = Box<quick_xml_deserialize::RestrictionTypeContentDeserializer>;
894}
895#[derive(Clone, Debug, Eq, PartialEq)]
896pub struct ExtensionType {
897 pub id: Option<String>,
898 pub base: QName,
899 pub content: Vec<ExtensionTypeContent>,
900}
901#[derive(Clone, Debug, Eq, PartialEq)]
902pub enum ExtensionTypeContent {
903 Annotation(Annotation),
904 OpenContent(OpenContent),
905 Group(GroupType),
906 All(GroupType),
907 Choice(GroupType),
908 Sequence(GroupType),
909 Attribute(AttributeType),
910 AttributeGroup(AttributeGroupType),
911 AnyAttribute(AnyAttribute),
912 Assert(AssertionType),
913}
914impl WithDeserializer for ExtensionType {
915 type Deserializer = Box<quick_xml_deserialize::ExtensionTypeDeserializer>;
916}
917impl WithDeserializer for ExtensionTypeContent {
918 type Deserializer = Box<quick_xml_deserialize::ExtensionTypeContentDeserializer>;
919}
920#[derive(Clone, Debug, Eq, PartialEq)]
921pub enum OpenContentModeType {
922 None,
923 Interleave,
924 Suffix,
925}
926impl DeserializeBytes for OpenContentModeType {
927 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
928 match bytes {
929 b"none" => Ok(Self::None),
930 b"interleave" => Ok(Self::Interleave),
931 b"suffix" => Ok(Self::Suffix),
932 x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
933 RawByteStr::from_slice(x),
934 ))),
935 }
936 }
937}
938impl WithDeserializerFromBytes for OpenContentModeType {}
939#[derive(Clone, Debug, Default, Eq, PartialEq)]
940pub struct QnameListAType(pub Vec<QnameListAItemType>);
941impl DeserializeBytes for QnameListAType {
942 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
943 Ok(Self(helper.deserialize_list(bytes)?))
944 }
945}
946impl WithDeserializerFromBytes for QnameListAType {}
947#[derive(Clone, Debug, Default, Eq, PartialEq)]
948pub struct QnameListType(pub Vec<QnameListItemType>);
949impl DeserializeBytes for QnameListType {
950 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
951 Ok(Self(helper.deserialize_list(bytes)?))
952 }
953}
954impl WithDeserializerFromBytes for QnameListType {}
955#[derive(Clone, Debug, Eq, PartialEq)]
956pub struct Field {
957 pub id: Option<String>,
958 pub xpath: String,
959 pub xpath_default_namespace: Option<XpathDefaultNamespaceType>,
960 pub annotation: Option<Annotation>,
961}
962impl WithDeserializer for Field {
963 type Deserializer = Box<quick_xml_deserialize::FieldDeserializer>;
964}
965#[derive(Clone, Debug, Default, Eq, PartialEq)]
966pub struct BasicNamespaceListType(pub Vec<BasicNamespaceListItemType>);
967impl DeserializeBytes for BasicNamespaceListType {
968 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
969 Ok(Self(helper.deserialize_list(bytes)?))
970 }
971}
972impl WithDeserializerFromBytes for BasicNamespaceListType {}
973#[derive(Clone, Debug, Eq, PartialEq)]
974pub enum BasicNamespaceListItemType {
975 String(String),
976 TargetNamespace,
977 Local,
978}
979impl DeserializeBytes for BasicNamespaceListItemType {
980 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
981 match bytes {
982 b"##targetNamespace" => Ok(Self::TargetNamespace),
983 b"##local" => Ok(Self::Local),
984 x => Ok(Self::String(String::deserialize_bytes(helper, x)?)),
985 }
986 }
987}
988impl WithDeserializerFromBytes for BasicNamespaceListItemType {}
989pub type FacetType = NamespaceScope<FacetInnerType>;
990#[derive(Clone, Debug, Eq, PartialEq)]
991pub struct FacetInnerType {
992 pub id: Option<String>,
993 pub value: String,
994 pub fixed: bool,
995 pub annotation: Option<Annotation>,
996}
997impl FacetInnerType {
998 #[must_use]
999 pub fn default_fixed() -> bool {
1000 false
1001 }
1002}
1003impl WithDeserializer for FacetInnerType {
1004 type Deserializer = Box<quick_xml_deserialize::FacetInnerTypeDeserializer>;
1005}
1006#[derive(Clone, Debug, Eq, PartialEq)]
1007pub enum QnameListAItemType {
1008 QName(QName),
1009 Defined,
1010}
1011impl DeserializeBytes for QnameListAItemType {
1012 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
1013 match bytes {
1014 b"##defined" => Ok(Self::Defined),
1015 x => Ok(Self::QName(QName::deserialize_bytes(helper, x)?)),
1016 }
1017 }
1018}
1019impl WithDeserializerFromBytes for QnameListAItemType {}
1020#[derive(Clone, Debug, Eq, PartialEq)]
1021pub enum QnameListItemType {
1022 QName(QName),
1023 Defined,
1024 DefinedSibling,
1025}
1026impl DeserializeBytes for QnameListItemType {
1027 fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
1028 match bytes {
1029 b"##defined" => Ok(Self::Defined),
1030 b"##definedSibling" => Ok(Self::DefinedSibling),
1031 x => Ok(Self::QName(QName::deserialize_bytes(helper, x)?)),
1032 }
1033 }
1034}
1035impl WithDeserializerFromBytes for QnameListItemType {}
1036pub mod quick_xml_deserialize {
1037 use crate::models::schema::{MaxOccurs, QName};
1038 use core::mem::replace;
1039 use xsd_parser_types::{
1040 quick_xml::{
1041 BytesStart, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent,
1042 DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event,
1043 RawByteStr, WithDeserializer,
1044 },
1045 xml::AnyElement,
1046 };
1047 #[derive(Debug)]
1048 pub struct SchemaDeserializer {
1049 target_namespace: Option<String>,
1050 version: Option<String>,
1051 final_default: super::FullDerivationSetType,
1052 block_default: super::BlockSetType,
1053 attribute_form_default: super::FormChoiceType,
1054 element_form_default: super::FormChoiceType,
1055 default_attributes: Option<QName>,
1056 xpath_default_namespace: super::XpathDefaultNamespaceType,
1057 id: Option<String>,
1058 lang: Option<String>,
1059 content: Vec<super::SchemaContent>,
1060 state__: Box<SchemaDeserializerState>,
1061 }
1062 #[derive(Debug)]
1063 enum SchemaDeserializerState {
1064 Init__,
1065 Next__,
1066 Content__(<super::SchemaContent as WithDeserializer>::Deserializer),
1067 Unknown__,
1068 }
1069 impl SchemaDeserializer {
1070 fn from_bytes_start(
1071 helper: &mut DeserializeHelper,
1072 bytes_start: &BytesStart<'_>,
1073 ) -> Result<Box<Self>, Error> {
1074 let mut target_namespace: Option<String> = None;
1075 let mut version: Option<String> = None;
1076 let mut final_default: Option<super::FullDerivationSetType> = None;
1077 let mut block_default: Option<super::BlockSetType> = None;
1078 let mut attribute_form_default: Option<super::FormChoiceType> = None;
1079 let mut element_form_default: Option<super::FormChoiceType> = None;
1080 let mut default_attributes: Option<QName> = None;
1081 let mut xpath_default_namespace: Option<super::XpathDefaultNamespaceType> = None;
1082 let mut id: Option<String> = None;
1083 let mut lang: Option<String> = None;
1084 for attrib in helper.filter_xmlns_attributes(bytes_start) {
1085 let attrib = attrib?;
1086 if matches!(
1087 helper.resolve_local_name(attrib.key, &super::NS_XS),
1088 Some(b"targetNamespace")
1089 ) {
1090 helper.read_attrib(&mut target_namespace, b"targetNamespace", &attrib.value)?;
1091 } else if matches!(
1092 helper.resolve_local_name(attrib.key, &super::NS_XS),
1093 Some(b"version")
1094 ) {
1095 helper.read_attrib(&mut version, b"version", &attrib.value)?;
1096 } else if matches!(
1097 helper.resolve_local_name(attrib.key, &super::NS_XS),
1098 Some(b"finalDefault")
1099 ) {
1100 helper.read_attrib(&mut final_default, b"finalDefault", &attrib.value)?;
1101 } else if matches!(
1102 helper.resolve_local_name(attrib.key, &super::NS_XS),
1103 Some(b"blockDefault")
1104 ) {
1105 helper.read_attrib(&mut block_default, b"blockDefault", &attrib.value)?;
1106 } else if matches!(
1107 helper.resolve_local_name(attrib.key, &super::NS_XS),
1108 Some(b"attributeFormDefault")
1109 ) {
1110 helper.read_attrib(
1111 &mut attribute_form_default,
1112 b"attributeFormDefault",
1113 &attrib.value,
1114 )?;
1115 } else if matches!(
1116 helper.resolve_local_name(attrib.key, &super::NS_XS),
1117 Some(b"elementFormDefault")
1118 ) {
1119 helper.read_attrib(
1120 &mut element_form_default,
1121 b"elementFormDefault",
1122 &attrib.value,
1123 )?;
1124 } else if matches!(
1125 helper.resolve_local_name(attrib.key, &super::NS_XS),
1126 Some(b"defaultAttributes")
1127 ) {
1128 helper.read_attrib(
1129 &mut default_attributes,
1130 b"defaultAttributes",
1131 &attrib.value,
1132 )?;
1133 } else if matches!(
1134 helper.resolve_local_name(attrib.key, &super::NS_XS),
1135 Some(b"xpathDefaultNamespace")
1136 ) {
1137 helper.read_attrib(
1138 &mut xpath_default_namespace,
1139 b"xpathDefaultNamespace",
1140 &attrib.value,
1141 )?;
1142 } else if matches!(
1143 helper.resolve_local_name(attrib.key, &super::NS_XS),
1144 Some(b"id")
1145 ) {
1146 helper.read_attrib(&mut id, b"id", &attrib.value)?;
1147 } else if matches!(
1148 helper.resolve_local_name(attrib.key, &super::NS_XML),
1149 Some(b"lang")
1150 ) {
1151 helper.read_attrib(&mut lang, b"lang", &attrib.value)?;
1152 }
1153 }
1154 Ok(Box::new(Self {
1155 target_namespace: target_namespace,
1156 version: version,
1157 final_default: final_default.unwrap_or_else(super::Schema::default_final_default),
1158 block_default: block_default.unwrap_or_else(super::Schema::default_block_default),
1159 attribute_form_default: attribute_form_default
1160 .unwrap_or_else(super::Schema::default_attribute_form_default),
1161 element_form_default: element_form_default
1162 .unwrap_or_else(super::Schema::default_element_form_default),
1163 default_attributes: default_attributes,
1164 xpath_default_namespace: xpath_default_namespace
1165 .unwrap_or_else(super::Schema::default_xpath_default_namespace),
1166 id: id,
1167 lang: lang,
1168 content: Vec::new(),
1169 state__: Box::new(SchemaDeserializerState::Init__),
1170 }))
1171 }
1172 fn finish_state(
1173 &mut self,
1174 helper: &mut DeserializeHelper,
1175 state: SchemaDeserializerState,
1176 ) -> Result<(), Error> {
1177 if let SchemaDeserializerState::Content__(deserializer) = state {
1178 self.store_content(deserializer.finish(helper)?)?;
1179 }
1180 Ok(())
1181 }
1182 fn store_content(&mut self, value: super::SchemaContent) -> Result<(), Error> {
1183 self.content.push(value);
1184 Ok(())
1185 }
1186 fn handle_content<'de>(
1187 &mut self,
1188 helper: &mut DeserializeHelper,
1189 output: DeserializerOutput<'de, super::SchemaContent>,
1190 fallback: &mut Option<SchemaDeserializerState>,
1191 ) -> Result<ElementHandlerOutput<'de>, Error> {
1192 use SchemaDeserializerState as S;
1193 let DeserializerOutput {
1194 artifact,
1195 event,
1196 allow_any,
1197 } = output;
1198 if artifact.is_none() {
1199 *self.state__ = fallback.take().unwrap_or(S::Next__);
1200 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
1201 }
1202 if let Some(fallback) = fallback.take() {
1203 self.finish_state(helper, fallback)?;
1204 }
1205 match artifact {
1206 DeserializerArtifact::None => unreachable!(),
1207 DeserializerArtifact::Data(data) => {
1208 self.store_content(data)?;
1209 *self.state__ = S::Next__;
1210 Ok(ElementHandlerOutput::from_event(event, allow_any))
1211 }
1212 DeserializerArtifact::Deserializer(deserializer) => {
1213 *fallback = Some(S::Content__(deserializer));
1214 *self.state__ = S::Next__;
1215 Ok(ElementHandlerOutput::from_event(event, allow_any))
1216 }
1217 }
1218 }
1219 }
1220 impl<'de> Deserializer<'de, super::Schema> for Box<SchemaDeserializer> {
1221 fn init(
1222 helper: &mut DeserializeHelper,
1223 event: Event<'de>,
1224 ) -> DeserializerResult<'de, super::Schema> {
1225 helper.init_deserializer_from_start_event(event, SchemaDeserializer::from_bytes_start)
1226 }
1227 fn next(
1228 mut self,
1229 helper: &mut DeserializeHelper,
1230 event: Event<'de>,
1231 ) -> DeserializerResult<'de, super::Schema> {
1232 use SchemaDeserializerState as S;
1233 let mut event = event;
1234 let mut fallback = None;
1235 let (event, allow_any) = loop {
1236 let state = replace(&mut *self.state__, S::Unknown__);
1237 event = match (state, event) {
1238 (S::Unknown__, _) => unreachable!(),
1239 (S::Content__(deserializer), event) => {
1240 let output = deserializer.next(helper, event)?;
1241 match self.handle_content(helper, output, &mut fallback)? {
1242 ElementHandlerOutput::Break { event, allow_any } => {
1243 break (event, allow_any)
1244 }
1245 ElementHandlerOutput::Continue { event, .. } => event,
1246 }
1247 }
1248 (_, Event::End(_)) => {
1249 return Ok(DeserializerOutput {
1250 artifact: DeserializerArtifact::Data(self.finish(helper)?),
1251 event: DeserializerEvent::None,
1252 allow_any: false,
1253 });
1254 }
1255 (state @ (S::Init__ | S::Next__), event) => {
1256 fallback.get_or_insert(state);
1257 let output =
1258 <super::SchemaContent as WithDeserializer>::init(helper, event)?;
1259 match self.handle_content(helper, output, &mut fallback)? {
1260 ElementHandlerOutput::Break { event, allow_any } => {
1261 break (event, allow_any)
1262 }
1263 ElementHandlerOutput::Continue { event, .. } => event,
1264 }
1265 }
1266 }
1267 };
1268 if let Some(fallback) = fallback {
1269 *self.state__ = fallback;
1270 }
1271 let artifact = DeserializerArtifact::Deserializer(self);
1272 Ok(DeserializerOutput {
1273 artifact,
1274 event,
1275 allow_any,
1276 })
1277 }
1278 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Schema, Error> {
1279 let state = replace(&mut *self.state__, SchemaDeserializerState::Unknown__);
1280 self.finish_state(helper, state)?;
1281 Ok(super::Schema {
1282 target_namespace: self.target_namespace,
1283 version: self.version,
1284 final_default: self.final_default,
1285 block_default: self.block_default,
1286 attribute_form_default: self.attribute_form_default,
1287 element_form_default: self.element_form_default,
1288 default_attributes: self.default_attributes,
1289 xpath_default_namespace: self.xpath_default_namespace,
1290 id: self.id,
1291 lang: self.lang,
1292 content: helper.finish_vec(0usize, None, self.content)?,
1293 })
1294 }
1295 }
1296 #[derive(Debug)]
1297 pub struct SchemaContentDeserializer {
1298 state__: Box<SchemaContentDeserializerState>,
1299 }
1300 #[derive(Debug)]
1301 pub enum SchemaContentDeserializerState {
1302 Init__,
1303 Include(
1304 Option<super::Include>,
1305 Option<<super::Include as WithDeserializer>::Deserializer>,
1306 Option<<super::Include as WithDeserializer>::Deserializer>,
1307 ),
1308 Import(
1309 Option<super::Import>,
1310 Option<<super::Import as WithDeserializer>::Deserializer>,
1311 Option<<super::Import as WithDeserializer>::Deserializer>,
1312 ),
1313 Redefine(
1314 Option<super::Redefine>,
1315 Option<<super::Redefine as WithDeserializer>::Deserializer>,
1316 Option<<super::Redefine as WithDeserializer>::Deserializer>,
1317 ),
1318 Override(
1319 Option<super::Override>,
1320 Option<<super::Override as WithDeserializer>::Deserializer>,
1321 Option<<super::Override as WithDeserializer>::Deserializer>,
1322 ),
1323 Annotation(
1324 Option<super::Annotation>,
1325 Option<<super::Annotation as WithDeserializer>::Deserializer>,
1326 Option<<super::Annotation as WithDeserializer>::Deserializer>,
1327 ),
1328 DefaultOpenContent(
1329 Option<super::DefaultOpenContent>,
1330 Option<<super::DefaultOpenContent as WithDeserializer>::Deserializer>,
1331 Option<<super::DefaultOpenContent as WithDeserializer>::Deserializer>,
1332 ),
1333 SimpleType(
1334 Option<super::SimpleBaseType>,
1335 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
1336 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
1337 ),
1338 ComplexType(
1339 Option<super::ComplexBaseType>,
1340 Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
1341 Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
1342 ),
1343 Group(
1344 Option<super::GroupType>,
1345 Option<<super::GroupType as WithDeserializer>::Deserializer>,
1346 Option<<super::GroupType as WithDeserializer>::Deserializer>,
1347 ),
1348 AttributeGroup(
1349 Option<super::AttributeGroupType>,
1350 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
1351 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
1352 ),
1353 Element(
1354 Option<super::ElementType>,
1355 Option<<super::ElementType as WithDeserializer>::Deserializer>,
1356 Option<<super::ElementType as WithDeserializer>::Deserializer>,
1357 ),
1358 Attribute(
1359 Option<super::AttributeType>,
1360 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
1361 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
1362 ),
1363 Notation(
1364 Option<super::Notation>,
1365 Option<<super::Notation as WithDeserializer>::Deserializer>,
1366 Option<<super::Notation as WithDeserializer>::Deserializer>,
1367 ),
1368 Done__(super::SchemaContent),
1369 Unknown__,
1370 }
1371 impl SchemaContentDeserializer {
1372 fn find_suitable<'de>(
1373 &mut self,
1374 helper: &mut DeserializeHelper,
1375 event: Event<'de>,
1376 ) -> Result<ElementHandlerOutput<'de>, Error> {
1377 if let Event::Start(x) | Event::Empty(x) = &event {
1378 if matches!(
1379 helper.resolve_local_name(x.name(), &super::NS_XS),
1380 Some(b"include")
1381 ) {
1382 let output = <super::Include as WithDeserializer>::init(helper, event)?;
1383 return self.handle_include(helper, Default::default(), None, output);
1384 }
1385 if matches!(
1386 helper.resolve_local_name(x.name(), &super::NS_XS),
1387 Some(b"import")
1388 ) {
1389 let output = <super::Import as WithDeserializer>::init(helper, event)?;
1390 return self.handle_import(helper, Default::default(), None, output);
1391 }
1392 if matches!(
1393 helper.resolve_local_name(x.name(), &super::NS_XS),
1394 Some(b"redefine")
1395 ) {
1396 let output = <super::Redefine as WithDeserializer>::init(helper, event)?;
1397 return self.handle_redefine(helper, Default::default(), None, output);
1398 }
1399 if matches!(
1400 helper.resolve_local_name(x.name(), &super::NS_XS),
1401 Some(b"override")
1402 ) {
1403 let output = <super::Override as WithDeserializer>::init(helper, event)?;
1404 return self.handle_override_(helper, Default::default(), None, output);
1405 }
1406 if matches!(
1407 helper.resolve_local_name(x.name(), &super::NS_XS),
1408 Some(b"annotation")
1409 ) {
1410 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
1411 return self.handle_annotation(helper, Default::default(), None, output);
1412 }
1413 if matches!(
1414 helper.resolve_local_name(x.name(), &super::NS_XS),
1415 Some(b"defaultOpenContent")
1416 ) {
1417 let output =
1418 <super::DefaultOpenContent as WithDeserializer>::init(helper, event)?;
1419 return self.handle_default_open_content(
1420 helper,
1421 Default::default(),
1422 None,
1423 output,
1424 );
1425 }
1426 if matches!(
1427 helper.resolve_local_name(x.name(), &super::NS_XS),
1428 Some(b"simpleType")
1429 ) {
1430 let output = <super::SimpleBaseType as WithDeserializer>::init(helper, event)?;
1431 return self.handle_simple_type(helper, Default::default(), None, output);
1432 }
1433 if matches!(
1434 helper.resolve_local_name(x.name(), &super::NS_XS),
1435 Some(b"complexType")
1436 ) {
1437 let output = <super::ComplexBaseType as WithDeserializer>::init(helper, event)?;
1438 return self.handle_complex_type(helper, Default::default(), None, output);
1439 }
1440 if matches!(
1441 helper.resolve_local_name(x.name(), &super::NS_XS),
1442 Some(b"group")
1443 ) {
1444 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
1445 return self.handle_group(helper, Default::default(), None, output);
1446 }
1447 if matches!(
1448 helper.resolve_local_name(x.name(), &super::NS_XS),
1449 Some(b"attributeGroup")
1450 ) {
1451 let output =
1452 <super::AttributeGroupType as WithDeserializer>::init(helper, event)?;
1453 return self.handle_attribute_group(helper, Default::default(), None, output);
1454 }
1455 if matches!(
1456 helper.resolve_local_name(x.name(), &super::NS_XS),
1457 Some(b"element")
1458 ) {
1459 let output = <super::ElementType as WithDeserializer>::init(helper, event)?;
1460 return self.handle_element(helper, Default::default(), None, output);
1461 }
1462 if matches!(
1463 helper.resolve_local_name(x.name(), &super::NS_XS),
1464 Some(b"attribute")
1465 ) {
1466 let output = <super::AttributeType as WithDeserializer>::init(helper, event)?;
1467 return self.handle_attribute(helper, Default::default(), None, output);
1468 }
1469 if matches!(
1470 helper.resolve_local_name(x.name(), &super::NS_XS),
1471 Some(b"notation")
1472 ) {
1473 let output = <super::Notation as WithDeserializer>::init(helper, event)?;
1474 return self.handle_notation(helper, Default::default(), None, output);
1475 }
1476 }
1477 *self.state__ = SchemaContentDeserializerState::Init__;
1478 Ok(ElementHandlerOutput::return_to_parent(event, false))
1479 }
1480 fn finish_state(
1481 helper: &mut DeserializeHelper,
1482 state: SchemaContentDeserializerState,
1483 ) -> Result<super::SchemaContent, Error> {
1484 use SchemaContentDeserializerState as S;
1485 match state {
1486 S::Init__ => Err(ErrorKind::MissingContent.into()),
1487 S::Include(mut values, None, deserializer) => {
1488 if let Some(deserializer) = deserializer {
1489 let value = deserializer.finish(helper)?;
1490 SchemaContentDeserializer::store_include(&mut values, value)?;
1491 }
1492 Ok(super::SchemaContent::Include(
1493 helper.finish_element("include", values)?,
1494 ))
1495 }
1496 S::Import(mut values, None, deserializer) => {
1497 if let Some(deserializer) = deserializer {
1498 let value = deserializer.finish(helper)?;
1499 SchemaContentDeserializer::store_import(&mut values, value)?;
1500 }
1501 Ok(super::SchemaContent::Import(
1502 helper.finish_element("import", values)?,
1503 ))
1504 }
1505 S::Redefine(mut values, None, deserializer) => {
1506 if let Some(deserializer) = deserializer {
1507 let value = deserializer.finish(helper)?;
1508 SchemaContentDeserializer::store_redefine(&mut values, value)?;
1509 }
1510 Ok(super::SchemaContent::Redefine(
1511 helper.finish_element("redefine", values)?,
1512 ))
1513 }
1514 S::Override(mut values, None, deserializer) => {
1515 if let Some(deserializer) = deserializer {
1516 let value = deserializer.finish(helper)?;
1517 SchemaContentDeserializer::store_override_(&mut values, value)?;
1518 }
1519 Ok(super::SchemaContent::Override(
1520 helper.finish_element("override", values)?,
1521 ))
1522 }
1523 S::Annotation(mut values, None, deserializer) => {
1524 if let Some(deserializer) = deserializer {
1525 let value = deserializer.finish(helper)?;
1526 SchemaContentDeserializer::store_annotation(&mut values, value)?;
1527 }
1528 Ok(super::SchemaContent::Annotation(
1529 helper.finish_element("annotation", values)?,
1530 ))
1531 }
1532 S::DefaultOpenContent(mut values, None, deserializer) => {
1533 if let Some(deserializer) = deserializer {
1534 let value = deserializer.finish(helper)?;
1535 SchemaContentDeserializer::store_default_open_content(&mut values, value)?;
1536 }
1537 Ok(super::SchemaContent::DefaultOpenContent(
1538 helper.finish_element("defaultOpenContent", values)?,
1539 ))
1540 }
1541 S::SimpleType(mut values, None, deserializer) => {
1542 if let Some(deserializer) = deserializer {
1543 let value = deserializer.finish(helper)?;
1544 SchemaContentDeserializer::store_simple_type(&mut values, value)?;
1545 }
1546 Ok(super::SchemaContent::SimpleType(
1547 helper.finish_element("simpleType", values)?,
1548 ))
1549 }
1550 S::ComplexType(mut values, None, deserializer) => {
1551 if let Some(deserializer) = deserializer {
1552 let value = deserializer.finish(helper)?;
1553 SchemaContentDeserializer::store_complex_type(&mut values, value)?;
1554 }
1555 Ok(super::SchemaContent::ComplexType(
1556 helper.finish_element("complexType", values)?,
1557 ))
1558 }
1559 S::Group(mut values, None, deserializer) => {
1560 if let Some(deserializer) = deserializer {
1561 let value = deserializer.finish(helper)?;
1562 SchemaContentDeserializer::store_group(&mut values, value)?;
1563 }
1564 Ok(super::SchemaContent::Group(
1565 helper.finish_element("group", values)?,
1566 ))
1567 }
1568 S::AttributeGroup(mut values, None, deserializer) => {
1569 if let Some(deserializer) = deserializer {
1570 let value = deserializer.finish(helper)?;
1571 SchemaContentDeserializer::store_attribute_group(&mut values, value)?;
1572 }
1573 Ok(super::SchemaContent::AttributeGroup(
1574 helper.finish_element("attributeGroup", values)?,
1575 ))
1576 }
1577 S::Element(mut values, None, deserializer) => {
1578 if let Some(deserializer) = deserializer {
1579 let value = deserializer.finish(helper)?;
1580 SchemaContentDeserializer::store_element(&mut values, value)?;
1581 }
1582 Ok(super::SchemaContent::Element(
1583 helper.finish_element("element", values)?,
1584 ))
1585 }
1586 S::Attribute(mut values, None, deserializer) => {
1587 if let Some(deserializer) = deserializer {
1588 let value = deserializer.finish(helper)?;
1589 SchemaContentDeserializer::store_attribute(&mut values, value)?;
1590 }
1591 Ok(super::SchemaContent::Attribute(
1592 helper.finish_element("attribute", values)?,
1593 ))
1594 }
1595 S::Notation(mut values, None, deserializer) => {
1596 if let Some(deserializer) = deserializer {
1597 let value = deserializer.finish(helper)?;
1598 SchemaContentDeserializer::store_notation(&mut values, value)?;
1599 }
1600 Ok(super::SchemaContent::Notation(
1601 helper.finish_element("notation", values)?,
1602 ))
1603 }
1604 S::Done__(data) => Ok(data),
1605 _ => unreachable!(),
1606 }
1607 }
1608 fn store_include(
1609 values: &mut Option<super::Include>,
1610 value: super::Include,
1611 ) -> Result<(), Error> {
1612 if values.is_some() {
1613 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1614 b"include",
1615 )))?;
1616 }
1617 *values = Some(value);
1618 Ok(())
1619 }
1620 fn store_import(
1621 values: &mut Option<super::Import>,
1622 value: super::Import,
1623 ) -> Result<(), Error> {
1624 if values.is_some() {
1625 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1626 b"import",
1627 )))?;
1628 }
1629 *values = Some(value);
1630 Ok(())
1631 }
1632 fn store_redefine(
1633 values: &mut Option<super::Redefine>,
1634 value: super::Redefine,
1635 ) -> Result<(), Error> {
1636 if values.is_some() {
1637 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1638 b"redefine",
1639 )))?;
1640 }
1641 *values = Some(value);
1642 Ok(())
1643 }
1644 fn store_override_(
1645 values: &mut Option<super::Override>,
1646 value: super::Override,
1647 ) -> Result<(), Error> {
1648 if values.is_some() {
1649 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1650 b"override",
1651 )))?;
1652 }
1653 *values = Some(value);
1654 Ok(())
1655 }
1656 fn store_annotation(
1657 values: &mut Option<super::Annotation>,
1658 value: super::Annotation,
1659 ) -> Result<(), Error> {
1660 if values.is_some() {
1661 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1662 b"annotation",
1663 )))?;
1664 }
1665 *values = Some(value);
1666 Ok(())
1667 }
1668 fn store_default_open_content(
1669 values: &mut Option<super::DefaultOpenContent>,
1670 value: super::DefaultOpenContent,
1671 ) -> Result<(), Error> {
1672 if values.is_some() {
1673 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1674 b"defaultOpenContent",
1675 )))?;
1676 }
1677 *values = Some(value);
1678 Ok(())
1679 }
1680 fn store_simple_type(
1681 values: &mut Option<super::SimpleBaseType>,
1682 value: super::SimpleBaseType,
1683 ) -> Result<(), Error> {
1684 if values.is_some() {
1685 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1686 b"simpleType",
1687 )))?;
1688 }
1689 *values = Some(value);
1690 Ok(())
1691 }
1692 fn store_complex_type(
1693 values: &mut Option<super::ComplexBaseType>,
1694 value: super::ComplexBaseType,
1695 ) -> Result<(), Error> {
1696 if values.is_some() {
1697 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1698 b"complexType",
1699 )))?;
1700 }
1701 *values = Some(value);
1702 Ok(())
1703 }
1704 fn store_group(
1705 values: &mut Option<super::GroupType>,
1706 value: super::GroupType,
1707 ) -> Result<(), Error> {
1708 if values.is_some() {
1709 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1710 b"group",
1711 )))?;
1712 }
1713 *values = Some(value);
1714 Ok(())
1715 }
1716 fn store_attribute_group(
1717 values: &mut Option<super::AttributeGroupType>,
1718 value: super::AttributeGroupType,
1719 ) -> Result<(), Error> {
1720 if values.is_some() {
1721 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1722 b"attributeGroup",
1723 )))?;
1724 }
1725 *values = Some(value);
1726 Ok(())
1727 }
1728 fn store_element(
1729 values: &mut Option<super::ElementType>,
1730 value: super::ElementType,
1731 ) -> Result<(), Error> {
1732 if values.is_some() {
1733 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1734 b"element",
1735 )))?;
1736 }
1737 *values = Some(value);
1738 Ok(())
1739 }
1740 fn store_attribute(
1741 values: &mut Option<super::AttributeType>,
1742 value: super::AttributeType,
1743 ) -> Result<(), Error> {
1744 if values.is_some() {
1745 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1746 b"attribute",
1747 )))?;
1748 }
1749 *values = Some(value);
1750 Ok(())
1751 }
1752 fn store_notation(
1753 values: &mut Option<super::Notation>,
1754 value: super::Notation,
1755 ) -> Result<(), Error> {
1756 if values.is_some() {
1757 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
1758 b"notation",
1759 )))?;
1760 }
1761 *values = Some(value);
1762 Ok(())
1763 }
1764 fn handle_include<'de>(
1765 &mut self,
1766 helper: &mut DeserializeHelper,
1767 mut values: Option<super::Include>,
1768 fallback: Option<<super::Include as WithDeserializer>::Deserializer>,
1769 output: DeserializerOutput<'de, super::Include>,
1770 ) -> Result<ElementHandlerOutput<'de>, Error> {
1771 use SchemaContentDeserializerState as S;
1772 let DeserializerOutput {
1773 artifact,
1774 event,
1775 allow_any,
1776 } = output;
1777 if artifact.is_none() {
1778 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
1779 }
1780 if let Some(deserializer) = fallback {
1781 let data = deserializer.finish(helper)?;
1782 SchemaContentDeserializer::store_include(&mut values, data)?;
1783 }
1784 match artifact {
1785 DeserializerArtifact::None => unreachable!(),
1786 DeserializerArtifact::Data(data) => {
1787 SchemaContentDeserializer::store_include(&mut values, data)?;
1788 let data = SchemaContentDeserializer::finish_state(
1789 helper,
1790 S::Include(values, None, None),
1791 )?;
1792 *self.state__ = S::Done__(data);
1793 Ok(ElementHandlerOutput::break_(event, allow_any))
1794 }
1795 DeserializerArtifact::Deserializer(deserializer) => {
1796 *self.state__ = S::Include(values, None, Some(deserializer));
1797 Ok(ElementHandlerOutput::break_(event, allow_any))
1798 }
1799 }
1800 }
1801 fn handle_import<'de>(
1802 &mut self,
1803 helper: &mut DeserializeHelper,
1804 mut values: Option<super::Import>,
1805 fallback: Option<<super::Import as WithDeserializer>::Deserializer>,
1806 output: DeserializerOutput<'de, super::Import>,
1807 ) -> Result<ElementHandlerOutput<'de>, Error> {
1808 use SchemaContentDeserializerState as S;
1809 let DeserializerOutput {
1810 artifact,
1811 event,
1812 allow_any,
1813 } = output;
1814 if artifact.is_none() {
1815 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
1816 }
1817 if let Some(deserializer) = fallback {
1818 let data = deserializer.finish(helper)?;
1819 SchemaContentDeserializer::store_import(&mut values, data)?;
1820 }
1821 match artifact {
1822 DeserializerArtifact::None => unreachable!(),
1823 DeserializerArtifact::Data(data) => {
1824 SchemaContentDeserializer::store_import(&mut values, data)?;
1825 let data = SchemaContentDeserializer::finish_state(
1826 helper,
1827 S::Import(values, None, None),
1828 )?;
1829 *self.state__ = S::Done__(data);
1830 Ok(ElementHandlerOutput::break_(event, allow_any))
1831 }
1832 DeserializerArtifact::Deserializer(deserializer) => {
1833 *self.state__ = S::Import(values, None, Some(deserializer));
1834 Ok(ElementHandlerOutput::break_(event, allow_any))
1835 }
1836 }
1837 }
1838 fn handle_redefine<'de>(
1839 &mut self,
1840 helper: &mut DeserializeHelper,
1841 mut values: Option<super::Redefine>,
1842 fallback: Option<<super::Redefine as WithDeserializer>::Deserializer>,
1843 output: DeserializerOutput<'de, super::Redefine>,
1844 ) -> Result<ElementHandlerOutput<'de>, Error> {
1845 use SchemaContentDeserializerState as S;
1846 let DeserializerOutput {
1847 artifact,
1848 event,
1849 allow_any,
1850 } = output;
1851 if artifact.is_none() {
1852 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
1853 }
1854 if let Some(deserializer) = fallback {
1855 let data = deserializer.finish(helper)?;
1856 SchemaContentDeserializer::store_redefine(&mut values, data)?;
1857 }
1858 match artifact {
1859 DeserializerArtifact::None => unreachable!(),
1860 DeserializerArtifact::Data(data) => {
1861 SchemaContentDeserializer::store_redefine(&mut values, data)?;
1862 let data = SchemaContentDeserializer::finish_state(
1863 helper,
1864 S::Redefine(values, None, None),
1865 )?;
1866 *self.state__ = S::Done__(data);
1867 Ok(ElementHandlerOutput::break_(event, allow_any))
1868 }
1869 DeserializerArtifact::Deserializer(deserializer) => {
1870 *self.state__ = S::Redefine(values, None, Some(deserializer));
1871 Ok(ElementHandlerOutput::break_(event, allow_any))
1872 }
1873 }
1874 }
1875 fn handle_override_<'de>(
1876 &mut self,
1877 helper: &mut DeserializeHelper,
1878 mut values: Option<super::Override>,
1879 fallback: Option<<super::Override as WithDeserializer>::Deserializer>,
1880 output: DeserializerOutput<'de, super::Override>,
1881 ) -> Result<ElementHandlerOutput<'de>, Error> {
1882 use SchemaContentDeserializerState as S;
1883 let DeserializerOutput {
1884 artifact,
1885 event,
1886 allow_any,
1887 } = output;
1888 if artifact.is_none() {
1889 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
1890 }
1891 if let Some(deserializer) = fallback {
1892 let data = deserializer.finish(helper)?;
1893 SchemaContentDeserializer::store_override_(&mut values, data)?;
1894 }
1895 match artifact {
1896 DeserializerArtifact::None => unreachable!(),
1897 DeserializerArtifact::Data(data) => {
1898 SchemaContentDeserializer::store_override_(&mut values, data)?;
1899 let data = SchemaContentDeserializer::finish_state(
1900 helper,
1901 S::Override(values, None, None),
1902 )?;
1903 *self.state__ = S::Done__(data);
1904 Ok(ElementHandlerOutput::break_(event, allow_any))
1905 }
1906 DeserializerArtifact::Deserializer(deserializer) => {
1907 *self.state__ = S::Override(values, None, Some(deserializer));
1908 Ok(ElementHandlerOutput::break_(event, allow_any))
1909 }
1910 }
1911 }
1912 fn handle_annotation<'de>(
1913 &mut self,
1914 helper: &mut DeserializeHelper,
1915 mut values: Option<super::Annotation>,
1916 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
1917 output: DeserializerOutput<'de, super::Annotation>,
1918 ) -> Result<ElementHandlerOutput<'de>, Error> {
1919 use SchemaContentDeserializerState as S;
1920 let DeserializerOutput {
1921 artifact,
1922 event,
1923 allow_any,
1924 } = output;
1925 if artifact.is_none() {
1926 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
1927 }
1928 if let Some(deserializer) = fallback {
1929 let data = deserializer.finish(helper)?;
1930 SchemaContentDeserializer::store_annotation(&mut values, data)?;
1931 }
1932 match artifact {
1933 DeserializerArtifact::None => unreachable!(),
1934 DeserializerArtifact::Data(data) => {
1935 SchemaContentDeserializer::store_annotation(&mut values, data)?;
1936 let data = SchemaContentDeserializer::finish_state(
1937 helper,
1938 S::Annotation(values, None, None),
1939 )?;
1940 *self.state__ = S::Done__(data);
1941 Ok(ElementHandlerOutput::break_(event, allow_any))
1942 }
1943 DeserializerArtifact::Deserializer(deserializer) => {
1944 *self.state__ = S::Annotation(values, None, Some(deserializer));
1945 Ok(ElementHandlerOutput::break_(event, allow_any))
1946 }
1947 }
1948 }
1949 fn handle_default_open_content<'de>(
1950 &mut self,
1951 helper: &mut DeserializeHelper,
1952 mut values: Option<super::DefaultOpenContent>,
1953 fallback: Option<<super::DefaultOpenContent as WithDeserializer>::Deserializer>,
1954 output: DeserializerOutput<'de, super::DefaultOpenContent>,
1955 ) -> Result<ElementHandlerOutput<'de>, Error> {
1956 use SchemaContentDeserializerState as S;
1957 let DeserializerOutput {
1958 artifact,
1959 event,
1960 allow_any,
1961 } = output;
1962 if artifact.is_none() {
1963 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
1964 }
1965 if let Some(deserializer) = fallback {
1966 let data = deserializer.finish(helper)?;
1967 SchemaContentDeserializer::store_default_open_content(&mut values, data)?;
1968 }
1969 match artifact {
1970 DeserializerArtifact::None => unreachable!(),
1971 DeserializerArtifact::Data(data) => {
1972 SchemaContentDeserializer::store_default_open_content(&mut values, data)?;
1973 let data = SchemaContentDeserializer::finish_state(
1974 helper,
1975 S::DefaultOpenContent(values, None, None),
1976 )?;
1977 *self.state__ = S::Done__(data);
1978 Ok(ElementHandlerOutput::break_(event, allow_any))
1979 }
1980 DeserializerArtifact::Deserializer(deserializer) => {
1981 *self.state__ = S::DefaultOpenContent(values, None, Some(deserializer));
1982 Ok(ElementHandlerOutput::break_(event, allow_any))
1983 }
1984 }
1985 }
1986 fn handle_simple_type<'de>(
1987 &mut self,
1988 helper: &mut DeserializeHelper,
1989 mut values: Option<super::SimpleBaseType>,
1990 fallback: Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
1991 output: DeserializerOutput<'de, super::SimpleBaseType>,
1992 ) -> Result<ElementHandlerOutput<'de>, Error> {
1993 use SchemaContentDeserializerState as S;
1994 let DeserializerOutput {
1995 artifact,
1996 event,
1997 allow_any,
1998 } = output;
1999 if artifact.is_none() {
2000 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
2001 }
2002 if let Some(deserializer) = fallback {
2003 let data = deserializer.finish(helper)?;
2004 SchemaContentDeserializer::store_simple_type(&mut values, data)?;
2005 }
2006 match artifact {
2007 DeserializerArtifact::None => unreachable!(),
2008 DeserializerArtifact::Data(data) => {
2009 SchemaContentDeserializer::store_simple_type(&mut values, data)?;
2010 let data = SchemaContentDeserializer::finish_state(
2011 helper,
2012 S::SimpleType(values, None, None),
2013 )?;
2014 *self.state__ = S::Done__(data);
2015 Ok(ElementHandlerOutput::break_(event, allow_any))
2016 }
2017 DeserializerArtifact::Deserializer(deserializer) => {
2018 *self.state__ = S::SimpleType(values, None, Some(deserializer));
2019 Ok(ElementHandlerOutput::break_(event, allow_any))
2020 }
2021 }
2022 }
2023 fn handle_complex_type<'de>(
2024 &mut self,
2025 helper: &mut DeserializeHelper,
2026 mut values: Option<super::ComplexBaseType>,
2027 fallback: Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
2028 output: DeserializerOutput<'de, super::ComplexBaseType>,
2029 ) -> Result<ElementHandlerOutput<'de>, Error> {
2030 use SchemaContentDeserializerState as S;
2031 let DeserializerOutput {
2032 artifact,
2033 event,
2034 allow_any,
2035 } = output;
2036 if artifact.is_none() {
2037 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
2038 }
2039 if let Some(deserializer) = fallback {
2040 let data = deserializer.finish(helper)?;
2041 SchemaContentDeserializer::store_complex_type(&mut values, data)?;
2042 }
2043 match artifact {
2044 DeserializerArtifact::None => unreachable!(),
2045 DeserializerArtifact::Data(data) => {
2046 SchemaContentDeserializer::store_complex_type(&mut values, data)?;
2047 let data = SchemaContentDeserializer::finish_state(
2048 helper,
2049 S::ComplexType(values, None, None),
2050 )?;
2051 *self.state__ = S::Done__(data);
2052 Ok(ElementHandlerOutput::break_(event, allow_any))
2053 }
2054 DeserializerArtifact::Deserializer(deserializer) => {
2055 *self.state__ = S::ComplexType(values, None, Some(deserializer));
2056 Ok(ElementHandlerOutput::break_(event, allow_any))
2057 }
2058 }
2059 }
2060 fn handle_group<'de>(
2061 &mut self,
2062 helper: &mut DeserializeHelper,
2063 mut values: Option<super::GroupType>,
2064 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
2065 output: DeserializerOutput<'de, super::GroupType>,
2066 ) -> Result<ElementHandlerOutput<'de>, Error> {
2067 use SchemaContentDeserializerState as S;
2068 let DeserializerOutput {
2069 artifact,
2070 event,
2071 allow_any,
2072 } = output;
2073 if artifact.is_none() {
2074 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
2075 }
2076 if let Some(deserializer) = fallback {
2077 let data = deserializer.finish(helper)?;
2078 SchemaContentDeserializer::store_group(&mut values, data)?;
2079 }
2080 match artifact {
2081 DeserializerArtifact::None => unreachable!(),
2082 DeserializerArtifact::Data(data) => {
2083 SchemaContentDeserializer::store_group(&mut values, data)?;
2084 let data = SchemaContentDeserializer::finish_state(
2085 helper,
2086 S::Group(values, None, None),
2087 )?;
2088 *self.state__ = S::Done__(data);
2089 Ok(ElementHandlerOutput::break_(event, allow_any))
2090 }
2091 DeserializerArtifact::Deserializer(deserializer) => {
2092 *self.state__ = S::Group(values, None, Some(deserializer));
2093 Ok(ElementHandlerOutput::break_(event, allow_any))
2094 }
2095 }
2096 }
2097 fn handle_attribute_group<'de>(
2098 &mut self,
2099 helper: &mut DeserializeHelper,
2100 mut values: Option<super::AttributeGroupType>,
2101 fallback: Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
2102 output: DeserializerOutput<'de, super::AttributeGroupType>,
2103 ) -> Result<ElementHandlerOutput<'de>, Error> {
2104 use SchemaContentDeserializerState as S;
2105 let DeserializerOutput {
2106 artifact,
2107 event,
2108 allow_any,
2109 } = output;
2110 if artifact.is_none() {
2111 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
2112 }
2113 if let Some(deserializer) = fallback {
2114 let data = deserializer.finish(helper)?;
2115 SchemaContentDeserializer::store_attribute_group(&mut values, data)?;
2116 }
2117 match artifact {
2118 DeserializerArtifact::None => unreachable!(),
2119 DeserializerArtifact::Data(data) => {
2120 SchemaContentDeserializer::store_attribute_group(&mut values, data)?;
2121 let data = SchemaContentDeserializer::finish_state(
2122 helper,
2123 S::AttributeGroup(values, None, None),
2124 )?;
2125 *self.state__ = S::Done__(data);
2126 Ok(ElementHandlerOutput::break_(event, allow_any))
2127 }
2128 DeserializerArtifact::Deserializer(deserializer) => {
2129 *self.state__ = S::AttributeGroup(values, None, Some(deserializer));
2130 Ok(ElementHandlerOutput::break_(event, allow_any))
2131 }
2132 }
2133 }
2134 fn handle_element<'de>(
2135 &mut self,
2136 helper: &mut DeserializeHelper,
2137 mut values: Option<super::ElementType>,
2138 fallback: Option<<super::ElementType as WithDeserializer>::Deserializer>,
2139 output: DeserializerOutput<'de, super::ElementType>,
2140 ) -> Result<ElementHandlerOutput<'de>, Error> {
2141 use SchemaContentDeserializerState as S;
2142 let DeserializerOutput {
2143 artifact,
2144 event,
2145 allow_any,
2146 } = output;
2147 if artifact.is_none() {
2148 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
2149 }
2150 if let Some(deserializer) = fallback {
2151 let data = deserializer.finish(helper)?;
2152 SchemaContentDeserializer::store_element(&mut values, data)?;
2153 }
2154 match artifact {
2155 DeserializerArtifact::None => unreachable!(),
2156 DeserializerArtifact::Data(data) => {
2157 SchemaContentDeserializer::store_element(&mut values, data)?;
2158 let data = SchemaContentDeserializer::finish_state(
2159 helper,
2160 S::Element(values, None, None),
2161 )?;
2162 *self.state__ = S::Done__(data);
2163 Ok(ElementHandlerOutput::break_(event, allow_any))
2164 }
2165 DeserializerArtifact::Deserializer(deserializer) => {
2166 *self.state__ = S::Element(values, None, Some(deserializer));
2167 Ok(ElementHandlerOutput::break_(event, allow_any))
2168 }
2169 }
2170 }
2171 fn handle_attribute<'de>(
2172 &mut self,
2173 helper: &mut DeserializeHelper,
2174 mut values: Option<super::AttributeType>,
2175 fallback: Option<<super::AttributeType as WithDeserializer>::Deserializer>,
2176 output: DeserializerOutput<'de, super::AttributeType>,
2177 ) -> Result<ElementHandlerOutput<'de>, Error> {
2178 use SchemaContentDeserializerState as S;
2179 let DeserializerOutput {
2180 artifact,
2181 event,
2182 allow_any,
2183 } = output;
2184 if artifact.is_none() {
2185 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
2186 }
2187 if let Some(deserializer) = fallback {
2188 let data = deserializer.finish(helper)?;
2189 SchemaContentDeserializer::store_attribute(&mut values, data)?;
2190 }
2191 match artifact {
2192 DeserializerArtifact::None => unreachable!(),
2193 DeserializerArtifact::Data(data) => {
2194 SchemaContentDeserializer::store_attribute(&mut values, data)?;
2195 let data = SchemaContentDeserializer::finish_state(
2196 helper,
2197 S::Attribute(values, None, None),
2198 )?;
2199 *self.state__ = S::Done__(data);
2200 Ok(ElementHandlerOutput::break_(event, allow_any))
2201 }
2202 DeserializerArtifact::Deserializer(deserializer) => {
2203 *self.state__ = S::Attribute(values, None, Some(deserializer));
2204 Ok(ElementHandlerOutput::break_(event, allow_any))
2205 }
2206 }
2207 }
2208 fn handle_notation<'de>(
2209 &mut self,
2210 helper: &mut DeserializeHelper,
2211 mut values: Option<super::Notation>,
2212 fallback: Option<<super::Notation as WithDeserializer>::Deserializer>,
2213 output: DeserializerOutput<'de, super::Notation>,
2214 ) -> Result<ElementHandlerOutput<'de>, Error> {
2215 use SchemaContentDeserializerState as S;
2216 let DeserializerOutput {
2217 artifact,
2218 event,
2219 allow_any,
2220 } = output;
2221 if artifact.is_none() {
2222 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
2223 }
2224 if let Some(deserializer) = fallback {
2225 let data = deserializer.finish(helper)?;
2226 SchemaContentDeserializer::store_notation(&mut values, data)?;
2227 }
2228 match artifact {
2229 DeserializerArtifact::None => unreachable!(),
2230 DeserializerArtifact::Data(data) => {
2231 SchemaContentDeserializer::store_notation(&mut values, data)?;
2232 let data = SchemaContentDeserializer::finish_state(
2233 helper,
2234 S::Notation(values, None, None),
2235 )?;
2236 *self.state__ = S::Done__(data);
2237 Ok(ElementHandlerOutput::break_(event, allow_any))
2238 }
2239 DeserializerArtifact::Deserializer(deserializer) => {
2240 *self.state__ = S::Notation(values, None, Some(deserializer));
2241 Ok(ElementHandlerOutput::break_(event, allow_any))
2242 }
2243 }
2244 }
2245 }
2246 impl<'de> Deserializer<'de, super::SchemaContent> for Box<SchemaContentDeserializer> {
2247 fn init(
2248 helper: &mut DeserializeHelper,
2249 event: Event<'de>,
2250 ) -> DeserializerResult<'de, super::SchemaContent> {
2251 let deserializer = Box::new(SchemaContentDeserializer {
2252 state__: Box::new(SchemaContentDeserializerState::Init__),
2253 });
2254 let mut output = deserializer.next(helper, event)?;
2255 output.artifact = match output.artifact {
2256 DeserializerArtifact::Deserializer(x)
2257 if matches!(&*x.state__, SchemaContentDeserializerState::Init__) =>
2258 {
2259 DeserializerArtifact::None
2260 }
2261 artifact => artifact,
2262 };
2263 Ok(output)
2264 }
2265 fn next(
2266 mut self,
2267 helper: &mut DeserializeHelper,
2268 event: Event<'de>,
2269 ) -> DeserializerResult<'de, super::SchemaContent> {
2270 use SchemaContentDeserializerState as S;
2271 let mut event = event;
2272 let (event, allow_any) = loop {
2273 let state = replace(&mut *self.state__, S::Unknown__);
2274 event = match (state, event) {
2275 (S::Unknown__, _) => unreachable!(),
2276 (S::Include(values, fallback, Some(deserializer)), event) => {
2277 let output = deserializer.next(helper, event)?;
2278 match self.handle_include(helper, values, fallback, output)? {
2279 ElementHandlerOutput::Break { event, allow_any } => {
2280 break (event, allow_any)
2281 }
2282 ElementHandlerOutput::Continue { event, .. } => event,
2283 }
2284 }
2285 (S::Import(values, fallback, Some(deserializer)), event) => {
2286 let output = deserializer.next(helper, event)?;
2287 match self.handle_import(helper, values, fallback, output)? {
2288 ElementHandlerOutput::Break { event, allow_any } => {
2289 break (event, allow_any)
2290 }
2291 ElementHandlerOutput::Continue { event, .. } => event,
2292 }
2293 }
2294 (S::Redefine(values, fallback, Some(deserializer)), event) => {
2295 let output = deserializer.next(helper, event)?;
2296 match self.handle_redefine(helper, values, fallback, output)? {
2297 ElementHandlerOutput::Break { event, allow_any } => {
2298 break (event, allow_any)
2299 }
2300 ElementHandlerOutput::Continue { event, .. } => event,
2301 }
2302 }
2303 (S::Override(values, fallback, Some(deserializer)), event) => {
2304 let output = deserializer.next(helper, event)?;
2305 match self.handle_override_(helper, values, fallback, output)? {
2306 ElementHandlerOutput::Break { event, allow_any } => {
2307 break (event, allow_any)
2308 }
2309 ElementHandlerOutput::Continue { event, .. } => event,
2310 }
2311 }
2312 (S::Annotation(values, fallback, Some(deserializer)), event) => {
2313 let output = deserializer.next(helper, event)?;
2314 match self.handle_annotation(helper, values, fallback, output)? {
2315 ElementHandlerOutput::Break { event, allow_any } => {
2316 break (event, allow_any)
2317 }
2318 ElementHandlerOutput::Continue { event, .. } => event,
2319 }
2320 }
2321 (S::DefaultOpenContent(values, fallback, Some(deserializer)), event) => {
2322 let output = deserializer.next(helper, event)?;
2323 match self.handle_default_open_content(helper, values, fallback, output)? {
2324 ElementHandlerOutput::Break { event, allow_any } => {
2325 break (event, allow_any)
2326 }
2327 ElementHandlerOutput::Continue { event, .. } => event,
2328 }
2329 }
2330 (S::SimpleType(values, fallback, Some(deserializer)), event) => {
2331 let output = deserializer.next(helper, event)?;
2332 match self.handle_simple_type(helper, values, fallback, output)? {
2333 ElementHandlerOutput::Break { event, allow_any } => {
2334 break (event, allow_any)
2335 }
2336 ElementHandlerOutput::Continue { event, .. } => event,
2337 }
2338 }
2339 (S::ComplexType(values, fallback, Some(deserializer)), event) => {
2340 let output = deserializer.next(helper, event)?;
2341 match self.handle_complex_type(helper, values, fallback, output)? {
2342 ElementHandlerOutput::Break { event, allow_any } => {
2343 break (event, allow_any)
2344 }
2345 ElementHandlerOutput::Continue { event, .. } => event,
2346 }
2347 }
2348 (S::Group(values, fallback, Some(deserializer)), event) => {
2349 let output = deserializer.next(helper, event)?;
2350 match self.handle_group(helper, values, fallback, output)? {
2351 ElementHandlerOutput::Break { event, allow_any } => {
2352 break (event, allow_any)
2353 }
2354 ElementHandlerOutput::Continue { event, .. } => event,
2355 }
2356 }
2357 (S::AttributeGroup(values, fallback, Some(deserializer)), event) => {
2358 let output = deserializer.next(helper, event)?;
2359 match self.handle_attribute_group(helper, values, fallback, output)? {
2360 ElementHandlerOutput::Break { event, allow_any } => {
2361 break (event, allow_any)
2362 }
2363 ElementHandlerOutput::Continue { event, .. } => event,
2364 }
2365 }
2366 (S::Element(values, fallback, Some(deserializer)), event) => {
2367 let output = deserializer.next(helper, event)?;
2368 match self.handle_element(helper, values, fallback, output)? {
2369 ElementHandlerOutput::Break { event, allow_any } => {
2370 break (event, allow_any)
2371 }
2372 ElementHandlerOutput::Continue { event, .. } => event,
2373 }
2374 }
2375 (S::Attribute(values, fallback, Some(deserializer)), event) => {
2376 let output = deserializer.next(helper, event)?;
2377 match self.handle_attribute(helper, values, fallback, output)? {
2378 ElementHandlerOutput::Break { event, allow_any } => {
2379 break (event, allow_any)
2380 }
2381 ElementHandlerOutput::Continue { event, .. } => event,
2382 }
2383 }
2384 (S::Notation(values, fallback, Some(deserializer)), event) => {
2385 let output = deserializer.next(helper, event)?;
2386 match self.handle_notation(helper, values, fallback, output)? {
2387 ElementHandlerOutput::Break { event, allow_any } => {
2388 break (event, allow_any)
2389 }
2390 ElementHandlerOutput::Continue { event, .. } => event,
2391 }
2392 }
2393 (state, event @ Event::End(_)) => {
2394 return Ok(DeserializerOutput {
2395 artifact: DeserializerArtifact::Data(
2396 SchemaContentDeserializer::finish_state(helper, state)?,
2397 ),
2398 event: DeserializerEvent::Continue(event),
2399 allow_any: false,
2400 });
2401 }
2402 (S::Init__, event) => match self.find_suitable(helper, event)? {
2403 ElementHandlerOutput::Break { event, allow_any } => {
2404 break (event, allow_any)
2405 }
2406 ElementHandlerOutput::Continue { event, .. } => event,
2407 },
2408 (
2409 S::Include(values, fallback, None),
2410 event @ (Event::Start(_) | Event::Empty(_)),
2411 ) => {
2412 let output = helper.init_start_tag_deserializer(
2413 event,
2414 Some(&super::NS_XS),
2415 b"include",
2416 false,
2417 )?;
2418 match self.handle_include(helper, values, fallback, output)? {
2419 ElementHandlerOutput::Break { event, allow_any } => {
2420 break (event, allow_any)
2421 }
2422 ElementHandlerOutput::Continue { event, .. } => event,
2423 }
2424 }
2425 (
2426 S::Import(values, fallback, None),
2427 event @ (Event::Start(_) | Event::Empty(_)),
2428 ) => {
2429 let output = helper.init_start_tag_deserializer(
2430 event,
2431 Some(&super::NS_XS),
2432 b"import",
2433 false,
2434 )?;
2435 match self.handle_import(helper, values, fallback, output)? {
2436 ElementHandlerOutput::Break { event, allow_any } => {
2437 break (event, allow_any)
2438 }
2439 ElementHandlerOutput::Continue { event, .. } => event,
2440 }
2441 }
2442 (
2443 S::Redefine(values, fallback, None),
2444 event @ (Event::Start(_) | Event::Empty(_)),
2445 ) => {
2446 let output = helper.init_start_tag_deserializer(
2447 event,
2448 Some(&super::NS_XS),
2449 b"redefine",
2450 true,
2451 )?;
2452 match self.handle_redefine(helper, values, fallback, output)? {
2453 ElementHandlerOutput::Break { event, allow_any } => {
2454 break (event, allow_any)
2455 }
2456 ElementHandlerOutput::Continue { event, .. } => event,
2457 }
2458 }
2459 (
2460 S::Override(values, fallback, None),
2461 event @ (Event::Start(_) | Event::Empty(_)),
2462 ) => {
2463 let output = helper.init_start_tag_deserializer(
2464 event,
2465 Some(&super::NS_XS),
2466 b"override",
2467 true,
2468 )?;
2469 match self.handle_override_(helper, values, fallback, output)? {
2470 ElementHandlerOutput::Break { event, allow_any } => {
2471 break (event, allow_any)
2472 }
2473 ElementHandlerOutput::Continue { event, .. } => event,
2474 }
2475 }
2476 (
2477 S::Annotation(values, fallback, None),
2478 event @ (Event::Start(_) | Event::Empty(_)),
2479 ) => {
2480 let output = helper.init_start_tag_deserializer(
2481 event,
2482 Some(&super::NS_XS),
2483 b"annotation",
2484 false,
2485 )?;
2486 match self.handle_annotation(helper, values, fallback, output)? {
2487 ElementHandlerOutput::Break { event, allow_any } => {
2488 break (event, allow_any)
2489 }
2490 ElementHandlerOutput::Continue { event, .. } => event,
2491 }
2492 }
2493 (
2494 S::DefaultOpenContent(values, fallback, None),
2495 event @ (Event::Start(_) | Event::Empty(_)),
2496 ) => {
2497 let output = helper.init_start_tag_deserializer(
2498 event,
2499 Some(&super::NS_XS),
2500 b"defaultOpenContent",
2501 false,
2502 )?;
2503 match self.handle_default_open_content(helper, values, fallback, output)? {
2504 ElementHandlerOutput::Break { event, allow_any } => {
2505 break (event, allow_any)
2506 }
2507 ElementHandlerOutput::Continue { event, .. } => event,
2508 }
2509 }
2510 (
2511 S::SimpleType(values, fallback, None),
2512 event @ (Event::Start(_) | Event::Empty(_)),
2513 ) => {
2514 let output = helper.init_start_tag_deserializer(
2515 event,
2516 Some(&super::NS_XS),
2517 b"simpleType",
2518 true,
2519 )?;
2520 match self.handle_simple_type(helper, values, fallback, output)? {
2521 ElementHandlerOutput::Break { event, allow_any } => {
2522 break (event, allow_any)
2523 }
2524 ElementHandlerOutput::Continue { event, .. } => event,
2525 }
2526 }
2527 (
2528 S::ComplexType(values, fallback, None),
2529 event @ (Event::Start(_) | Event::Empty(_)),
2530 ) => {
2531 let output = helper.init_start_tag_deserializer(
2532 event,
2533 Some(&super::NS_XS),
2534 b"complexType",
2535 true,
2536 )?;
2537 match self.handle_complex_type(helper, values, fallback, output)? {
2538 ElementHandlerOutput::Break { event, allow_any } => {
2539 break (event, allow_any)
2540 }
2541 ElementHandlerOutput::Continue { event, .. } => event,
2542 }
2543 }
2544 (
2545 S::Group(values, fallback, None),
2546 event @ (Event::Start(_) | Event::Empty(_)),
2547 ) => {
2548 let output = helper.init_start_tag_deserializer(
2549 event,
2550 Some(&super::NS_XS),
2551 b"group",
2552 true,
2553 )?;
2554 match self.handle_group(helper, values, fallback, output)? {
2555 ElementHandlerOutput::Break { event, allow_any } => {
2556 break (event, allow_any)
2557 }
2558 ElementHandlerOutput::Continue { event, .. } => event,
2559 }
2560 }
2561 (
2562 S::AttributeGroup(values, fallback, None),
2563 event @ (Event::Start(_) | Event::Empty(_)),
2564 ) => {
2565 let output = helper.init_start_tag_deserializer(
2566 event,
2567 Some(&super::NS_XS),
2568 b"attributeGroup",
2569 false,
2570 )?;
2571 match self.handle_attribute_group(helper, values, fallback, output)? {
2572 ElementHandlerOutput::Break { event, allow_any } => {
2573 break (event, allow_any)
2574 }
2575 ElementHandlerOutput::Continue { event, .. } => event,
2576 }
2577 }
2578 (
2579 S::Element(values, fallback, None),
2580 event @ (Event::Start(_) | Event::Empty(_)),
2581 ) => {
2582 let output = helper.init_start_tag_deserializer(
2583 event,
2584 Some(&super::NS_XS),
2585 b"element",
2586 true,
2587 )?;
2588 match self.handle_element(helper, values, fallback, output)? {
2589 ElementHandlerOutput::Break { event, allow_any } => {
2590 break (event, allow_any)
2591 }
2592 ElementHandlerOutput::Continue { event, .. } => event,
2593 }
2594 }
2595 (
2596 S::Attribute(values, fallback, None),
2597 event @ (Event::Start(_) | Event::Empty(_)),
2598 ) => {
2599 let output = helper.init_start_tag_deserializer(
2600 event,
2601 Some(&super::NS_XS),
2602 b"attribute",
2603 false,
2604 )?;
2605 match self.handle_attribute(helper, values, fallback, output)? {
2606 ElementHandlerOutput::Break { event, allow_any } => {
2607 break (event, allow_any)
2608 }
2609 ElementHandlerOutput::Continue { event, .. } => event,
2610 }
2611 }
2612 (
2613 S::Notation(values, fallback, None),
2614 event @ (Event::Start(_) | Event::Empty(_)),
2615 ) => {
2616 let output = helper.init_start_tag_deserializer(
2617 event,
2618 Some(&super::NS_XS),
2619 b"notation",
2620 false,
2621 )?;
2622 match self.handle_notation(helper, values, fallback, output)? {
2623 ElementHandlerOutput::Break { event, allow_any } => {
2624 break (event, allow_any)
2625 }
2626 ElementHandlerOutput::Continue { event, .. } => event,
2627 }
2628 }
2629 (state @ S::Done__(_), event) => {
2630 *self.state__ = state;
2631 break (DeserializerEvent::Continue(event), false);
2632 }
2633 (state, event) => {
2634 *self.state__ = state;
2635 break (DeserializerEvent::Continue(event), false);
2636 }
2637 }
2638 };
2639 let artifact = if matches!(&*self.state__, S::Done__(_)) {
2640 DeserializerArtifact::Data(self.finish(helper)?)
2641 } else {
2642 DeserializerArtifact::Deserializer(self)
2643 };
2644 Ok(DeserializerOutput {
2645 artifact,
2646 event,
2647 allow_any,
2648 })
2649 }
2650 fn finish(self, helper: &mut DeserializeHelper) -> Result<super::SchemaContent, Error> {
2651 SchemaContentDeserializer::finish_state(helper, *self.state__)
2652 }
2653 }
2654 #[derive(Debug)]
2655 pub struct IncludeDeserializer {
2656 id: Option<String>,
2657 schema_location: String,
2658 annotation: Option<super::Annotation>,
2659 state__: Box<IncludeDeserializerState>,
2660 }
2661 #[derive(Debug)]
2662 enum IncludeDeserializerState {
2663 Init__,
2664 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
2665 Done__,
2666 Unknown__,
2667 }
2668 impl IncludeDeserializer {
2669 fn from_bytes_start(
2670 helper: &mut DeserializeHelper,
2671 bytes_start: &BytesStart<'_>,
2672 ) -> Result<Box<Self>, Error> {
2673 let mut id: Option<String> = None;
2674 let mut schema_location: Option<String> = None;
2675 for attrib in helper.filter_xmlns_attributes(bytes_start) {
2676 let attrib = attrib?;
2677 if matches!(
2678 helper.resolve_local_name(attrib.key, &super::NS_XS),
2679 Some(b"id")
2680 ) {
2681 helper.read_attrib(&mut id, b"id", &attrib.value)?;
2682 } else if matches!(
2683 helper.resolve_local_name(attrib.key, &super::NS_XS),
2684 Some(b"schemaLocation")
2685 ) {
2686 helper.read_attrib(&mut schema_location, b"schemaLocation", &attrib.value)?;
2687 }
2688 }
2689 Ok(Box::new(Self {
2690 id: id,
2691 schema_location: schema_location
2692 .ok_or_else(|| ErrorKind::MissingAttribute("schemaLocation".into()))?,
2693 annotation: None,
2694 state__: Box::new(IncludeDeserializerState::Init__),
2695 }))
2696 }
2697 fn finish_state(
2698 &mut self,
2699 helper: &mut DeserializeHelper,
2700 state: IncludeDeserializerState,
2701 ) -> Result<(), Error> {
2702 use IncludeDeserializerState as S;
2703 match state {
2704 S::Annotation(Some(deserializer)) => {
2705 self.store_annotation(deserializer.finish(helper)?)?
2706 }
2707 _ => (),
2708 }
2709 Ok(())
2710 }
2711 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
2712 if self.annotation.is_some() {
2713 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
2714 b"annotation",
2715 )))?;
2716 }
2717 self.annotation = Some(value);
2718 Ok(())
2719 }
2720 fn handle_annotation<'de>(
2721 &mut self,
2722 helper: &mut DeserializeHelper,
2723 output: DeserializerOutput<'de, super::Annotation>,
2724 fallback: &mut Option<IncludeDeserializerState>,
2725 ) -> Result<ElementHandlerOutput<'de>, Error> {
2726 use IncludeDeserializerState as S;
2727 let DeserializerOutput {
2728 artifact,
2729 event,
2730 allow_any,
2731 } = output;
2732 if artifact.is_none() {
2733 fallback.get_or_insert(S::Annotation(None));
2734 *self.state__ = S::Done__;
2735 return Ok(ElementHandlerOutput::from_event(event, allow_any));
2736 }
2737 if let Some(fallback) = fallback.take() {
2738 self.finish_state(helper, fallback)?;
2739 }
2740 match artifact {
2741 DeserializerArtifact::None => unreachable!(),
2742 DeserializerArtifact::Data(data) => {
2743 self.store_annotation(data)?;
2744 *self.state__ = S::Done__;
2745 Ok(ElementHandlerOutput::from_event(event, allow_any))
2746 }
2747 DeserializerArtifact::Deserializer(deserializer) => {
2748 fallback.get_or_insert(S::Annotation(Some(deserializer)));
2749 *self.state__ = S::Done__;
2750 Ok(ElementHandlerOutput::from_event(event, allow_any))
2751 }
2752 }
2753 }
2754 }
2755 impl<'de> Deserializer<'de, super::Include> for Box<IncludeDeserializer> {
2756 fn init(
2757 helper: &mut DeserializeHelper,
2758 event: Event<'de>,
2759 ) -> DeserializerResult<'de, super::Include> {
2760 helper.init_deserializer_from_start_event(event, IncludeDeserializer::from_bytes_start)
2761 }
2762 fn next(
2763 mut self,
2764 helper: &mut DeserializeHelper,
2765 event: Event<'de>,
2766 ) -> DeserializerResult<'de, super::Include> {
2767 use IncludeDeserializerState as S;
2768 let mut event = event;
2769 let mut fallback = None;
2770 let mut allow_any_element = false;
2771 let (event, allow_any) = loop {
2772 let state = replace(&mut *self.state__, S::Unknown__);
2773 event = match (state, event) {
2774 (S::Unknown__, _) => unreachable!(),
2775 (S::Annotation(Some(deserializer)), event) => {
2776 let output = deserializer.next(helper, event)?;
2777 match self.handle_annotation(helper, output, &mut fallback)? {
2778 ElementHandlerOutput::Continue { event, allow_any } => {
2779 allow_any_element = allow_any_element || allow_any;
2780 event
2781 }
2782 ElementHandlerOutput::Break { event, allow_any } => {
2783 break (event, allow_any)
2784 }
2785 }
2786 }
2787 (_, Event::End(_)) => {
2788 if let Some(fallback) = fallback.take() {
2789 self.finish_state(helper, fallback)?;
2790 }
2791 return Ok(DeserializerOutput {
2792 artifact: DeserializerArtifact::Data(self.finish(helper)?),
2793 event: DeserializerEvent::None,
2794 allow_any: false,
2795 });
2796 }
2797 (S::Init__, event) => {
2798 fallback.get_or_insert(S::Init__);
2799 *self.state__ = S::Annotation(None);
2800 event
2801 }
2802 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
2803 let output = helper.init_start_tag_deserializer(
2804 event,
2805 Some(&super::NS_XS),
2806 b"annotation",
2807 false,
2808 )?;
2809 match self.handle_annotation(helper, output, &mut fallback)? {
2810 ElementHandlerOutput::Continue { event, allow_any } => {
2811 allow_any_element = allow_any_element || allow_any;
2812 event
2813 }
2814 ElementHandlerOutput::Break { event, allow_any } => {
2815 break (event, allow_any)
2816 }
2817 }
2818 }
2819 (S::Done__, event) => {
2820 *self.state__ = S::Done__;
2821 break (DeserializerEvent::Continue(event), allow_any_element);
2822 }
2823 (state, event) => {
2824 *self.state__ = state;
2825 break (DeserializerEvent::Break(event), false);
2826 }
2827 }
2828 };
2829 if let Some(fallback) = fallback {
2830 *self.state__ = fallback;
2831 }
2832 Ok(DeserializerOutput {
2833 artifact: DeserializerArtifact::Deserializer(self),
2834 event,
2835 allow_any,
2836 })
2837 }
2838 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Include, Error> {
2839 let state = replace(&mut *self.state__, IncludeDeserializerState::Unknown__);
2840 self.finish_state(helper, state)?;
2841 Ok(super::Include {
2842 id: self.id,
2843 schema_location: self.schema_location,
2844 annotation: self.annotation,
2845 })
2846 }
2847 }
2848 #[derive(Debug)]
2849 pub struct ImportDeserializer {
2850 id: Option<String>,
2851 namespace: Option<String>,
2852 schema_location: Option<String>,
2853 annotation: Option<super::Annotation>,
2854 state__: Box<ImportDeserializerState>,
2855 }
2856 #[derive(Debug)]
2857 enum ImportDeserializerState {
2858 Init__,
2859 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
2860 Done__,
2861 Unknown__,
2862 }
2863 impl ImportDeserializer {
2864 fn from_bytes_start(
2865 helper: &mut DeserializeHelper,
2866 bytes_start: &BytesStart<'_>,
2867 ) -> Result<Box<Self>, Error> {
2868 let mut id: Option<String> = None;
2869 let mut namespace: Option<String> = None;
2870 let mut schema_location: Option<String> = None;
2871 for attrib in helper.filter_xmlns_attributes(bytes_start) {
2872 let attrib = attrib?;
2873 if matches!(
2874 helper.resolve_local_name(attrib.key, &super::NS_XS),
2875 Some(b"id")
2876 ) {
2877 helper.read_attrib(&mut id, b"id", &attrib.value)?;
2878 } else if matches!(
2879 helper.resolve_local_name(attrib.key, &super::NS_XS),
2880 Some(b"namespace")
2881 ) {
2882 helper.read_attrib(&mut namespace, b"namespace", &attrib.value)?;
2883 } else if matches!(
2884 helper.resolve_local_name(attrib.key, &super::NS_XS),
2885 Some(b"schemaLocation")
2886 ) {
2887 helper.read_attrib(&mut schema_location, b"schemaLocation", &attrib.value)?;
2888 }
2889 }
2890 Ok(Box::new(Self {
2891 id: id,
2892 namespace: namespace,
2893 schema_location: schema_location,
2894 annotation: None,
2895 state__: Box::new(ImportDeserializerState::Init__),
2896 }))
2897 }
2898 fn finish_state(
2899 &mut self,
2900 helper: &mut DeserializeHelper,
2901 state: ImportDeserializerState,
2902 ) -> Result<(), Error> {
2903 use ImportDeserializerState as S;
2904 match state {
2905 S::Annotation(Some(deserializer)) => {
2906 self.store_annotation(deserializer.finish(helper)?)?
2907 }
2908 _ => (),
2909 }
2910 Ok(())
2911 }
2912 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
2913 if self.annotation.is_some() {
2914 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
2915 b"annotation",
2916 )))?;
2917 }
2918 self.annotation = Some(value);
2919 Ok(())
2920 }
2921 fn handle_annotation<'de>(
2922 &mut self,
2923 helper: &mut DeserializeHelper,
2924 output: DeserializerOutput<'de, super::Annotation>,
2925 fallback: &mut Option<ImportDeserializerState>,
2926 ) -> Result<ElementHandlerOutput<'de>, Error> {
2927 use ImportDeserializerState as S;
2928 let DeserializerOutput {
2929 artifact,
2930 event,
2931 allow_any,
2932 } = output;
2933 if artifact.is_none() {
2934 fallback.get_or_insert(S::Annotation(None));
2935 *self.state__ = S::Done__;
2936 return Ok(ElementHandlerOutput::from_event(event, allow_any));
2937 }
2938 if let Some(fallback) = fallback.take() {
2939 self.finish_state(helper, fallback)?;
2940 }
2941 match artifact {
2942 DeserializerArtifact::None => unreachable!(),
2943 DeserializerArtifact::Data(data) => {
2944 self.store_annotation(data)?;
2945 *self.state__ = S::Done__;
2946 Ok(ElementHandlerOutput::from_event(event, allow_any))
2947 }
2948 DeserializerArtifact::Deserializer(deserializer) => {
2949 fallback.get_or_insert(S::Annotation(Some(deserializer)));
2950 *self.state__ = S::Done__;
2951 Ok(ElementHandlerOutput::from_event(event, allow_any))
2952 }
2953 }
2954 }
2955 }
2956 impl<'de> Deserializer<'de, super::Import> for Box<ImportDeserializer> {
2957 fn init(
2958 helper: &mut DeserializeHelper,
2959 event: Event<'de>,
2960 ) -> DeserializerResult<'de, super::Import> {
2961 helper.init_deserializer_from_start_event(event, ImportDeserializer::from_bytes_start)
2962 }
2963 fn next(
2964 mut self,
2965 helper: &mut DeserializeHelper,
2966 event: Event<'de>,
2967 ) -> DeserializerResult<'de, super::Import> {
2968 use ImportDeserializerState as S;
2969 let mut event = event;
2970 let mut fallback = None;
2971 let mut allow_any_element = false;
2972 let (event, allow_any) = loop {
2973 let state = replace(&mut *self.state__, S::Unknown__);
2974 event = match (state, event) {
2975 (S::Unknown__, _) => unreachable!(),
2976 (S::Annotation(Some(deserializer)), event) => {
2977 let output = deserializer.next(helper, event)?;
2978 match self.handle_annotation(helper, output, &mut fallback)? {
2979 ElementHandlerOutput::Continue { event, allow_any } => {
2980 allow_any_element = allow_any_element || allow_any;
2981 event
2982 }
2983 ElementHandlerOutput::Break { event, allow_any } => {
2984 break (event, allow_any)
2985 }
2986 }
2987 }
2988 (_, Event::End(_)) => {
2989 if let Some(fallback) = fallback.take() {
2990 self.finish_state(helper, fallback)?;
2991 }
2992 return Ok(DeserializerOutput {
2993 artifact: DeserializerArtifact::Data(self.finish(helper)?),
2994 event: DeserializerEvent::None,
2995 allow_any: false,
2996 });
2997 }
2998 (S::Init__, event) => {
2999 fallback.get_or_insert(S::Init__);
3000 *self.state__ = S::Annotation(None);
3001 event
3002 }
3003 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
3004 let output = helper.init_start_tag_deserializer(
3005 event,
3006 Some(&super::NS_XS),
3007 b"annotation",
3008 false,
3009 )?;
3010 match self.handle_annotation(helper, output, &mut fallback)? {
3011 ElementHandlerOutput::Continue { event, allow_any } => {
3012 allow_any_element = allow_any_element || allow_any;
3013 event
3014 }
3015 ElementHandlerOutput::Break { event, allow_any } => {
3016 break (event, allow_any)
3017 }
3018 }
3019 }
3020 (S::Done__, event) => {
3021 *self.state__ = S::Done__;
3022 break (DeserializerEvent::Continue(event), allow_any_element);
3023 }
3024 (state, event) => {
3025 *self.state__ = state;
3026 break (DeserializerEvent::Break(event), false);
3027 }
3028 }
3029 };
3030 if let Some(fallback) = fallback {
3031 *self.state__ = fallback;
3032 }
3033 Ok(DeserializerOutput {
3034 artifact: DeserializerArtifact::Deserializer(self),
3035 event,
3036 allow_any,
3037 })
3038 }
3039 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Import, Error> {
3040 let state = replace(&mut *self.state__, ImportDeserializerState::Unknown__);
3041 self.finish_state(helper, state)?;
3042 Ok(super::Import {
3043 id: self.id,
3044 namespace: self.namespace,
3045 schema_location: self.schema_location,
3046 annotation: self.annotation,
3047 })
3048 }
3049 }
3050 #[derive(Debug)]
3051 pub struct RedefineDeserializer {
3052 schema_location: String,
3053 id: Option<String>,
3054 content: Vec<super::RedefineContent>,
3055 state__: Box<RedefineDeserializerState>,
3056 }
3057 #[derive(Debug)]
3058 enum RedefineDeserializerState {
3059 Init__,
3060 Next__,
3061 Content__(<super::RedefineContent as WithDeserializer>::Deserializer),
3062 Unknown__,
3063 }
3064 impl RedefineDeserializer {
3065 fn from_bytes_start(
3066 helper: &mut DeserializeHelper,
3067 bytes_start: &BytesStart<'_>,
3068 ) -> Result<Box<Self>, Error> {
3069 let mut schema_location: Option<String> = None;
3070 let mut id: Option<String> = None;
3071 for attrib in helper.filter_xmlns_attributes(bytes_start) {
3072 let attrib = attrib?;
3073 if matches!(
3074 helper.resolve_local_name(attrib.key, &super::NS_XS),
3075 Some(b"schemaLocation")
3076 ) {
3077 helper.read_attrib(&mut schema_location, b"schemaLocation", &attrib.value)?;
3078 } else if matches!(
3079 helper.resolve_local_name(attrib.key, &super::NS_XS),
3080 Some(b"id")
3081 ) {
3082 helper.read_attrib(&mut id, b"id", &attrib.value)?;
3083 }
3084 }
3085 Ok(Box::new(Self {
3086 schema_location: schema_location
3087 .ok_or_else(|| ErrorKind::MissingAttribute("schemaLocation".into()))?,
3088 id: id,
3089 content: Vec::new(),
3090 state__: Box::new(RedefineDeserializerState::Init__),
3091 }))
3092 }
3093 fn finish_state(
3094 &mut self,
3095 helper: &mut DeserializeHelper,
3096 state: RedefineDeserializerState,
3097 ) -> Result<(), Error> {
3098 if let RedefineDeserializerState::Content__(deserializer) = state {
3099 self.store_content(deserializer.finish(helper)?)?;
3100 }
3101 Ok(())
3102 }
3103 fn store_content(&mut self, value: super::RedefineContent) -> Result<(), Error> {
3104 self.content.push(value);
3105 Ok(())
3106 }
3107 fn handle_content<'de>(
3108 &mut self,
3109 helper: &mut DeserializeHelper,
3110 output: DeserializerOutput<'de, super::RedefineContent>,
3111 fallback: &mut Option<RedefineDeserializerState>,
3112 ) -> Result<ElementHandlerOutput<'de>, Error> {
3113 use RedefineDeserializerState as S;
3114 let DeserializerOutput {
3115 artifact,
3116 event,
3117 allow_any,
3118 } = output;
3119 if artifact.is_none() {
3120 *self.state__ = fallback.take().unwrap_or(S::Next__);
3121 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
3122 }
3123 if let Some(fallback) = fallback.take() {
3124 self.finish_state(helper, fallback)?;
3125 }
3126 match artifact {
3127 DeserializerArtifact::None => unreachable!(),
3128 DeserializerArtifact::Data(data) => {
3129 self.store_content(data)?;
3130 *self.state__ = S::Next__;
3131 Ok(ElementHandlerOutput::from_event(event, allow_any))
3132 }
3133 DeserializerArtifact::Deserializer(deserializer) => {
3134 *fallback = Some(S::Content__(deserializer));
3135 *self.state__ = S::Next__;
3136 Ok(ElementHandlerOutput::from_event(event, allow_any))
3137 }
3138 }
3139 }
3140 }
3141 impl<'de> Deserializer<'de, super::Redefine> for Box<RedefineDeserializer> {
3142 fn init(
3143 helper: &mut DeserializeHelper,
3144 event: Event<'de>,
3145 ) -> DeserializerResult<'de, super::Redefine> {
3146 helper.init_deserializer_from_start_event(event, RedefineDeserializer::from_bytes_start)
3147 }
3148 fn next(
3149 mut self,
3150 helper: &mut DeserializeHelper,
3151 event: Event<'de>,
3152 ) -> DeserializerResult<'de, super::Redefine> {
3153 use RedefineDeserializerState as S;
3154 let mut event = event;
3155 let mut fallback = None;
3156 let (event, allow_any) = loop {
3157 let state = replace(&mut *self.state__, S::Unknown__);
3158 event = match (state, event) {
3159 (S::Unknown__, _) => unreachable!(),
3160 (S::Content__(deserializer), event) => {
3161 let output = deserializer.next(helper, event)?;
3162 match self.handle_content(helper, output, &mut fallback)? {
3163 ElementHandlerOutput::Break { event, allow_any } => {
3164 break (event, allow_any)
3165 }
3166 ElementHandlerOutput::Continue { event, .. } => event,
3167 }
3168 }
3169 (_, Event::End(_)) => {
3170 return Ok(DeserializerOutput {
3171 artifact: DeserializerArtifact::Data(self.finish(helper)?),
3172 event: DeserializerEvent::None,
3173 allow_any: false,
3174 });
3175 }
3176 (state @ (S::Init__ | S::Next__), event) => {
3177 fallback.get_or_insert(state);
3178 let output =
3179 <super::RedefineContent as WithDeserializer>::init(helper, event)?;
3180 match self.handle_content(helper, output, &mut fallback)? {
3181 ElementHandlerOutput::Break { event, allow_any } => {
3182 break (event, allow_any)
3183 }
3184 ElementHandlerOutput::Continue { event, .. } => event,
3185 }
3186 }
3187 }
3188 };
3189 if let Some(fallback) = fallback {
3190 *self.state__ = fallback;
3191 }
3192 let artifact = DeserializerArtifact::Deserializer(self);
3193 Ok(DeserializerOutput {
3194 artifact,
3195 event,
3196 allow_any,
3197 })
3198 }
3199 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Redefine, Error> {
3200 let state = replace(&mut *self.state__, RedefineDeserializerState::Unknown__);
3201 self.finish_state(helper, state)?;
3202 Ok(super::Redefine {
3203 schema_location: self.schema_location,
3204 id: self.id,
3205 content: helper.finish_vec(0usize, None, self.content)?,
3206 })
3207 }
3208 }
3209 #[derive(Debug)]
3210 pub struct RedefineContentDeserializer {
3211 state__: Box<RedefineContentDeserializerState>,
3212 }
3213 #[derive(Debug)]
3214 pub enum RedefineContentDeserializerState {
3215 Init__,
3216 Annotation(
3217 Option<super::Annotation>,
3218 Option<<super::Annotation as WithDeserializer>::Deserializer>,
3219 Option<<super::Annotation as WithDeserializer>::Deserializer>,
3220 ),
3221 SimpleType(
3222 Option<super::SimpleBaseType>,
3223 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
3224 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
3225 ),
3226 ComplexType(
3227 Option<super::ComplexBaseType>,
3228 Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
3229 Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
3230 ),
3231 Group(
3232 Option<super::GroupType>,
3233 Option<<super::GroupType as WithDeserializer>::Deserializer>,
3234 Option<<super::GroupType as WithDeserializer>::Deserializer>,
3235 ),
3236 AttributeGroup(
3237 Option<super::AttributeGroupType>,
3238 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
3239 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
3240 ),
3241 Done__(super::RedefineContent),
3242 Unknown__,
3243 }
3244 impl RedefineContentDeserializer {
3245 fn find_suitable<'de>(
3246 &mut self,
3247 helper: &mut DeserializeHelper,
3248 event: Event<'de>,
3249 ) -> Result<ElementHandlerOutput<'de>, Error> {
3250 if let Event::Start(x) | Event::Empty(x) = &event {
3251 if matches!(
3252 helper.resolve_local_name(x.name(), &super::NS_XS),
3253 Some(b"annotation")
3254 ) {
3255 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
3256 return self.handle_annotation(helper, Default::default(), None, output);
3257 }
3258 if matches!(
3259 helper.resolve_local_name(x.name(), &super::NS_XS),
3260 Some(b"simpleType")
3261 ) {
3262 let output = <super::SimpleBaseType as WithDeserializer>::init(helper, event)?;
3263 return self.handle_simple_type(helper, Default::default(), None, output);
3264 }
3265 if matches!(
3266 helper.resolve_local_name(x.name(), &super::NS_XS),
3267 Some(b"complexType")
3268 ) {
3269 let output = <super::ComplexBaseType as WithDeserializer>::init(helper, event)?;
3270 return self.handle_complex_type(helper, Default::default(), None, output);
3271 }
3272 if matches!(
3273 helper.resolve_local_name(x.name(), &super::NS_XS),
3274 Some(b"group")
3275 ) {
3276 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
3277 return self.handle_group(helper, Default::default(), None, output);
3278 }
3279 if matches!(
3280 helper.resolve_local_name(x.name(), &super::NS_XS),
3281 Some(b"attributeGroup")
3282 ) {
3283 let output =
3284 <super::AttributeGroupType as WithDeserializer>::init(helper, event)?;
3285 return self.handle_attribute_group(helper, Default::default(), None, output);
3286 }
3287 }
3288 *self.state__ = RedefineContentDeserializerState::Init__;
3289 Ok(ElementHandlerOutput::return_to_parent(event, false))
3290 }
3291 fn finish_state(
3292 helper: &mut DeserializeHelper,
3293 state: RedefineContentDeserializerState,
3294 ) -> Result<super::RedefineContent, Error> {
3295 use RedefineContentDeserializerState as S;
3296 match state {
3297 S::Init__ => Err(ErrorKind::MissingContent.into()),
3298 S::Annotation(mut values, None, deserializer) => {
3299 if let Some(deserializer) = deserializer {
3300 let value = deserializer.finish(helper)?;
3301 RedefineContentDeserializer::store_annotation(&mut values, value)?;
3302 }
3303 Ok(super::RedefineContent::Annotation(
3304 helper.finish_element("annotation", values)?,
3305 ))
3306 }
3307 S::SimpleType(mut values, None, deserializer) => {
3308 if let Some(deserializer) = deserializer {
3309 let value = deserializer.finish(helper)?;
3310 RedefineContentDeserializer::store_simple_type(&mut values, value)?;
3311 }
3312 Ok(super::RedefineContent::SimpleType(
3313 helper.finish_element("simpleType", values)?,
3314 ))
3315 }
3316 S::ComplexType(mut values, None, deserializer) => {
3317 if let Some(deserializer) = deserializer {
3318 let value = deserializer.finish(helper)?;
3319 RedefineContentDeserializer::store_complex_type(&mut values, value)?;
3320 }
3321 Ok(super::RedefineContent::ComplexType(
3322 helper.finish_element("complexType", values)?,
3323 ))
3324 }
3325 S::Group(mut values, None, deserializer) => {
3326 if let Some(deserializer) = deserializer {
3327 let value = deserializer.finish(helper)?;
3328 RedefineContentDeserializer::store_group(&mut values, value)?;
3329 }
3330 Ok(super::RedefineContent::Group(
3331 helper.finish_element("group", values)?,
3332 ))
3333 }
3334 S::AttributeGroup(mut values, None, deserializer) => {
3335 if let Some(deserializer) = deserializer {
3336 let value = deserializer.finish(helper)?;
3337 RedefineContentDeserializer::store_attribute_group(&mut values, value)?;
3338 }
3339 Ok(super::RedefineContent::AttributeGroup(
3340 helper.finish_element("attributeGroup", values)?,
3341 ))
3342 }
3343 S::Done__(data) => Ok(data),
3344 _ => unreachable!(),
3345 }
3346 }
3347 fn store_annotation(
3348 values: &mut Option<super::Annotation>,
3349 value: super::Annotation,
3350 ) -> Result<(), Error> {
3351 if values.is_some() {
3352 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
3353 b"annotation",
3354 )))?;
3355 }
3356 *values = Some(value);
3357 Ok(())
3358 }
3359 fn store_simple_type(
3360 values: &mut Option<super::SimpleBaseType>,
3361 value: super::SimpleBaseType,
3362 ) -> Result<(), Error> {
3363 if values.is_some() {
3364 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
3365 b"simpleType",
3366 )))?;
3367 }
3368 *values = Some(value);
3369 Ok(())
3370 }
3371 fn store_complex_type(
3372 values: &mut Option<super::ComplexBaseType>,
3373 value: super::ComplexBaseType,
3374 ) -> Result<(), Error> {
3375 if values.is_some() {
3376 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
3377 b"complexType",
3378 )))?;
3379 }
3380 *values = Some(value);
3381 Ok(())
3382 }
3383 fn store_group(
3384 values: &mut Option<super::GroupType>,
3385 value: super::GroupType,
3386 ) -> Result<(), Error> {
3387 if values.is_some() {
3388 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
3389 b"group",
3390 )))?;
3391 }
3392 *values = Some(value);
3393 Ok(())
3394 }
3395 fn store_attribute_group(
3396 values: &mut Option<super::AttributeGroupType>,
3397 value: super::AttributeGroupType,
3398 ) -> Result<(), Error> {
3399 if values.is_some() {
3400 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
3401 b"attributeGroup",
3402 )))?;
3403 }
3404 *values = Some(value);
3405 Ok(())
3406 }
3407 fn handle_annotation<'de>(
3408 &mut self,
3409 helper: &mut DeserializeHelper,
3410 mut values: Option<super::Annotation>,
3411 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
3412 output: DeserializerOutput<'de, super::Annotation>,
3413 ) -> Result<ElementHandlerOutput<'de>, Error> {
3414 use RedefineContentDeserializerState as S;
3415 let DeserializerOutput {
3416 artifact,
3417 event,
3418 allow_any,
3419 } = output;
3420 if artifact.is_none() {
3421 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
3422 }
3423 if let Some(deserializer) = fallback {
3424 let data = deserializer.finish(helper)?;
3425 RedefineContentDeserializer::store_annotation(&mut values, data)?;
3426 }
3427 match artifact {
3428 DeserializerArtifact::None => unreachable!(),
3429 DeserializerArtifact::Data(data) => {
3430 RedefineContentDeserializer::store_annotation(&mut values, data)?;
3431 let data = RedefineContentDeserializer::finish_state(
3432 helper,
3433 S::Annotation(values, None, None),
3434 )?;
3435 *self.state__ = S::Done__(data);
3436 Ok(ElementHandlerOutput::break_(event, allow_any))
3437 }
3438 DeserializerArtifact::Deserializer(deserializer) => {
3439 *self.state__ = S::Annotation(values, None, Some(deserializer));
3440 Ok(ElementHandlerOutput::break_(event, allow_any))
3441 }
3442 }
3443 }
3444 fn handle_simple_type<'de>(
3445 &mut self,
3446 helper: &mut DeserializeHelper,
3447 mut values: Option<super::SimpleBaseType>,
3448 fallback: Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
3449 output: DeserializerOutput<'de, super::SimpleBaseType>,
3450 ) -> Result<ElementHandlerOutput<'de>, Error> {
3451 use RedefineContentDeserializerState as S;
3452 let DeserializerOutput {
3453 artifact,
3454 event,
3455 allow_any,
3456 } = output;
3457 if artifact.is_none() {
3458 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
3459 }
3460 if let Some(deserializer) = fallback {
3461 let data = deserializer.finish(helper)?;
3462 RedefineContentDeserializer::store_simple_type(&mut values, data)?;
3463 }
3464 match artifact {
3465 DeserializerArtifact::None => unreachable!(),
3466 DeserializerArtifact::Data(data) => {
3467 RedefineContentDeserializer::store_simple_type(&mut values, data)?;
3468 let data = RedefineContentDeserializer::finish_state(
3469 helper,
3470 S::SimpleType(values, None, None),
3471 )?;
3472 *self.state__ = S::Done__(data);
3473 Ok(ElementHandlerOutput::break_(event, allow_any))
3474 }
3475 DeserializerArtifact::Deserializer(deserializer) => {
3476 *self.state__ = S::SimpleType(values, None, Some(deserializer));
3477 Ok(ElementHandlerOutput::break_(event, allow_any))
3478 }
3479 }
3480 }
3481 fn handle_complex_type<'de>(
3482 &mut self,
3483 helper: &mut DeserializeHelper,
3484 mut values: Option<super::ComplexBaseType>,
3485 fallback: Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
3486 output: DeserializerOutput<'de, super::ComplexBaseType>,
3487 ) -> Result<ElementHandlerOutput<'de>, Error> {
3488 use RedefineContentDeserializerState as S;
3489 let DeserializerOutput {
3490 artifact,
3491 event,
3492 allow_any,
3493 } = output;
3494 if artifact.is_none() {
3495 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
3496 }
3497 if let Some(deserializer) = fallback {
3498 let data = deserializer.finish(helper)?;
3499 RedefineContentDeserializer::store_complex_type(&mut values, data)?;
3500 }
3501 match artifact {
3502 DeserializerArtifact::None => unreachable!(),
3503 DeserializerArtifact::Data(data) => {
3504 RedefineContentDeserializer::store_complex_type(&mut values, data)?;
3505 let data = RedefineContentDeserializer::finish_state(
3506 helper,
3507 S::ComplexType(values, None, None),
3508 )?;
3509 *self.state__ = S::Done__(data);
3510 Ok(ElementHandlerOutput::break_(event, allow_any))
3511 }
3512 DeserializerArtifact::Deserializer(deserializer) => {
3513 *self.state__ = S::ComplexType(values, None, Some(deserializer));
3514 Ok(ElementHandlerOutput::break_(event, allow_any))
3515 }
3516 }
3517 }
3518 fn handle_group<'de>(
3519 &mut self,
3520 helper: &mut DeserializeHelper,
3521 mut values: Option<super::GroupType>,
3522 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
3523 output: DeserializerOutput<'de, super::GroupType>,
3524 ) -> Result<ElementHandlerOutput<'de>, Error> {
3525 use RedefineContentDeserializerState as S;
3526 let DeserializerOutput {
3527 artifact,
3528 event,
3529 allow_any,
3530 } = output;
3531 if artifact.is_none() {
3532 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
3533 }
3534 if let Some(deserializer) = fallback {
3535 let data = deserializer.finish(helper)?;
3536 RedefineContentDeserializer::store_group(&mut values, data)?;
3537 }
3538 match artifact {
3539 DeserializerArtifact::None => unreachable!(),
3540 DeserializerArtifact::Data(data) => {
3541 RedefineContentDeserializer::store_group(&mut values, data)?;
3542 let data = RedefineContentDeserializer::finish_state(
3543 helper,
3544 S::Group(values, None, None),
3545 )?;
3546 *self.state__ = S::Done__(data);
3547 Ok(ElementHandlerOutput::break_(event, allow_any))
3548 }
3549 DeserializerArtifact::Deserializer(deserializer) => {
3550 *self.state__ = S::Group(values, None, Some(deserializer));
3551 Ok(ElementHandlerOutput::break_(event, allow_any))
3552 }
3553 }
3554 }
3555 fn handle_attribute_group<'de>(
3556 &mut self,
3557 helper: &mut DeserializeHelper,
3558 mut values: Option<super::AttributeGroupType>,
3559 fallback: Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
3560 output: DeserializerOutput<'de, super::AttributeGroupType>,
3561 ) -> Result<ElementHandlerOutput<'de>, Error> {
3562 use RedefineContentDeserializerState as S;
3563 let DeserializerOutput {
3564 artifact,
3565 event,
3566 allow_any,
3567 } = output;
3568 if artifact.is_none() {
3569 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
3570 }
3571 if let Some(deserializer) = fallback {
3572 let data = deserializer.finish(helper)?;
3573 RedefineContentDeserializer::store_attribute_group(&mut values, data)?;
3574 }
3575 match artifact {
3576 DeserializerArtifact::None => unreachable!(),
3577 DeserializerArtifact::Data(data) => {
3578 RedefineContentDeserializer::store_attribute_group(&mut values, data)?;
3579 let data = RedefineContentDeserializer::finish_state(
3580 helper,
3581 S::AttributeGroup(values, None, None),
3582 )?;
3583 *self.state__ = S::Done__(data);
3584 Ok(ElementHandlerOutput::break_(event, allow_any))
3585 }
3586 DeserializerArtifact::Deserializer(deserializer) => {
3587 *self.state__ = S::AttributeGroup(values, None, Some(deserializer));
3588 Ok(ElementHandlerOutput::break_(event, allow_any))
3589 }
3590 }
3591 }
3592 }
3593 impl<'de> Deserializer<'de, super::RedefineContent> for Box<RedefineContentDeserializer> {
3594 fn init(
3595 helper: &mut DeserializeHelper,
3596 event: Event<'de>,
3597 ) -> DeserializerResult<'de, super::RedefineContent> {
3598 let deserializer = Box::new(RedefineContentDeserializer {
3599 state__: Box::new(RedefineContentDeserializerState::Init__),
3600 });
3601 let mut output = deserializer.next(helper, event)?;
3602 output.artifact = match output.artifact {
3603 DeserializerArtifact::Deserializer(x)
3604 if matches!(&*x.state__, RedefineContentDeserializerState::Init__) =>
3605 {
3606 DeserializerArtifact::None
3607 }
3608 artifact => artifact,
3609 };
3610 Ok(output)
3611 }
3612 fn next(
3613 mut self,
3614 helper: &mut DeserializeHelper,
3615 event: Event<'de>,
3616 ) -> DeserializerResult<'de, super::RedefineContent> {
3617 use RedefineContentDeserializerState as S;
3618 let mut event = event;
3619 let (event, allow_any) = loop {
3620 let state = replace(&mut *self.state__, S::Unknown__);
3621 event = match (state, event) {
3622 (S::Unknown__, _) => unreachable!(),
3623 (S::Annotation(values, fallback, Some(deserializer)), event) => {
3624 let output = deserializer.next(helper, event)?;
3625 match self.handle_annotation(helper, values, fallback, output)? {
3626 ElementHandlerOutput::Break { event, allow_any } => {
3627 break (event, allow_any)
3628 }
3629 ElementHandlerOutput::Continue { event, .. } => event,
3630 }
3631 }
3632 (S::SimpleType(values, fallback, Some(deserializer)), event) => {
3633 let output = deserializer.next(helper, event)?;
3634 match self.handle_simple_type(helper, values, fallback, output)? {
3635 ElementHandlerOutput::Break { event, allow_any } => {
3636 break (event, allow_any)
3637 }
3638 ElementHandlerOutput::Continue { event, .. } => event,
3639 }
3640 }
3641 (S::ComplexType(values, fallback, Some(deserializer)), event) => {
3642 let output = deserializer.next(helper, event)?;
3643 match self.handle_complex_type(helper, values, fallback, output)? {
3644 ElementHandlerOutput::Break { event, allow_any } => {
3645 break (event, allow_any)
3646 }
3647 ElementHandlerOutput::Continue { event, .. } => event,
3648 }
3649 }
3650 (S::Group(values, fallback, Some(deserializer)), event) => {
3651 let output = deserializer.next(helper, event)?;
3652 match self.handle_group(helper, values, fallback, output)? {
3653 ElementHandlerOutput::Break { event, allow_any } => {
3654 break (event, allow_any)
3655 }
3656 ElementHandlerOutput::Continue { event, .. } => event,
3657 }
3658 }
3659 (S::AttributeGroup(values, fallback, Some(deserializer)), event) => {
3660 let output = deserializer.next(helper, event)?;
3661 match self.handle_attribute_group(helper, values, fallback, output)? {
3662 ElementHandlerOutput::Break { event, allow_any } => {
3663 break (event, allow_any)
3664 }
3665 ElementHandlerOutput::Continue { event, .. } => event,
3666 }
3667 }
3668 (state, event @ Event::End(_)) => {
3669 return Ok(DeserializerOutput {
3670 artifact: DeserializerArtifact::Data(
3671 RedefineContentDeserializer::finish_state(helper, state)?,
3672 ),
3673 event: DeserializerEvent::Continue(event),
3674 allow_any: false,
3675 });
3676 }
3677 (S::Init__, event) => match self.find_suitable(helper, event)? {
3678 ElementHandlerOutput::Break { event, allow_any } => {
3679 break (event, allow_any)
3680 }
3681 ElementHandlerOutput::Continue { event, .. } => event,
3682 },
3683 (
3684 S::Annotation(values, fallback, None),
3685 event @ (Event::Start(_) | Event::Empty(_)),
3686 ) => {
3687 let output = helper.init_start_tag_deserializer(
3688 event,
3689 Some(&super::NS_XS),
3690 b"annotation",
3691 false,
3692 )?;
3693 match self.handle_annotation(helper, values, fallback, output)? {
3694 ElementHandlerOutput::Break { event, allow_any } => {
3695 break (event, allow_any)
3696 }
3697 ElementHandlerOutput::Continue { event, .. } => event,
3698 }
3699 }
3700 (
3701 S::SimpleType(values, fallback, None),
3702 event @ (Event::Start(_) | Event::Empty(_)),
3703 ) => {
3704 let output = helper.init_start_tag_deserializer(
3705 event,
3706 Some(&super::NS_XS),
3707 b"simpleType",
3708 true,
3709 )?;
3710 match self.handle_simple_type(helper, values, fallback, output)? {
3711 ElementHandlerOutput::Break { event, allow_any } => {
3712 break (event, allow_any)
3713 }
3714 ElementHandlerOutput::Continue { event, .. } => event,
3715 }
3716 }
3717 (
3718 S::ComplexType(values, fallback, None),
3719 event @ (Event::Start(_) | Event::Empty(_)),
3720 ) => {
3721 let output = helper.init_start_tag_deserializer(
3722 event,
3723 Some(&super::NS_XS),
3724 b"complexType",
3725 true,
3726 )?;
3727 match self.handle_complex_type(helper, values, fallback, output)? {
3728 ElementHandlerOutput::Break { event, allow_any } => {
3729 break (event, allow_any)
3730 }
3731 ElementHandlerOutput::Continue { event, .. } => event,
3732 }
3733 }
3734 (
3735 S::Group(values, fallback, None),
3736 event @ (Event::Start(_) | Event::Empty(_)),
3737 ) => {
3738 let output = helper.init_start_tag_deserializer(
3739 event,
3740 Some(&super::NS_XS),
3741 b"group",
3742 true,
3743 )?;
3744 match self.handle_group(helper, values, fallback, output)? {
3745 ElementHandlerOutput::Break { event, allow_any } => {
3746 break (event, allow_any)
3747 }
3748 ElementHandlerOutput::Continue { event, .. } => event,
3749 }
3750 }
3751 (
3752 S::AttributeGroup(values, fallback, None),
3753 event @ (Event::Start(_) | Event::Empty(_)),
3754 ) => {
3755 let output = helper.init_start_tag_deserializer(
3756 event,
3757 Some(&super::NS_XS),
3758 b"attributeGroup",
3759 false,
3760 )?;
3761 match self.handle_attribute_group(helper, values, fallback, output)? {
3762 ElementHandlerOutput::Break { event, allow_any } => {
3763 break (event, allow_any)
3764 }
3765 ElementHandlerOutput::Continue { event, .. } => event,
3766 }
3767 }
3768 (state @ S::Done__(_), event) => {
3769 *self.state__ = state;
3770 break (DeserializerEvent::Continue(event), false);
3771 }
3772 (state, event) => {
3773 *self.state__ = state;
3774 break (DeserializerEvent::Continue(event), false);
3775 }
3776 }
3777 };
3778 let artifact = if matches!(&*self.state__, S::Done__(_)) {
3779 DeserializerArtifact::Data(self.finish(helper)?)
3780 } else {
3781 DeserializerArtifact::Deserializer(self)
3782 };
3783 Ok(DeserializerOutput {
3784 artifact,
3785 event,
3786 allow_any,
3787 })
3788 }
3789 fn finish(self, helper: &mut DeserializeHelper) -> Result<super::RedefineContent, Error> {
3790 RedefineContentDeserializer::finish_state(helper, *self.state__)
3791 }
3792 }
3793 #[derive(Debug)]
3794 pub struct OverrideDeserializer {
3795 schema_location: String,
3796 id: Option<String>,
3797 content: Vec<super::OverrideContent>,
3798 state__: Box<OverrideDeserializerState>,
3799 }
3800 #[derive(Debug)]
3801 enum OverrideDeserializerState {
3802 Init__,
3803 Next__,
3804 Content__(<super::OverrideContent as WithDeserializer>::Deserializer),
3805 Unknown__,
3806 }
3807 impl OverrideDeserializer {
3808 fn from_bytes_start(
3809 helper: &mut DeserializeHelper,
3810 bytes_start: &BytesStart<'_>,
3811 ) -> Result<Box<Self>, Error> {
3812 let mut schema_location: Option<String> = None;
3813 let mut id: Option<String> = None;
3814 for attrib in helper.filter_xmlns_attributes(bytes_start) {
3815 let attrib = attrib?;
3816 if matches!(
3817 helper.resolve_local_name(attrib.key, &super::NS_XS),
3818 Some(b"schemaLocation")
3819 ) {
3820 helper.read_attrib(&mut schema_location, b"schemaLocation", &attrib.value)?;
3821 } else if matches!(
3822 helper.resolve_local_name(attrib.key, &super::NS_XS),
3823 Some(b"id")
3824 ) {
3825 helper.read_attrib(&mut id, b"id", &attrib.value)?;
3826 }
3827 }
3828 Ok(Box::new(Self {
3829 schema_location: schema_location
3830 .ok_or_else(|| ErrorKind::MissingAttribute("schemaLocation".into()))?,
3831 id: id,
3832 content: Vec::new(),
3833 state__: Box::new(OverrideDeserializerState::Init__),
3834 }))
3835 }
3836 fn finish_state(
3837 &mut self,
3838 helper: &mut DeserializeHelper,
3839 state: OverrideDeserializerState,
3840 ) -> Result<(), Error> {
3841 if let OverrideDeserializerState::Content__(deserializer) = state {
3842 self.store_content(deserializer.finish(helper)?)?;
3843 }
3844 Ok(())
3845 }
3846 fn store_content(&mut self, value: super::OverrideContent) -> Result<(), Error> {
3847 self.content.push(value);
3848 Ok(())
3849 }
3850 fn handle_content<'de>(
3851 &mut self,
3852 helper: &mut DeserializeHelper,
3853 output: DeserializerOutput<'de, super::OverrideContent>,
3854 fallback: &mut Option<OverrideDeserializerState>,
3855 ) -> Result<ElementHandlerOutput<'de>, Error> {
3856 use OverrideDeserializerState as S;
3857 let DeserializerOutput {
3858 artifact,
3859 event,
3860 allow_any,
3861 } = output;
3862 if artifact.is_none() {
3863 *self.state__ = fallback.take().unwrap_or(S::Next__);
3864 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
3865 }
3866 if let Some(fallback) = fallback.take() {
3867 self.finish_state(helper, fallback)?;
3868 }
3869 match artifact {
3870 DeserializerArtifact::None => unreachable!(),
3871 DeserializerArtifact::Data(data) => {
3872 self.store_content(data)?;
3873 *self.state__ = S::Next__;
3874 Ok(ElementHandlerOutput::from_event(event, allow_any))
3875 }
3876 DeserializerArtifact::Deserializer(deserializer) => {
3877 *fallback = Some(S::Content__(deserializer));
3878 *self.state__ = S::Next__;
3879 Ok(ElementHandlerOutput::from_event(event, allow_any))
3880 }
3881 }
3882 }
3883 }
3884 impl<'de> Deserializer<'de, super::Override> for Box<OverrideDeserializer> {
3885 fn init(
3886 helper: &mut DeserializeHelper,
3887 event: Event<'de>,
3888 ) -> DeserializerResult<'de, super::Override> {
3889 helper.init_deserializer_from_start_event(event, OverrideDeserializer::from_bytes_start)
3890 }
3891 fn next(
3892 mut self,
3893 helper: &mut DeserializeHelper,
3894 event: Event<'de>,
3895 ) -> DeserializerResult<'de, super::Override> {
3896 use OverrideDeserializerState as S;
3897 let mut event = event;
3898 let mut fallback = None;
3899 let (event, allow_any) = loop {
3900 let state = replace(&mut *self.state__, S::Unknown__);
3901 event = match (state, event) {
3902 (S::Unknown__, _) => unreachable!(),
3903 (S::Content__(deserializer), event) => {
3904 let output = deserializer.next(helper, event)?;
3905 match self.handle_content(helper, output, &mut fallback)? {
3906 ElementHandlerOutput::Break { event, allow_any } => {
3907 break (event, allow_any)
3908 }
3909 ElementHandlerOutput::Continue { event, .. } => event,
3910 }
3911 }
3912 (_, Event::End(_)) => {
3913 return Ok(DeserializerOutput {
3914 artifact: DeserializerArtifact::Data(self.finish(helper)?),
3915 event: DeserializerEvent::None,
3916 allow_any: false,
3917 });
3918 }
3919 (state @ (S::Init__ | S::Next__), event) => {
3920 fallback.get_or_insert(state);
3921 let output =
3922 <super::OverrideContent as WithDeserializer>::init(helper, event)?;
3923 match self.handle_content(helper, output, &mut fallback)? {
3924 ElementHandlerOutput::Break { event, allow_any } => {
3925 break (event, allow_any)
3926 }
3927 ElementHandlerOutput::Continue { event, .. } => event,
3928 }
3929 }
3930 }
3931 };
3932 if let Some(fallback) = fallback {
3933 *self.state__ = fallback;
3934 }
3935 let artifact = DeserializerArtifact::Deserializer(self);
3936 Ok(DeserializerOutput {
3937 artifact,
3938 event,
3939 allow_any,
3940 })
3941 }
3942 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Override, Error> {
3943 let state = replace(&mut *self.state__, OverrideDeserializerState::Unknown__);
3944 self.finish_state(helper, state)?;
3945 Ok(super::Override {
3946 schema_location: self.schema_location,
3947 id: self.id,
3948 content: helper.finish_vec(0usize, None, self.content)?,
3949 })
3950 }
3951 }
3952 #[derive(Debug)]
3953 pub struct OverrideContentDeserializer {
3954 state__: Box<OverrideContentDeserializerState>,
3955 }
3956 #[derive(Debug)]
3957 pub enum OverrideContentDeserializerState {
3958 Init__,
3959 Annotation(
3960 Option<super::Annotation>,
3961 Option<<super::Annotation as WithDeserializer>::Deserializer>,
3962 Option<<super::Annotation as WithDeserializer>::Deserializer>,
3963 ),
3964 SimpleType(
3965 Option<super::SimpleBaseType>,
3966 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
3967 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
3968 ),
3969 ComplexType(
3970 Option<super::ComplexBaseType>,
3971 Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
3972 Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
3973 ),
3974 Group(
3975 Option<super::GroupType>,
3976 Option<<super::GroupType as WithDeserializer>::Deserializer>,
3977 Option<<super::GroupType as WithDeserializer>::Deserializer>,
3978 ),
3979 AttributeGroup(
3980 Option<super::AttributeGroupType>,
3981 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
3982 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
3983 ),
3984 Element(
3985 Option<super::ElementType>,
3986 Option<<super::ElementType as WithDeserializer>::Deserializer>,
3987 Option<<super::ElementType as WithDeserializer>::Deserializer>,
3988 ),
3989 Attribute(
3990 Option<super::AttributeType>,
3991 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
3992 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
3993 ),
3994 Notation(
3995 Option<super::Notation>,
3996 Option<<super::Notation as WithDeserializer>::Deserializer>,
3997 Option<<super::Notation as WithDeserializer>::Deserializer>,
3998 ),
3999 Done__(super::OverrideContent),
4000 Unknown__,
4001 }
4002 impl OverrideContentDeserializer {
4003 fn find_suitable<'de>(
4004 &mut self,
4005 helper: &mut DeserializeHelper,
4006 event: Event<'de>,
4007 ) -> Result<ElementHandlerOutput<'de>, Error> {
4008 if let Event::Start(x) | Event::Empty(x) = &event {
4009 if matches!(
4010 helper.resolve_local_name(x.name(), &super::NS_XS),
4011 Some(b"annotation")
4012 ) {
4013 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
4014 return self.handle_annotation(helper, Default::default(), None, output);
4015 }
4016 if matches!(
4017 helper.resolve_local_name(x.name(), &super::NS_XS),
4018 Some(b"simpleType")
4019 ) {
4020 let output = <super::SimpleBaseType as WithDeserializer>::init(helper, event)?;
4021 return self.handle_simple_type(helper, Default::default(), None, output);
4022 }
4023 if matches!(
4024 helper.resolve_local_name(x.name(), &super::NS_XS),
4025 Some(b"complexType")
4026 ) {
4027 let output = <super::ComplexBaseType as WithDeserializer>::init(helper, event)?;
4028 return self.handle_complex_type(helper, Default::default(), None, output);
4029 }
4030 if matches!(
4031 helper.resolve_local_name(x.name(), &super::NS_XS),
4032 Some(b"group")
4033 ) {
4034 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
4035 return self.handle_group(helper, Default::default(), None, output);
4036 }
4037 if matches!(
4038 helper.resolve_local_name(x.name(), &super::NS_XS),
4039 Some(b"attributeGroup")
4040 ) {
4041 let output =
4042 <super::AttributeGroupType as WithDeserializer>::init(helper, event)?;
4043 return self.handle_attribute_group(helper, Default::default(), None, output);
4044 }
4045 if matches!(
4046 helper.resolve_local_name(x.name(), &super::NS_XS),
4047 Some(b"element")
4048 ) {
4049 let output = <super::ElementType as WithDeserializer>::init(helper, event)?;
4050 return self.handle_element(helper, Default::default(), None, output);
4051 }
4052 if matches!(
4053 helper.resolve_local_name(x.name(), &super::NS_XS),
4054 Some(b"attribute")
4055 ) {
4056 let output = <super::AttributeType as WithDeserializer>::init(helper, event)?;
4057 return self.handle_attribute(helper, Default::default(), None, output);
4058 }
4059 if matches!(
4060 helper.resolve_local_name(x.name(), &super::NS_XS),
4061 Some(b"notation")
4062 ) {
4063 let output = <super::Notation as WithDeserializer>::init(helper, event)?;
4064 return self.handle_notation(helper, Default::default(), None, output);
4065 }
4066 }
4067 *self.state__ = OverrideContentDeserializerState::Init__;
4068 Ok(ElementHandlerOutput::return_to_parent(event, false))
4069 }
4070 fn finish_state(
4071 helper: &mut DeserializeHelper,
4072 state: OverrideContentDeserializerState,
4073 ) -> Result<super::OverrideContent, Error> {
4074 use OverrideContentDeserializerState as S;
4075 match state {
4076 S::Init__ => Err(ErrorKind::MissingContent.into()),
4077 S::Annotation(mut values, None, deserializer) => {
4078 if let Some(deserializer) = deserializer {
4079 let value = deserializer.finish(helper)?;
4080 OverrideContentDeserializer::store_annotation(&mut values, value)?;
4081 }
4082 Ok(super::OverrideContent::Annotation(
4083 helper.finish_element("annotation", values)?,
4084 ))
4085 }
4086 S::SimpleType(mut values, None, deserializer) => {
4087 if let Some(deserializer) = deserializer {
4088 let value = deserializer.finish(helper)?;
4089 OverrideContentDeserializer::store_simple_type(&mut values, value)?;
4090 }
4091 Ok(super::OverrideContent::SimpleType(
4092 helper.finish_element("simpleType", values)?,
4093 ))
4094 }
4095 S::ComplexType(mut values, None, deserializer) => {
4096 if let Some(deserializer) = deserializer {
4097 let value = deserializer.finish(helper)?;
4098 OverrideContentDeserializer::store_complex_type(&mut values, value)?;
4099 }
4100 Ok(super::OverrideContent::ComplexType(
4101 helper.finish_element("complexType", values)?,
4102 ))
4103 }
4104 S::Group(mut values, None, deserializer) => {
4105 if let Some(deserializer) = deserializer {
4106 let value = deserializer.finish(helper)?;
4107 OverrideContentDeserializer::store_group(&mut values, value)?;
4108 }
4109 Ok(super::OverrideContent::Group(
4110 helper.finish_element("group", values)?,
4111 ))
4112 }
4113 S::AttributeGroup(mut values, None, deserializer) => {
4114 if let Some(deserializer) = deserializer {
4115 let value = deserializer.finish(helper)?;
4116 OverrideContentDeserializer::store_attribute_group(&mut values, value)?;
4117 }
4118 Ok(super::OverrideContent::AttributeGroup(
4119 helper.finish_element("attributeGroup", values)?,
4120 ))
4121 }
4122 S::Element(mut values, None, deserializer) => {
4123 if let Some(deserializer) = deserializer {
4124 let value = deserializer.finish(helper)?;
4125 OverrideContentDeserializer::store_element(&mut values, value)?;
4126 }
4127 Ok(super::OverrideContent::Element(
4128 helper.finish_element("element", values)?,
4129 ))
4130 }
4131 S::Attribute(mut values, None, deserializer) => {
4132 if let Some(deserializer) = deserializer {
4133 let value = deserializer.finish(helper)?;
4134 OverrideContentDeserializer::store_attribute(&mut values, value)?;
4135 }
4136 Ok(super::OverrideContent::Attribute(
4137 helper.finish_element("attribute", values)?,
4138 ))
4139 }
4140 S::Notation(mut values, None, deserializer) => {
4141 if let Some(deserializer) = deserializer {
4142 let value = deserializer.finish(helper)?;
4143 OverrideContentDeserializer::store_notation(&mut values, value)?;
4144 }
4145 Ok(super::OverrideContent::Notation(
4146 helper.finish_element("notation", values)?,
4147 ))
4148 }
4149 S::Done__(data) => Ok(data),
4150 _ => unreachable!(),
4151 }
4152 }
4153 fn store_annotation(
4154 values: &mut Option<super::Annotation>,
4155 value: super::Annotation,
4156 ) -> Result<(), Error> {
4157 if values.is_some() {
4158 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4159 b"annotation",
4160 )))?;
4161 }
4162 *values = Some(value);
4163 Ok(())
4164 }
4165 fn store_simple_type(
4166 values: &mut Option<super::SimpleBaseType>,
4167 value: super::SimpleBaseType,
4168 ) -> Result<(), Error> {
4169 if values.is_some() {
4170 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4171 b"simpleType",
4172 )))?;
4173 }
4174 *values = Some(value);
4175 Ok(())
4176 }
4177 fn store_complex_type(
4178 values: &mut Option<super::ComplexBaseType>,
4179 value: super::ComplexBaseType,
4180 ) -> Result<(), Error> {
4181 if values.is_some() {
4182 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4183 b"complexType",
4184 )))?;
4185 }
4186 *values = Some(value);
4187 Ok(())
4188 }
4189 fn store_group(
4190 values: &mut Option<super::GroupType>,
4191 value: super::GroupType,
4192 ) -> Result<(), Error> {
4193 if values.is_some() {
4194 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4195 b"group",
4196 )))?;
4197 }
4198 *values = Some(value);
4199 Ok(())
4200 }
4201 fn store_attribute_group(
4202 values: &mut Option<super::AttributeGroupType>,
4203 value: super::AttributeGroupType,
4204 ) -> Result<(), Error> {
4205 if values.is_some() {
4206 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4207 b"attributeGroup",
4208 )))?;
4209 }
4210 *values = Some(value);
4211 Ok(())
4212 }
4213 fn store_element(
4214 values: &mut Option<super::ElementType>,
4215 value: super::ElementType,
4216 ) -> Result<(), Error> {
4217 if values.is_some() {
4218 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4219 b"element",
4220 )))?;
4221 }
4222 *values = Some(value);
4223 Ok(())
4224 }
4225 fn store_attribute(
4226 values: &mut Option<super::AttributeType>,
4227 value: super::AttributeType,
4228 ) -> Result<(), Error> {
4229 if values.is_some() {
4230 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4231 b"attribute",
4232 )))?;
4233 }
4234 *values = Some(value);
4235 Ok(())
4236 }
4237 fn store_notation(
4238 values: &mut Option<super::Notation>,
4239 value: super::Notation,
4240 ) -> Result<(), Error> {
4241 if values.is_some() {
4242 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
4243 b"notation",
4244 )))?;
4245 }
4246 *values = Some(value);
4247 Ok(())
4248 }
4249 fn handle_annotation<'de>(
4250 &mut self,
4251 helper: &mut DeserializeHelper,
4252 mut values: Option<super::Annotation>,
4253 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
4254 output: DeserializerOutput<'de, super::Annotation>,
4255 ) -> Result<ElementHandlerOutput<'de>, Error> {
4256 use OverrideContentDeserializerState as S;
4257 let DeserializerOutput {
4258 artifact,
4259 event,
4260 allow_any,
4261 } = output;
4262 if artifact.is_none() {
4263 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
4264 }
4265 if let Some(deserializer) = fallback {
4266 let data = deserializer.finish(helper)?;
4267 OverrideContentDeserializer::store_annotation(&mut values, data)?;
4268 }
4269 match artifact {
4270 DeserializerArtifact::None => unreachable!(),
4271 DeserializerArtifact::Data(data) => {
4272 OverrideContentDeserializer::store_annotation(&mut values, data)?;
4273 let data = OverrideContentDeserializer::finish_state(
4274 helper,
4275 S::Annotation(values, None, None),
4276 )?;
4277 *self.state__ = S::Done__(data);
4278 Ok(ElementHandlerOutput::break_(event, allow_any))
4279 }
4280 DeserializerArtifact::Deserializer(deserializer) => {
4281 *self.state__ = S::Annotation(values, None, Some(deserializer));
4282 Ok(ElementHandlerOutput::break_(event, allow_any))
4283 }
4284 }
4285 }
4286 fn handle_simple_type<'de>(
4287 &mut self,
4288 helper: &mut DeserializeHelper,
4289 mut values: Option<super::SimpleBaseType>,
4290 fallback: Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
4291 output: DeserializerOutput<'de, super::SimpleBaseType>,
4292 ) -> Result<ElementHandlerOutput<'de>, Error> {
4293 use OverrideContentDeserializerState as S;
4294 let DeserializerOutput {
4295 artifact,
4296 event,
4297 allow_any,
4298 } = output;
4299 if artifact.is_none() {
4300 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
4301 }
4302 if let Some(deserializer) = fallback {
4303 let data = deserializer.finish(helper)?;
4304 OverrideContentDeserializer::store_simple_type(&mut values, data)?;
4305 }
4306 match artifact {
4307 DeserializerArtifact::None => unreachable!(),
4308 DeserializerArtifact::Data(data) => {
4309 OverrideContentDeserializer::store_simple_type(&mut values, data)?;
4310 let data = OverrideContentDeserializer::finish_state(
4311 helper,
4312 S::SimpleType(values, None, None),
4313 )?;
4314 *self.state__ = S::Done__(data);
4315 Ok(ElementHandlerOutput::break_(event, allow_any))
4316 }
4317 DeserializerArtifact::Deserializer(deserializer) => {
4318 *self.state__ = S::SimpleType(values, None, Some(deserializer));
4319 Ok(ElementHandlerOutput::break_(event, allow_any))
4320 }
4321 }
4322 }
4323 fn handle_complex_type<'de>(
4324 &mut self,
4325 helper: &mut DeserializeHelper,
4326 mut values: Option<super::ComplexBaseType>,
4327 fallback: Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
4328 output: DeserializerOutput<'de, super::ComplexBaseType>,
4329 ) -> Result<ElementHandlerOutput<'de>, Error> {
4330 use OverrideContentDeserializerState as S;
4331 let DeserializerOutput {
4332 artifact,
4333 event,
4334 allow_any,
4335 } = output;
4336 if artifact.is_none() {
4337 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
4338 }
4339 if let Some(deserializer) = fallback {
4340 let data = deserializer.finish(helper)?;
4341 OverrideContentDeserializer::store_complex_type(&mut values, data)?;
4342 }
4343 match artifact {
4344 DeserializerArtifact::None => unreachable!(),
4345 DeserializerArtifact::Data(data) => {
4346 OverrideContentDeserializer::store_complex_type(&mut values, data)?;
4347 let data = OverrideContentDeserializer::finish_state(
4348 helper,
4349 S::ComplexType(values, None, None),
4350 )?;
4351 *self.state__ = S::Done__(data);
4352 Ok(ElementHandlerOutput::break_(event, allow_any))
4353 }
4354 DeserializerArtifact::Deserializer(deserializer) => {
4355 *self.state__ = S::ComplexType(values, None, Some(deserializer));
4356 Ok(ElementHandlerOutput::break_(event, allow_any))
4357 }
4358 }
4359 }
4360 fn handle_group<'de>(
4361 &mut self,
4362 helper: &mut DeserializeHelper,
4363 mut values: Option<super::GroupType>,
4364 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
4365 output: DeserializerOutput<'de, super::GroupType>,
4366 ) -> Result<ElementHandlerOutput<'de>, Error> {
4367 use OverrideContentDeserializerState as S;
4368 let DeserializerOutput {
4369 artifact,
4370 event,
4371 allow_any,
4372 } = output;
4373 if artifact.is_none() {
4374 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
4375 }
4376 if let Some(deserializer) = fallback {
4377 let data = deserializer.finish(helper)?;
4378 OverrideContentDeserializer::store_group(&mut values, data)?;
4379 }
4380 match artifact {
4381 DeserializerArtifact::None => unreachable!(),
4382 DeserializerArtifact::Data(data) => {
4383 OverrideContentDeserializer::store_group(&mut values, data)?;
4384 let data = OverrideContentDeserializer::finish_state(
4385 helper,
4386 S::Group(values, None, None),
4387 )?;
4388 *self.state__ = S::Done__(data);
4389 Ok(ElementHandlerOutput::break_(event, allow_any))
4390 }
4391 DeserializerArtifact::Deserializer(deserializer) => {
4392 *self.state__ = S::Group(values, None, Some(deserializer));
4393 Ok(ElementHandlerOutput::break_(event, allow_any))
4394 }
4395 }
4396 }
4397 fn handle_attribute_group<'de>(
4398 &mut self,
4399 helper: &mut DeserializeHelper,
4400 mut values: Option<super::AttributeGroupType>,
4401 fallback: Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
4402 output: DeserializerOutput<'de, super::AttributeGroupType>,
4403 ) -> Result<ElementHandlerOutput<'de>, Error> {
4404 use OverrideContentDeserializerState as S;
4405 let DeserializerOutput {
4406 artifact,
4407 event,
4408 allow_any,
4409 } = output;
4410 if artifact.is_none() {
4411 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
4412 }
4413 if let Some(deserializer) = fallback {
4414 let data = deserializer.finish(helper)?;
4415 OverrideContentDeserializer::store_attribute_group(&mut values, data)?;
4416 }
4417 match artifact {
4418 DeserializerArtifact::None => unreachable!(),
4419 DeserializerArtifact::Data(data) => {
4420 OverrideContentDeserializer::store_attribute_group(&mut values, data)?;
4421 let data = OverrideContentDeserializer::finish_state(
4422 helper,
4423 S::AttributeGroup(values, None, None),
4424 )?;
4425 *self.state__ = S::Done__(data);
4426 Ok(ElementHandlerOutput::break_(event, allow_any))
4427 }
4428 DeserializerArtifact::Deserializer(deserializer) => {
4429 *self.state__ = S::AttributeGroup(values, None, Some(deserializer));
4430 Ok(ElementHandlerOutput::break_(event, allow_any))
4431 }
4432 }
4433 }
4434 fn handle_element<'de>(
4435 &mut self,
4436 helper: &mut DeserializeHelper,
4437 mut values: Option<super::ElementType>,
4438 fallback: Option<<super::ElementType as WithDeserializer>::Deserializer>,
4439 output: DeserializerOutput<'de, super::ElementType>,
4440 ) -> Result<ElementHandlerOutput<'de>, Error> {
4441 use OverrideContentDeserializerState as S;
4442 let DeserializerOutput {
4443 artifact,
4444 event,
4445 allow_any,
4446 } = output;
4447 if artifact.is_none() {
4448 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
4449 }
4450 if let Some(deserializer) = fallback {
4451 let data = deserializer.finish(helper)?;
4452 OverrideContentDeserializer::store_element(&mut values, data)?;
4453 }
4454 match artifact {
4455 DeserializerArtifact::None => unreachable!(),
4456 DeserializerArtifact::Data(data) => {
4457 OverrideContentDeserializer::store_element(&mut values, data)?;
4458 let data = OverrideContentDeserializer::finish_state(
4459 helper,
4460 S::Element(values, None, None),
4461 )?;
4462 *self.state__ = S::Done__(data);
4463 Ok(ElementHandlerOutput::break_(event, allow_any))
4464 }
4465 DeserializerArtifact::Deserializer(deserializer) => {
4466 *self.state__ = S::Element(values, None, Some(deserializer));
4467 Ok(ElementHandlerOutput::break_(event, allow_any))
4468 }
4469 }
4470 }
4471 fn handle_attribute<'de>(
4472 &mut self,
4473 helper: &mut DeserializeHelper,
4474 mut values: Option<super::AttributeType>,
4475 fallback: Option<<super::AttributeType as WithDeserializer>::Deserializer>,
4476 output: DeserializerOutput<'de, super::AttributeType>,
4477 ) -> Result<ElementHandlerOutput<'de>, Error> {
4478 use OverrideContentDeserializerState as S;
4479 let DeserializerOutput {
4480 artifact,
4481 event,
4482 allow_any,
4483 } = output;
4484 if artifact.is_none() {
4485 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
4486 }
4487 if let Some(deserializer) = fallback {
4488 let data = deserializer.finish(helper)?;
4489 OverrideContentDeserializer::store_attribute(&mut values, data)?;
4490 }
4491 match artifact {
4492 DeserializerArtifact::None => unreachable!(),
4493 DeserializerArtifact::Data(data) => {
4494 OverrideContentDeserializer::store_attribute(&mut values, data)?;
4495 let data = OverrideContentDeserializer::finish_state(
4496 helper,
4497 S::Attribute(values, None, None),
4498 )?;
4499 *self.state__ = S::Done__(data);
4500 Ok(ElementHandlerOutput::break_(event, allow_any))
4501 }
4502 DeserializerArtifact::Deserializer(deserializer) => {
4503 *self.state__ = S::Attribute(values, None, Some(deserializer));
4504 Ok(ElementHandlerOutput::break_(event, allow_any))
4505 }
4506 }
4507 }
4508 fn handle_notation<'de>(
4509 &mut self,
4510 helper: &mut DeserializeHelper,
4511 mut values: Option<super::Notation>,
4512 fallback: Option<<super::Notation as WithDeserializer>::Deserializer>,
4513 output: DeserializerOutput<'de, super::Notation>,
4514 ) -> Result<ElementHandlerOutput<'de>, Error> {
4515 use OverrideContentDeserializerState as S;
4516 let DeserializerOutput {
4517 artifact,
4518 event,
4519 allow_any,
4520 } = output;
4521 if artifact.is_none() {
4522 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
4523 }
4524 if let Some(deserializer) = fallback {
4525 let data = deserializer.finish(helper)?;
4526 OverrideContentDeserializer::store_notation(&mut values, data)?;
4527 }
4528 match artifact {
4529 DeserializerArtifact::None => unreachable!(),
4530 DeserializerArtifact::Data(data) => {
4531 OverrideContentDeserializer::store_notation(&mut values, data)?;
4532 let data = OverrideContentDeserializer::finish_state(
4533 helper,
4534 S::Notation(values, None, None),
4535 )?;
4536 *self.state__ = S::Done__(data);
4537 Ok(ElementHandlerOutput::break_(event, allow_any))
4538 }
4539 DeserializerArtifact::Deserializer(deserializer) => {
4540 *self.state__ = S::Notation(values, None, Some(deserializer));
4541 Ok(ElementHandlerOutput::break_(event, allow_any))
4542 }
4543 }
4544 }
4545 }
4546 impl<'de> Deserializer<'de, super::OverrideContent> for Box<OverrideContentDeserializer> {
4547 fn init(
4548 helper: &mut DeserializeHelper,
4549 event: Event<'de>,
4550 ) -> DeserializerResult<'de, super::OverrideContent> {
4551 let deserializer = Box::new(OverrideContentDeserializer {
4552 state__: Box::new(OverrideContentDeserializerState::Init__),
4553 });
4554 let mut output = deserializer.next(helper, event)?;
4555 output.artifact = match output.artifact {
4556 DeserializerArtifact::Deserializer(x)
4557 if matches!(&*x.state__, OverrideContentDeserializerState::Init__) =>
4558 {
4559 DeserializerArtifact::None
4560 }
4561 artifact => artifact,
4562 };
4563 Ok(output)
4564 }
4565 fn next(
4566 mut self,
4567 helper: &mut DeserializeHelper,
4568 event: Event<'de>,
4569 ) -> DeserializerResult<'de, super::OverrideContent> {
4570 use OverrideContentDeserializerState as S;
4571 let mut event = event;
4572 let (event, allow_any) = loop {
4573 let state = replace(&mut *self.state__, S::Unknown__);
4574 event = match (state, event) {
4575 (S::Unknown__, _) => unreachable!(),
4576 (S::Annotation(values, fallback, Some(deserializer)), event) => {
4577 let output = deserializer.next(helper, event)?;
4578 match self.handle_annotation(helper, values, fallback, output)? {
4579 ElementHandlerOutput::Break { event, allow_any } => {
4580 break (event, allow_any)
4581 }
4582 ElementHandlerOutput::Continue { event, .. } => event,
4583 }
4584 }
4585 (S::SimpleType(values, fallback, Some(deserializer)), event) => {
4586 let output = deserializer.next(helper, event)?;
4587 match self.handle_simple_type(helper, values, fallback, output)? {
4588 ElementHandlerOutput::Break { event, allow_any } => {
4589 break (event, allow_any)
4590 }
4591 ElementHandlerOutput::Continue { event, .. } => event,
4592 }
4593 }
4594 (S::ComplexType(values, fallback, Some(deserializer)), event) => {
4595 let output = deserializer.next(helper, event)?;
4596 match self.handle_complex_type(helper, values, fallback, output)? {
4597 ElementHandlerOutput::Break { event, allow_any } => {
4598 break (event, allow_any)
4599 }
4600 ElementHandlerOutput::Continue { event, .. } => event,
4601 }
4602 }
4603 (S::Group(values, fallback, Some(deserializer)), event) => {
4604 let output = deserializer.next(helper, event)?;
4605 match self.handle_group(helper, values, fallback, output)? {
4606 ElementHandlerOutput::Break { event, allow_any } => {
4607 break (event, allow_any)
4608 }
4609 ElementHandlerOutput::Continue { event, .. } => event,
4610 }
4611 }
4612 (S::AttributeGroup(values, fallback, Some(deserializer)), event) => {
4613 let output = deserializer.next(helper, event)?;
4614 match self.handle_attribute_group(helper, values, fallback, output)? {
4615 ElementHandlerOutput::Break { event, allow_any } => {
4616 break (event, allow_any)
4617 }
4618 ElementHandlerOutput::Continue { event, .. } => event,
4619 }
4620 }
4621 (S::Element(values, fallback, Some(deserializer)), event) => {
4622 let output = deserializer.next(helper, event)?;
4623 match self.handle_element(helper, values, fallback, output)? {
4624 ElementHandlerOutput::Break { event, allow_any } => {
4625 break (event, allow_any)
4626 }
4627 ElementHandlerOutput::Continue { event, .. } => event,
4628 }
4629 }
4630 (S::Attribute(values, fallback, Some(deserializer)), event) => {
4631 let output = deserializer.next(helper, event)?;
4632 match self.handle_attribute(helper, values, fallback, output)? {
4633 ElementHandlerOutput::Break { event, allow_any } => {
4634 break (event, allow_any)
4635 }
4636 ElementHandlerOutput::Continue { event, .. } => event,
4637 }
4638 }
4639 (S::Notation(values, fallback, Some(deserializer)), event) => {
4640 let output = deserializer.next(helper, event)?;
4641 match self.handle_notation(helper, values, fallback, output)? {
4642 ElementHandlerOutput::Break { event, allow_any } => {
4643 break (event, allow_any)
4644 }
4645 ElementHandlerOutput::Continue { event, .. } => event,
4646 }
4647 }
4648 (state, event @ Event::End(_)) => {
4649 return Ok(DeserializerOutput {
4650 artifact: DeserializerArtifact::Data(
4651 OverrideContentDeserializer::finish_state(helper, state)?,
4652 ),
4653 event: DeserializerEvent::Continue(event),
4654 allow_any: false,
4655 });
4656 }
4657 (S::Init__, event) => match self.find_suitable(helper, event)? {
4658 ElementHandlerOutput::Break { event, allow_any } => {
4659 break (event, allow_any)
4660 }
4661 ElementHandlerOutput::Continue { event, .. } => event,
4662 },
4663 (
4664 S::Annotation(values, fallback, None),
4665 event @ (Event::Start(_) | Event::Empty(_)),
4666 ) => {
4667 let output = helper.init_start_tag_deserializer(
4668 event,
4669 Some(&super::NS_XS),
4670 b"annotation",
4671 false,
4672 )?;
4673 match self.handle_annotation(helper, values, fallback, output)? {
4674 ElementHandlerOutput::Break { event, allow_any } => {
4675 break (event, allow_any)
4676 }
4677 ElementHandlerOutput::Continue { event, .. } => event,
4678 }
4679 }
4680 (
4681 S::SimpleType(values, fallback, None),
4682 event @ (Event::Start(_) | Event::Empty(_)),
4683 ) => {
4684 let output = helper.init_start_tag_deserializer(
4685 event,
4686 Some(&super::NS_XS),
4687 b"simpleType",
4688 true,
4689 )?;
4690 match self.handle_simple_type(helper, values, fallback, output)? {
4691 ElementHandlerOutput::Break { event, allow_any } => {
4692 break (event, allow_any)
4693 }
4694 ElementHandlerOutput::Continue { event, .. } => event,
4695 }
4696 }
4697 (
4698 S::ComplexType(values, fallback, None),
4699 event @ (Event::Start(_) | Event::Empty(_)),
4700 ) => {
4701 let output = helper.init_start_tag_deserializer(
4702 event,
4703 Some(&super::NS_XS),
4704 b"complexType",
4705 true,
4706 )?;
4707 match self.handle_complex_type(helper, values, fallback, output)? {
4708 ElementHandlerOutput::Break { event, allow_any } => {
4709 break (event, allow_any)
4710 }
4711 ElementHandlerOutput::Continue { event, .. } => event,
4712 }
4713 }
4714 (
4715 S::Group(values, fallback, None),
4716 event @ (Event::Start(_) | Event::Empty(_)),
4717 ) => {
4718 let output = helper.init_start_tag_deserializer(
4719 event,
4720 Some(&super::NS_XS),
4721 b"group",
4722 true,
4723 )?;
4724 match self.handle_group(helper, values, fallback, output)? {
4725 ElementHandlerOutput::Break { event, allow_any } => {
4726 break (event, allow_any)
4727 }
4728 ElementHandlerOutput::Continue { event, .. } => event,
4729 }
4730 }
4731 (
4732 S::AttributeGroup(values, fallback, None),
4733 event @ (Event::Start(_) | Event::Empty(_)),
4734 ) => {
4735 let output = helper.init_start_tag_deserializer(
4736 event,
4737 Some(&super::NS_XS),
4738 b"attributeGroup",
4739 false,
4740 )?;
4741 match self.handle_attribute_group(helper, values, fallback, output)? {
4742 ElementHandlerOutput::Break { event, allow_any } => {
4743 break (event, allow_any)
4744 }
4745 ElementHandlerOutput::Continue { event, .. } => event,
4746 }
4747 }
4748 (
4749 S::Element(values, fallback, None),
4750 event @ (Event::Start(_) | Event::Empty(_)),
4751 ) => {
4752 let output = helper.init_start_tag_deserializer(
4753 event,
4754 Some(&super::NS_XS),
4755 b"element",
4756 true,
4757 )?;
4758 match self.handle_element(helper, values, fallback, output)? {
4759 ElementHandlerOutput::Break { event, allow_any } => {
4760 break (event, allow_any)
4761 }
4762 ElementHandlerOutput::Continue { event, .. } => event,
4763 }
4764 }
4765 (
4766 S::Attribute(values, fallback, None),
4767 event @ (Event::Start(_) | Event::Empty(_)),
4768 ) => {
4769 let output = helper.init_start_tag_deserializer(
4770 event,
4771 Some(&super::NS_XS),
4772 b"attribute",
4773 false,
4774 )?;
4775 match self.handle_attribute(helper, values, fallback, output)? {
4776 ElementHandlerOutput::Break { event, allow_any } => {
4777 break (event, allow_any)
4778 }
4779 ElementHandlerOutput::Continue { event, .. } => event,
4780 }
4781 }
4782 (
4783 S::Notation(values, fallback, None),
4784 event @ (Event::Start(_) | Event::Empty(_)),
4785 ) => {
4786 let output = helper.init_start_tag_deserializer(
4787 event,
4788 Some(&super::NS_XS),
4789 b"notation",
4790 false,
4791 )?;
4792 match self.handle_notation(helper, values, fallback, output)? {
4793 ElementHandlerOutput::Break { event, allow_any } => {
4794 break (event, allow_any)
4795 }
4796 ElementHandlerOutput::Continue { event, .. } => event,
4797 }
4798 }
4799 (state @ S::Done__(_), event) => {
4800 *self.state__ = state;
4801 break (DeserializerEvent::Continue(event), false);
4802 }
4803 (state, event) => {
4804 *self.state__ = state;
4805 break (DeserializerEvent::Continue(event), false);
4806 }
4807 }
4808 };
4809 let artifact = if matches!(&*self.state__, S::Done__(_)) {
4810 DeserializerArtifact::Data(self.finish(helper)?)
4811 } else {
4812 DeserializerArtifact::Deserializer(self)
4813 };
4814 Ok(DeserializerOutput {
4815 artifact,
4816 event,
4817 allow_any,
4818 })
4819 }
4820 fn finish(self, helper: &mut DeserializeHelper) -> Result<super::OverrideContent, Error> {
4821 OverrideContentDeserializer::finish_state(helper, *self.state__)
4822 }
4823 }
4824 #[derive(Debug)]
4825 pub struct AnnotationDeserializer {
4826 id: Option<String>,
4827 content: Vec<super::AnnotationContent>,
4828 state__: Box<AnnotationDeserializerState>,
4829 }
4830 #[derive(Debug)]
4831 enum AnnotationDeserializerState {
4832 Init__,
4833 Next__,
4834 Content__(<super::AnnotationContent as WithDeserializer>::Deserializer),
4835 Unknown__,
4836 }
4837 impl AnnotationDeserializer {
4838 fn from_bytes_start(
4839 helper: &mut DeserializeHelper,
4840 bytes_start: &BytesStart<'_>,
4841 ) -> Result<Box<Self>, Error> {
4842 let mut id: Option<String> = None;
4843 for attrib in helper.filter_xmlns_attributes(bytes_start) {
4844 let attrib = attrib?;
4845 if matches!(
4846 helper.resolve_local_name(attrib.key, &super::NS_XS),
4847 Some(b"id")
4848 ) {
4849 helper.read_attrib(&mut id, b"id", &attrib.value)?;
4850 }
4851 }
4852 Ok(Box::new(Self {
4853 id: id,
4854 content: Vec::new(),
4855 state__: Box::new(AnnotationDeserializerState::Init__),
4856 }))
4857 }
4858 fn finish_state(
4859 &mut self,
4860 helper: &mut DeserializeHelper,
4861 state: AnnotationDeserializerState,
4862 ) -> Result<(), Error> {
4863 if let AnnotationDeserializerState::Content__(deserializer) = state {
4864 self.store_content(deserializer.finish(helper)?)?;
4865 }
4866 Ok(())
4867 }
4868 fn store_content(&mut self, value: super::AnnotationContent) -> Result<(), Error> {
4869 self.content.push(value);
4870 Ok(())
4871 }
4872 fn handle_content<'de>(
4873 &mut self,
4874 helper: &mut DeserializeHelper,
4875 output: DeserializerOutput<'de, super::AnnotationContent>,
4876 fallback: &mut Option<AnnotationDeserializerState>,
4877 ) -> Result<ElementHandlerOutput<'de>, Error> {
4878 use AnnotationDeserializerState as S;
4879 let DeserializerOutput {
4880 artifact,
4881 event,
4882 allow_any,
4883 } = output;
4884 if artifact.is_none() {
4885 *self.state__ = fallback.take().unwrap_or(S::Next__);
4886 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
4887 }
4888 if let Some(fallback) = fallback.take() {
4889 self.finish_state(helper, fallback)?;
4890 }
4891 match artifact {
4892 DeserializerArtifact::None => unreachable!(),
4893 DeserializerArtifact::Data(data) => {
4894 self.store_content(data)?;
4895 *self.state__ = S::Next__;
4896 Ok(ElementHandlerOutput::from_event(event, allow_any))
4897 }
4898 DeserializerArtifact::Deserializer(deserializer) => {
4899 *fallback = Some(S::Content__(deserializer));
4900 *self.state__ = S::Next__;
4901 Ok(ElementHandlerOutput::from_event(event, allow_any))
4902 }
4903 }
4904 }
4905 }
4906 impl<'de> Deserializer<'de, super::Annotation> for Box<AnnotationDeserializer> {
4907 fn init(
4908 helper: &mut DeserializeHelper,
4909 event: Event<'de>,
4910 ) -> DeserializerResult<'de, super::Annotation> {
4911 helper
4912 .init_deserializer_from_start_event(event, AnnotationDeserializer::from_bytes_start)
4913 }
4914 fn next(
4915 mut self,
4916 helper: &mut DeserializeHelper,
4917 event: Event<'de>,
4918 ) -> DeserializerResult<'de, super::Annotation> {
4919 use AnnotationDeserializerState as S;
4920 let mut event = event;
4921 let mut fallback = None;
4922 let (event, allow_any) = loop {
4923 let state = replace(&mut *self.state__, S::Unknown__);
4924 event = match (state, event) {
4925 (S::Unknown__, _) => unreachable!(),
4926 (S::Content__(deserializer), event) => {
4927 let output = deserializer.next(helper, event)?;
4928 match self.handle_content(helper, output, &mut fallback)? {
4929 ElementHandlerOutput::Break { event, allow_any } => {
4930 break (event, allow_any)
4931 }
4932 ElementHandlerOutput::Continue { event, .. } => event,
4933 }
4934 }
4935 (_, Event::End(_)) => {
4936 return Ok(DeserializerOutput {
4937 artifact: DeserializerArtifact::Data(self.finish(helper)?),
4938 event: DeserializerEvent::None,
4939 allow_any: false,
4940 });
4941 }
4942 (state @ (S::Init__ | S::Next__), event) => {
4943 fallback.get_or_insert(state);
4944 let output =
4945 <super::AnnotationContent as WithDeserializer>::init(helper, event)?;
4946 match self.handle_content(helper, output, &mut fallback)? {
4947 ElementHandlerOutput::Break { event, allow_any } => {
4948 break (event, allow_any)
4949 }
4950 ElementHandlerOutput::Continue { event, .. } => event,
4951 }
4952 }
4953 }
4954 };
4955 if let Some(fallback) = fallback {
4956 *self.state__ = fallback;
4957 }
4958 let artifact = DeserializerArtifact::Deserializer(self);
4959 Ok(DeserializerOutput {
4960 artifact,
4961 event,
4962 allow_any,
4963 })
4964 }
4965 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Annotation, Error> {
4966 let state = replace(&mut *self.state__, AnnotationDeserializerState::Unknown__);
4967 self.finish_state(helper, state)?;
4968 Ok(super::Annotation {
4969 id: self.id,
4970 content: helper.finish_vec(0usize, None, self.content)?,
4971 })
4972 }
4973 }
4974 #[derive(Debug)]
4975 pub struct AnnotationContentDeserializer {
4976 state__: Box<AnnotationContentDeserializerState>,
4977 }
4978 #[derive(Debug)]
4979 pub enum AnnotationContentDeserializerState {
4980 Init__,
4981 Appinfo(
4982 Option<AnyElement>,
4983 Option<<AnyElement as WithDeserializer>::Deserializer>,
4984 Option<<AnyElement as WithDeserializer>::Deserializer>,
4985 ),
4986 Documentation(
4987 Option<AnyElement>,
4988 Option<<AnyElement as WithDeserializer>::Deserializer>,
4989 Option<<AnyElement as WithDeserializer>::Deserializer>,
4990 ),
4991 Done__(super::AnnotationContent),
4992 Unknown__,
4993 }
4994 impl AnnotationContentDeserializer {
4995 fn find_suitable<'de>(
4996 &mut self,
4997 helper: &mut DeserializeHelper,
4998 event: Event<'de>,
4999 ) -> Result<ElementHandlerOutput<'de>, Error> {
5000 if let Event::Start(x) | Event::Empty(x) = &event {
5001 if matches!(
5002 helper.resolve_local_name(x.name(), &super::NS_XS),
5003 Some(b"appinfo")
5004 ) {
5005 let output = <AnyElement as WithDeserializer>::init(helper, event)?;
5006 return self.handle_appinfo(helper, Default::default(), None, output);
5007 }
5008 if matches!(
5009 helper.resolve_local_name(x.name(), &super::NS_XS),
5010 Some(b"documentation")
5011 ) {
5012 let output = <AnyElement as WithDeserializer>::init(helper, event)?;
5013 return self.handle_documentation(helper, Default::default(), None, output);
5014 }
5015 }
5016 *self.state__ = AnnotationContentDeserializerState::Init__;
5017 Ok(ElementHandlerOutput::return_to_parent(event, false))
5018 }
5019 fn finish_state(
5020 helper: &mut DeserializeHelper,
5021 state: AnnotationContentDeserializerState,
5022 ) -> Result<super::AnnotationContent, Error> {
5023 use AnnotationContentDeserializerState as S;
5024 match state {
5025 S::Init__ => Err(ErrorKind::MissingContent.into()),
5026 S::Appinfo(mut values, None, deserializer) => {
5027 if let Some(deserializer) = deserializer {
5028 let value = deserializer.finish(helper)?;
5029 AnnotationContentDeserializer::store_appinfo(&mut values, value)?;
5030 }
5031 Ok(super::AnnotationContent::Appinfo(
5032 helper.finish_element("appinfo", values)?,
5033 ))
5034 }
5035 S::Documentation(mut values, None, deserializer) => {
5036 if let Some(deserializer) = deserializer {
5037 let value = deserializer.finish(helper)?;
5038 AnnotationContentDeserializer::store_documentation(&mut values, value)?;
5039 }
5040 Ok(super::AnnotationContent::Documentation(
5041 helper.finish_element("documentation", values)?,
5042 ))
5043 }
5044 S::Done__(data) => Ok(data),
5045 _ => unreachable!(),
5046 }
5047 }
5048 fn store_appinfo(values: &mut Option<AnyElement>, value: AnyElement) -> Result<(), Error> {
5049 if values.is_some() {
5050 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
5051 b"appinfo",
5052 )))?;
5053 }
5054 *values = Some(value);
5055 Ok(())
5056 }
5057 fn store_documentation(
5058 values: &mut Option<AnyElement>,
5059 value: AnyElement,
5060 ) -> Result<(), Error> {
5061 if values.is_some() {
5062 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
5063 b"documentation",
5064 )))?;
5065 }
5066 *values = Some(value);
5067 Ok(())
5068 }
5069 fn handle_appinfo<'de>(
5070 &mut self,
5071 helper: &mut DeserializeHelper,
5072 mut values: Option<AnyElement>,
5073 fallback: Option<<AnyElement as WithDeserializer>::Deserializer>,
5074 output: DeserializerOutput<'de, AnyElement>,
5075 ) -> Result<ElementHandlerOutput<'de>, Error> {
5076 use AnnotationContentDeserializerState as S;
5077 let DeserializerOutput {
5078 artifact,
5079 event,
5080 allow_any,
5081 } = output;
5082 if artifact.is_none() {
5083 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
5084 }
5085 if let Some(deserializer) = fallback {
5086 let data = deserializer.finish(helper)?;
5087 AnnotationContentDeserializer::store_appinfo(&mut values, data)?;
5088 }
5089 match artifact {
5090 DeserializerArtifact::None => unreachable!(),
5091 DeserializerArtifact::Data(data) => {
5092 AnnotationContentDeserializer::store_appinfo(&mut values, data)?;
5093 let data = AnnotationContentDeserializer::finish_state(
5094 helper,
5095 S::Appinfo(values, None, None),
5096 )?;
5097 *self.state__ = S::Done__(data);
5098 Ok(ElementHandlerOutput::break_(event, allow_any))
5099 }
5100 DeserializerArtifact::Deserializer(deserializer) => {
5101 *self.state__ = S::Appinfo(values, None, Some(deserializer));
5102 Ok(ElementHandlerOutput::break_(event, allow_any))
5103 }
5104 }
5105 }
5106 fn handle_documentation<'de>(
5107 &mut self,
5108 helper: &mut DeserializeHelper,
5109 mut values: Option<AnyElement>,
5110 fallback: Option<<AnyElement as WithDeserializer>::Deserializer>,
5111 output: DeserializerOutput<'de, AnyElement>,
5112 ) -> Result<ElementHandlerOutput<'de>, Error> {
5113 use AnnotationContentDeserializerState as S;
5114 let DeserializerOutput {
5115 artifact,
5116 event,
5117 allow_any,
5118 } = output;
5119 if artifact.is_none() {
5120 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
5121 }
5122 if let Some(deserializer) = fallback {
5123 let data = deserializer.finish(helper)?;
5124 AnnotationContentDeserializer::store_documentation(&mut values, data)?;
5125 }
5126 match artifact {
5127 DeserializerArtifact::None => unreachable!(),
5128 DeserializerArtifact::Data(data) => {
5129 AnnotationContentDeserializer::store_documentation(&mut values, data)?;
5130 let data = AnnotationContentDeserializer::finish_state(
5131 helper,
5132 S::Documentation(values, None, None),
5133 )?;
5134 *self.state__ = S::Done__(data);
5135 Ok(ElementHandlerOutput::break_(event, allow_any))
5136 }
5137 DeserializerArtifact::Deserializer(deserializer) => {
5138 *self.state__ = S::Documentation(values, None, Some(deserializer));
5139 Ok(ElementHandlerOutput::break_(event, allow_any))
5140 }
5141 }
5142 }
5143 }
5144 impl<'de> Deserializer<'de, super::AnnotationContent> for Box<AnnotationContentDeserializer> {
5145 fn init(
5146 helper: &mut DeserializeHelper,
5147 event: Event<'de>,
5148 ) -> DeserializerResult<'de, super::AnnotationContent> {
5149 let deserializer = Box::new(AnnotationContentDeserializer {
5150 state__: Box::new(AnnotationContentDeserializerState::Init__),
5151 });
5152 let mut output = deserializer.next(helper, event)?;
5153 output.artifact = match output.artifact {
5154 DeserializerArtifact::Deserializer(x)
5155 if matches!(&*x.state__, AnnotationContentDeserializerState::Init__) =>
5156 {
5157 DeserializerArtifact::None
5158 }
5159 artifact => artifact,
5160 };
5161 Ok(output)
5162 }
5163 fn next(
5164 mut self,
5165 helper: &mut DeserializeHelper,
5166 event: Event<'de>,
5167 ) -> DeserializerResult<'de, super::AnnotationContent> {
5168 use AnnotationContentDeserializerState as S;
5169 let mut event = event;
5170 let (event, allow_any) = loop {
5171 let state = replace(&mut *self.state__, S::Unknown__);
5172 event = match (state, event) {
5173 (S::Unknown__, _) => unreachable!(),
5174 (S::Appinfo(values, fallback, Some(deserializer)), event) => {
5175 let output = deserializer.next(helper, event)?;
5176 match self.handle_appinfo(helper, values, fallback, output)? {
5177 ElementHandlerOutput::Break { event, allow_any } => {
5178 break (event, allow_any)
5179 }
5180 ElementHandlerOutput::Continue { event, .. } => event,
5181 }
5182 }
5183 (S::Documentation(values, fallback, Some(deserializer)), event) => {
5184 let output = deserializer.next(helper, event)?;
5185 match self.handle_documentation(helper, values, fallback, output)? {
5186 ElementHandlerOutput::Break { event, allow_any } => {
5187 break (event, allow_any)
5188 }
5189 ElementHandlerOutput::Continue { event, .. } => event,
5190 }
5191 }
5192 (state, event @ Event::End(_)) => {
5193 return Ok(DeserializerOutput {
5194 artifact: DeserializerArtifact::Data(
5195 AnnotationContentDeserializer::finish_state(helper, state)?,
5196 ),
5197 event: DeserializerEvent::Continue(event),
5198 allow_any: false,
5199 });
5200 }
5201 (S::Init__, event) => match self.find_suitable(helper, event)? {
5202 ElementHandlerOutput::Break { event, allow_any } => {
5203 break (event, allow_any)
5204 }
5205 ElementHandlerOutput::Continue { event, .. } => event,
5206 },
5207 (
5208 S::Appinfo(values, fallback, None),
5209 event @ (Event::Start(_) | Event::Empty(_)),
5210 ) => {
5211 let output = helper.init_start_tag_deserializer(
5212 event,
5213 Some(&super::NS_XS),
5214 b"appinfo",
5215 false,
5216 )?;
5217 match self.handle_appinfo(helper, values, fallback, output)? {
5218 ElementHandlerOutput::Break { event, allow_any } => {
5219 break (event, allow_any)
5220 }
5221 ElementHandlerOutput::Continue { event, .. } => event,
5222 }
5223 }
5224 (
5225 S::Documentation(values, fallback, None),
5226 event @ (Event::Start(_) | Event::Empty(_)),
5227 ) => {
5228 let output = helper.init_start_tag_deserializer(
5229 event,
5230 Some(&super::NS_XS),
5231 b"documentation",
5232 false,
5233 )?;
5234 match self.handle_documentation(helper, values, fallback, output)? {
5235 ElementHandlerOutput::Break { event, allow_any } => {
5236 break (event, allow_any)
5237 }
5238 ElementHandlerOutput::Continue { event, .. } => event,
5239 }
5240 }
5241 (state @ S::Done__(_), event) => {
5242 *self.state__ = state;
5243 break (DeserializerEvent::Continue(event), false);
5244 }
5245 (state, event) => {
5246 *self.state__ = state;
5247 break (DeserializerEvent::Continue(event), false);
5248 }
5249 }
5250 };
5251 let artifact = if matches!(&*self.state__, S::Done__(_)) {
5252 DeserializerArtifact::Data(self.finish(helper)?)
5253 } else {
5254 DeserializerArtifact::Deserializer(self)
5255 };
5256 Ok(DeserializerOutput {
5257 artifact,
5258 event,
5259 allow_any,
5260 })
5261 }
5262 fn finish(self, helper: &mut DeserializeHelper) -> Result<super::AnnotationContent, Error> {
5263 AnnotationContentDeserializer::finish_state(helper, *self.state__)
5264 }
5265 }
5266 #[derive(Debug)]
5267 pub struct DefaultOpenContentDeserializer {
5268 id: Option<String>,
5269 applies_to_empty: bool,
5270 mode: super::DefaultOpenContentModeType,
5271 annotation: Option<super::Annotation>,
5272 any: Option<super::WildcardType>,
5273 state__: Box<DefaultOpenContentDeserializerState>,
5274 }
5275 #[derive(Debug)]
5276 enum DefaultOpenContentDeserializerState {
5277 Init__,
5278 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
5279 Any(Option<<super::WildcardType as WithDeserializer>::Deserializer>),
5280 Done__,
5281 Unknown__,
5282 }
5283 impl DefaultOpenContentDeserializer {
5284 fn from_bytes_start(
5285 helper: &mut DeserializeHelper,
5286 bytes_start: &BytesStart<'_>,
5287 ) -> Result<Box<Self>, Error> {
5288 let mut id: Option<String> = None;
5289 let mut applies_to_empty: Option<bool> = None;
5290 let mut mode: Option<super::DefaultOpenContentModeType> = None;
5291 for attrib in helper.filter_xmlns_attributes(bytes_start) {
5292 let attrib = attrib?;
5293 if matches!(
5294 helper.resolve_local_name(attrib.key, &super::NS_XS),
5295 Some(b"id")
5296 ) {
5297 helper.read_attrib(&mut id, b"id", &attrib.value)?;
5298 } else if matches!(
5299 helper.resolve_local_name(attrib.key, &super::NS_XS),
5300 Some(b"appliesToEmpty")
5301 ) {
5302 helper.read_attrib(&mut applies_to_empty, b"appliesToEmpty", &attrib.value)?;
5303 } else if matches!(
5304 helper.resolve_local_name(attrib.key, &super::NS_XS),
5305 Some(b"mode")
5306 ) {
5307 helper.read_attrib(&mut mode, b"mode", &attrib.value)?;
5308 }
5309 }
5310 Ok(Box::new(Self {
5311 id: id,
5312 applies_to_empty: applies_to_empty
5313 .unwrap_or_else(super::DefaultOpenContent::default_applies_to_empty),
5314 mode: mode.unwrap_or_else(super::DefaultOpenContent::default_mode),
5315 annotation: None,
5316 any: None,
5317 state__: Box::new(DefaultOpenContentDeserializerState::Init__),
5318 }))
5319 }
5320 fn finish_state(
5321 &mut self,
5322 helper: &mut DeserializeHelper,
5323 state: DefaultOpenContentDeserializerState,
5324 ) -> Result<(), Error> {
5325 use DefaultOpenContentDeserializerState as S;
5326 match state {
5327 S::Annotation(Some(deserializer)) => {
5328 self.store_annotation(deserializer.finish(helper)?)?
5329 }
5330 S::Any(Some(deserializer)) => self.store_any(deserializer.finish(helper)?)?,
5331 _ => (),
5332 }
5333 Ok(())
5334 }
5335 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
5336 if self.annotation.is_some() {
5337 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
5338 b"annotation",
5339 )))?;
5340 }
5341 self.annotation = Some(value);
5342 Ok(())
5343 }
5344 fn store_any(&mut self, value: super::WildcardType) -> Result<(), Error> {
5345 if self.any.is_some() {
5346 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"any")))?;
5347 }
5348 self.any = Some(value);
5349 Ok(())
5350 }
5351 fn handle_annotation<'de>(
5352 &mut self,
5353 helper: &mut DeserializeHelper,
5354 output: DeserializerOutput<'de, super::Annotation>,
5355 fallback: &mut Option<DefaultOpenContentDeserializerState>,
5356 ) -> Result<ElementHandlerOutput<'de>, Error> {
5357 use DefaultOpenContentDeserializerState as S;
5358 let DeserializerOutput {
5359 artifact,
5360 event,
5361 allow_any,
5362 } = output;
5363 if artifact.is_none() {
5364 fallback.get_or_insert(S::Annotation(None));
5365 *self.state__ = S::Any(None);
5366 return Ok(ElementHandlerOutput::from_event(event, allow_any));
5367 }
5368 if let Some(fallback) = fallback.take() {
5369 self.finish_state(helper, fallback)?;
5370 }
5371 match artifact {
5372 DeserializerArtifact::None => unreachable!(),
5373 DeserializerArtifact::Data(data) => {
5374 self.store_annotation(data)?;
5375 *self.state__ = S::Any(None);
5376 Ok(ElementHandlerOutput::from_event(event, allow_any))
5377 }
5378 DeserializerArtifact::Deserializer(deserializer) => {
5379 fallback.get_or_insert(S::Annotation(Some(deserializer)));
5380 *self.state__ = S::Any(None);
5381 Ok(ElementHandlerOutput::from_event(event, allow_any))
5382 }
5383 }
5384 }
5385 fn handle_any<'de>(
5386 &mut self,
5387 helper: &mut DeserializeHelper,
5388 output: DeserializerOutput<'de, super::WildcardType>,
5389 fallback: &mut Option<DefaultOpenContentDeserializerState>,
5390 ) -> Result<ElementHandlerOutput<'de>, Error> {
5391 use DefaultOpenContentDeserializerState as S;
5392 let DeserializerOutput {
5393 artifact,
5394 event,
5395 allow_any,
5396 } = output;
5397 if artifact.is_none() {
5398 fallback.get_or_insert(S::Any(None));
5399 if matches!(&fallback, Some(S::Init__)) {
5400 return Ok(ElementHandlerOutput::break_(event, allow_any));
5401 } else {
5402 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
5403 }
5404 }
5405 if let Some(fallback) = fallback.take() {
5406 self.finish_state(helper, fallback)?;
5407 }
5408 match artifact {
5409 DeserializerArtifact::None => unreachable!(),
5410 DeserializerArtifact::Data(data) => {
5411 self.store_any(data)?;
5412 *self.state__ = S::Done__;
5413 Ok(ElementHandlerOutput::from_event(event, allow_any))
5414 }
5415 DeserializerArtifact::Deserializer(deserializer) => {
5416 fallback.get_or_insert(S::Any(Some(deserializer)));
5417 *self.state__ = S::Done__;
5418 Ok(ElementHandlerOutput::from_event(event, allow_any))
5419 }
5420 }
5421 }
5422 }
5423 impl<'de> Deserializer<'de, super::DefaultOpenContent> for Box<DefaultOpenContentDeserializer> {
5424 fn init(
5425 helper: &mut DeserializeHelper,
5426 event: Event<'de>,
5427 ) -> DeserializerResult<'de, super::DefaultOpenContent> {
5428 helper.init_deserializer_from_start_event(
5429 event,
5430 DefaultOpenContentDeserializer::from_bytes_start,
5431 )
5432 }
5433 fn next(
5434 mut self,
5435 helper: &mut DeserializeHelper,
5436 event: Event<'de>,
5437 ) -> DeserializerResult<'de, super::DefaultOpenContent> {
5438 use DefaultOpenContentDeserializerState as S;
5439 let mut event = event;
5440 let mut fallback = None;
5441 let mut allow_any_element = false;
5442 let (event, allow_any) = loop {
5443 let state = replace(&mut *self.state__, S::Unknown__);
5444 event = match (state, event) {
5445 (S::Unknown__, _) => unreachable!(),
5446 (S::Annotation(Some(deserializer)), event) => {
5447 let output = deserializer.next(helper, event)?;
5448 match self.handle_annotation(helper, output, &mut fallback)? {
5449 ElementHandlerOutput::Continue { event, allow_any } => {
5450 allow_any_element = allow_any_element || allow_any;
5451 event
5452 }
5453 ElementHandlerOutput::Break { event, allow_any } => {
5454 break (event, allow_any)
5455 }
5456 }
5457 }
5458 (S::Any(Some(deserializer)), event) => {
5459 let output = deserializer.next(helper, event)?;
5460 match self.handle_any(helper, output, &mut fallback)? {
5461 ElementHandlerOutput::Continue { event, allow_any } => {
5462 allow_any_element = allow_any_element || allow_any;
5463 event
5464 }
5465 ElementHandlerOutput::Break { event, allow_any } => {
5466 break (event, allow_any)
5467 }
5468 }
5469 }
5470 (_, Event::End(_)) => {
5471 if let Some(fallback) = fallback.take() {
5472 self.finish_state(helper, fallback)?;
5473 }
5474 return Ok(DeserializerOutput {
5475 artifact: DeserializerArtifact::Data(self.finish(helper)?),
5476 event: DeserializerEvent::None,
5477 allow_any: false,
5478 });
5479 }
5480 (S::Init__, event) => {
5481 fallback.get_or_insert(S::Init__);
5482 *self.state__ = S::Annotation(None);
5483 event
5484 }
5485 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
5486 let output = helper.init_start_tag_deserializer(
5487 event,
5488 Some(&super::NS_XS),
5489 b"annotation",
5490 false,
5491 )?;
5492 match self.handle_annotation(helper, output, &mut fallback)? {
5493 ElementHandlerOutput::Continue { event, allow_any } => {
5494 allow_any_element = allow_any_element || allow_any;
5495 event
5496 }
5497 ElementHandlerOutput::Break { event, allow_any } => {
5498 break (event, allow_any)
5499 }
5500 }
5501 }
5502 (S::Any(None), event @ (Event::Start(_) | Event::Empty(_))) => {
5503 let output = helper.init_start_tag_deserializer(
5504 event,
5505 Some(&super::NS_XS),
5506 b"any",
5507 false,
5508 )?;
5509 match self.handle_any(helper, output, &mut fallback)? {
5510 ElementHandlerOutput::Continue { event, allow_any } => {
5511 allow_any_element = allow_any_element || allow_any;
5512 event
5513 }
5514 ElementHandlerOutput::Break { event, allow_any } => {
5515 break (event, allow_any)
5516 }
5517 }
5518 }
5519 (S::Done__, event) => {
5520 *self.state__ = S::Done__;
5521 break (DeserializerEvent::Continue(event), allow_any_element);
5522 }
5523 (state, event) => {
5524 *self.state__ = state;
5525 break (DeserializerEvent::Break(event), false);
5526 }
5527 }
5528 };
5529 if let Some(fallback) = fallback {
5530 *self.state__ = fallback;
5531 }
5532 Ok(DeserializerOutput {
5533 artifact: DeserializerArtifact::Deserializer(self),
5534 event,
5535 allow_any,
5536 })
5537 }
5538 fn finish(
5539 mut self,
5540 helper: &mut DeserializeHelper,
5541 ) -> Result<super::DefaultOpenContent, Error> {
5542 let state = replace(
5543 &mut *self.state__,
5544 DefaultOpenContentDeserializerState::Unknown__,
5545 );
5546 self.finish_state(helper, state)?;
5547 Ok(super::DefaultOpenContent {
5548 id: self.id,
5549 applies_to_empty: self.applies_to_empty,
5550 mode: self.mode,
5551 annotation: self.annotation,
5552 any: helper.finish_element("any", self.any)?,
5553 })
5554 }
5555 }
5556 #[derive(Debug)]
5557 pub struct SimpleBaseTypeDeserializer {
5558 id: Option<String>,
5559 final_: Option<super::SimpleDerivationSetType>,
5560 name: Option<String>,
5561 content: Vec<super::SimpleBaseTypeContent>,
5562 state__: Box<SimpleBaseTypeDeserializerState>,
5563 }
5564 #[derive(Debug)]
5565 enum SimpleBaseTypeDeserializerState {
5566 Init__,
5567 Next__,
5568 Content__(<super::SimpleBaseTypeContent as WithDeserializer>::Deserializer),
5569 Unknown__,
5570 }
5571 impl SimpleBaseTypeDeserializer {
5572 fn from_bytes_start(
5573 helper: &mut DeserializeHelper,
5574 bytes_start: &BytesStart<'_>,
5575 ) -> Result<Box<Self>, Error> {
5576 let mut id: Option<String> = None;
5577 let mut final_: Option<super::SimpleDerivationSetType> = None;
5578 let mut name: Option<String> = None;
5579 for attrib in helper.filter_xmlns_attributes(bytes_start) {
5580 let attrib = attrib?;
5581 if matches!(
5582 helper.resolve_local_name(attrib.key, &super::NS_XS),
5583 Some(b"id")
5584 ) {
5585 helper.read_attrib(&mut id, b"id", &attrib.value)?;
5586 } else if matches!(
5587 helper.resolve_local_name(attrib.key, &super::NS_XS),
5588 Some(b"final")
5589 ) {
5590 helper.read_attrib(&mut final_, b"final", &attrib.value)?;
5591 } else if matches!(
5592 helper.resolve_local_name(attrib.key, &super::NS_XS),
5593 Some(b"name")
5594 ) {
5595 helper.read_attrib(&mut name, b"name", &attrib.value)?;
5596 }
5597 }
5598 Ok(Box::new(Self {
5599 id: id,
5600 final_: final_,
5601 name: name,
5602 content: Vec::new(),
5603 state__: Box::new(SimpleBaseTypeDeserializerState::Init__),
5604 }))
5605 }
5606 fn finish_state(
5607 &mut self,
5608 helper: &mut DeserializeHelper,
5609 state: SimpleBaseTypeDeserializerState,
5610 ) -> Result<(), Error> {
5611 if let SimpleBaseTypeDeserializerState::Content__(deserializer) = state {
5612 self.store_content(deserializer.finish(helper)?)?;
5613 }
5614 Ok(())
5615 }
5616 fn store_content(&mut self, value: super::SimpleBaseTypeContent) -> Result<(), Error> {
5617 self.content.push(value);
5618 Ok(())
5619 }
5620 fn handle_content<'de>(
5621 &mut self,
5622 helper: &mut DeserializeHelper,
5623 output: DeserializerOutput<'de, super::SimpleBaseTypeContent>,
5624 fallback: &mut Option<SimpleBaseTypeDeserializerState>,
5625 ) -> Result<ElementHandlerOutput<'de>, Error> {
5626 use SimpleBaseTypeDeserializerState as S;
5627 let DeserializerOutput {
5628 artifact,
5629 event,
5630 allow_any,
5631 } = output;
5632 if artifact.is_none() {
5633 *self.state__ = fallback.take().unwrap_or(S::Next__);
5634 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
5635 }
5636 if let Some(fallback) = fallback.take() {
5637 self.finish_state(helper, fallback)?;
5638 }
5639 match artifact {
5640 DeserializerArtifact::None => unreachable!(),
5641 DeserializerArtifact::Data(data) => {
5642 self.store_content(data)?;
5643 *self.state__ = S::Next__;
5644 Ok(ElementHandlerOutput::from_event(event, allow_any))
5645 }
5646 DeserializerArtifact::Deserializer(deserializer) => {
5647 if self.content.len() < 1usize {
5648 *fallback = Some(S::Content__(deserializer));
5649 *self.state__ = S::Next__;
5650 Ok(ElementHandlerOutput::from_event(event, allow_any))
5651 } else {
5652 *self.state__ = S::Content__(deserializer);
5653 Ok(ElementHandlerOutput::from_event_end(event, allow_any))
5654 }
5655 }
5656 }
5657 }
5658 }
5659 impl<'de> Deserializer<'de, super::SimpleBaseType> for Box<SimpleBaseTypeDeserializer> {
5660 fn init(
5661 helper: &mut DeserializeHelper,
5662 event: Event<'de>,
5663 ) -> DeserializerResult<'de, super::SimpleBaseType> {
5664 helper.init_deserializer_from_start_event(
5665 event,
5666 SimpleBaseTypeDeserializer::from_bytes_start,
5667 )
5668 }
5669 fn next(
5670 mut self,
5671 helper: &mut DeserializeHelper,
5672 event: Event<'de>,
5673 ) -> DeserializerResult<'de, super::SimpleBaseType> {
5674 use SimpleBaseTypeDeserializerState as S;
5675 let mut event = event;
5676 let mut fallback = None;
5677 let (event, allow_any) = loop {
5678 let state = replace(&mut *self.state__, S::Unknown__);
5679 event = match (state, event) {
5680 (S::Unknown__, _) => unreachable!(),
5681 (S::Content__(deserializer), event) => {
5682 let output = deserializer.next(helper, event)?;
5683 match self.handle_content(helper, output, &mut fallback)? {
5684 ElementHandlerOutput::Break { event, allow_any } => {
5685 break (event, allow_any)
5686 }
5687 ElementHandlerOutput::Continue { event, .. } => event,
5688 }
5689 }
5690 (_, Event::End(_)) => {
5691 return Ok(DeserializerOutput {
5692 artifact: DeserializerArtifact::Data(self.finish(helper)?),
5693 event: DeserializerEvent::None,
5694 allow_any: false,
5695 });
5696 }
5697 (state @ (S::Init__ | S::Next__), event) => {
5698 fallback.get_or_insert(state);
5699 let output = <super::SimpleBaseTypeContent as WithDeserializer>::init(
5700 helper, event,
5701 )?;
5702 match self.handle_content(helper, output, &mut fallback)? {
5703 ElementHandlerOutput::Break { event, allow_any } => {
5704 break (event, allow_any)
5705 }
5706 ElementHandlerOutput::Continue { event, .. } => event,
5707 }
5708 }
5709 }
5710 };
5711 if let Some(fallback) = fallback {
5712 *self.state__ = fallback;
5713 }
5714 let artifact = DeserializerArtifact::Deserializer(self);
5715 Ok(DeserializerOutput {
5716 artifact,
5717 event,
5718 allow_any,
5719 })
5720 }
5721 fn finish(
5722 mut self,
5723 helper: &mut DeserializeHelper,
5724 ) -> Result<super::SimpleBaseType, Error> {
5725 let state = replace(
5726 &mut *self.state__,
5727 SimpleBaseTypeDeserializerState::Unknown__,
5728 );
5729 self.finish_state(helper, state)?;
5730 Ok(super::SimpleBaseType {
5731 id: self.id,
5732 final_: self.final_,
5733 name: self.name,
5734 content: helper.finish_vec(1usize, Some(2usize), self.content)?,
5735 })
5736 }
5737 }
5738 #[derive(Debug)]
5739 pub struct SimpleBaseTypeContentDeserializer {
5740 state__: Box<SimpleBaseTypeContentDeserializerState>,
5741 }
5742 #[derive(Debug)]
5743 pub enum SimpleBaseTypeContentDeserializerState {
5744 Init__,
5745 Annotation(
5746 Option<super::Annotation>,
5747 Option<<super::Annotation as WithDeserializer>::Deserializer>,
5748 Option<<super::Annotation as WithDeserializer>::Deserializer>,
5749 ),
5750 Restriction(
5751 Option<super::Restriction>,
5752 Option<<super::Restriction as WithDeserializer>::Deserializer>,
5753 Option<<super::Restriction as WithDeserializer>::Deserializer>,
5754 ),
5755 List(
5756 Option<super::List>,
5757 Option<<super::List as WithDeserializer>::Deserializer>,
5758 Option<<super::List as WithDeserializer>::Deserializer>,
5759 ),
5760 Union(
5761 Option<super::Union>,
5762 Option<<super::Union as WithDeserializer>::Deserializer>,
5763 Option<<super::Union as WithDeserializer>::Deserializer>,
5764 ),
5765 Done__(super::SimpleBaseTypeContent),
5766 Unknown__,
5767 }
5768 impl SimpleBaseTypeContentDeserializer {
5769 fn find_suitable<'de>(
5770 &mut self,
5771 helper: &mut DeserializeHelper,
5772 event: Event<'de>,
5773 ) -> Result<ElementHandlerOutput<'de>, Error> {
5774 if let Event::Start(x) | Event::Empty(x) = &event {
5775 if matches!(
5776 helper.resolve_local_name(x.name(), &super::NS_XS),
5777 Some(b"annotation")
5778 ) {
5779 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
5780 return self.handle_annotation(helper, Default::default(), None, output);
5781 }
5782 if matches!(
5783 helper.resolve_local_name(x.name(), &super::NS_XS),
5784 Some(b"restriction")
5785 ) {
5786 let output = <super::Restriction as WithDeserializer>::init(helper, event)?;
5787 return self.handle_restriction(helper, Default::default(), None, output);
5788 }
5789 if matches!(
5790 helper.resolve_local_name(x.name(), &super::NS_XS),
5791 Some(b"list")
5792 ) {
5793 let output = <super::List as WithDeserializer>::init(helper, event)?;
5794 return self.handle_list(helper, Default::default(), None, output);
5795 }
5796 if matches!(
5797 helper.resolve_local_name(x.name(), &super::NS_XS),
5798 Some(b"union")
5799 ) {
5800 let output = <super::Union as WithDeserializer>::init(helper, event)?;
5801 return self.handle_union_(helper, Default::default(), None, output);
5802 }
5803 }
5804 *self.state__ = SimpleBaseTypeContentDeserializerState::Init__;
5805 Ok(ElementHandlerOutput::return_to_parent(event, false))
5806 }
5807 fn finish_state(
5808 helper: &mut DeserializeHelper,
5809 state: SimpleBaseTypeContentDeserializerState,
5810 ) -> Result<super::SimpleBaseTypeContent, Error> {
5811 use SimpleBaseTypeContentDeserializerState as S;
5812 match state {
5813 S::Init__ => Err(ErrorKind::MissingContent.into()),
5814 S::Annotation(mut values, None, deserializer) => {
5815 if let Some(deserializer) = deserializer {
5816 let value = deserializer.finish(helper)?;
5817 SimpleBaseTypeContentDeserializer::store_annotation(&mut values, value)?;
5818 }
5819 Ok(super::SimpleBaseTypeContent::Annotation(
5820 helper.finish_element("annotation", values)?,
5821 ))
5822 }
5823 S::Restriction(mut values, None, deserializer) => {
5824 if let Some(deserializer) = deserializer {
5825 let value = deserializer.finish(helper)?;
5826 SimpleBaseTypeContentDeserializer::store_restriction(&mut values, value)?;
5827 }
5828 Ok(super::SimpleBaseTypeContent::Restriction(
5829 helper.finish_element("restriction", values)?,
5830 ))
5831 }
5832 S::List(mut values, None, deserializer) => {
5833 if let Some(deserializer) = deserializer {
5834 let value = deserializer.finish(helper)?;
5835 SimpleBaseTypeContentDeserializer::store_list(&mut values, value)?;
5836 }
5837 Ok(super::SimpleBaseTypeContent::List(
5838 helper.finish_element("list", values)?,
5839 ))
5840 }
5841 S::Union(mut values, None, deserializer) => {
5842 if let Some(deserializer) = deserializer {
5843 let value = deserializer.finish(helper)?;
5844 SimpleBaseTypeContentDeserializer::store_union_(&mut values, value)?;
5845 }
5846 Ok(super::SimpleBaseTypeContent::Union(
5847 helper.finish_element("union", values)?,
5848 ))
5849 }
5850 S::Done__(data) => Ok(data),
5851 _ => unreachable!(),
5852 }
5853 }
5854 fn store_annotation(
5855 values: &mut Option<super::Annotation>,
5856 value: super::Annotation,
5857 ) -> Result<(), Error> {
5858 if values.is_some() {
5859 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
5860 b"annotation",
5861 )))?;
5862 }
5863 *values = Some(value);
5864 Ok(())
5865 }
5866 fn store_restriction(
5867 values: &mut Option<super::Restriction>,
5868 value: super::Restriction,
5869 ) -> Result<(), Error> {
5870 if values.is_some() {
5871 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
5872 b"restriction",
5873 )))?;
5874 }
5875 *values = Some(value);
5876 Ok(())
5877 }
5878 fn store_list(values: &mut Option<super::List>, value: super::List) -> Result<(), Error> {
5879 if values.is_some() {
5880 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"list")))?;
5881 }
5882 *values = Some(value);
5883 Ok(())
5884 }
5885 fn store_union_(
5886 values: &mut Option<super::Union>,
5887 value: super::Union,
5888 ) -> Result<(), Error> {
5889 if values.is_some() {
5890 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
5891 b"union",
5892 )))?;
5893 }
5894 *values = Some(value);
5895 Ok(())
5896 }
5897 fn handle_annotation<'de>(
5898 &mut self,
5899 helper: &mut DeserializeHelper,
5900 mut values: Option<super::Annotation>,
5901 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
5902 output: DeserializerOutput<'de, super::Annotation>,
5903 ) -> Result<ElementHandlerOutput<'de>, Error> {
5904 use SimpleBaseTypeContentDeserializerState as S;
5905 let DeserializerOutput {
5906 artifact,
5907 event,
5908 allow_any,
5909 } = output;
5910 if artifact.is_none() {
5911 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
5912 }
5913 if let Some(deserializer) = fallback {
5914 let data = deserializer.finish(helper)?;
5915 SimpleBaseTypeContentDeserializer::store_annotation(&mut values, data)?;
5916 }
5917 match artifact {
5918 DeserializerArtifact::None => unreachable!(),
5919 DeserializerArtifact::Data(data) => {
5920 SimpleBaseTypeContentDeserializer::store_annotation(&mut values, data)?;
5921 let data = SimpleBaseTypeContentDeserializer::finish_state(
5922 helper,
5923 S::Annotation(values, None, None),
5924 )?;
5925 *self.state__ = S::Done__(data);
5926 Ok(ElementHandlerOutput::break_(event, allow_any))
5927 }
5928 DeserializerArtifact::Deserializer(deserializer) => {
5929 *self.state__ = S::Annotation(values, None, Some(deserializer));
5930 Ok(ElementHandlerOutput::break_(event, allow_any))
5931 }
5932 }
5933 }
5934 fn handle_restriction<'de>(
5935 &mut self,
5936 helper: &mut DeserializeHelper,
5937 mut values: Option<super::Restriction>,
5938 fallback: Option<<super::Restriction as WithDeserializer>::Deserializer>,
5939 output: DeserializerOutput<'de, super::Restriction>,
5940 ) -> Result<ElementHandlerOutput<'de>, Error> {
5941 use SimpleBaseTypeContentDeserializerState as S;
5942 let DeserializerOutput {
5943 artifact,
5944 event,
5945 allow_any,
5946 } = output;
5947 if artifact.is_none() {
5948 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
5949 }
5950 if let Some(deserializer) = fallback {
5951 let data = deserializer.finish(helper)?;
5952 SimpleBaseTypeContentDeserializer::store_restriction(&mut values, data)?;
5953 }
5954 match artifact {
5955 DeserializerArtifact::None => unreachable!(),
5956 DeserializerArtifact::Data(data) => {
5957 SimpleBaseTypeContentDeserializer::store_restriction(&mut values, data)?;
5958 let data = SimpleBaseTypeContentDeserializer::finish_state(
5959 helper,
5960 S::Restriction(values, None, None),
5961 )?;
5962 *self.state__ = S::Done__(data);
5963 Ok(ElementHandlerOutput::break_(event, allow_any))
5964 }
5965 DeserializerArtifact::Deserializer(deserializer) => {
5966 *self.state__ = S::Restriction(values, None, Some(deserializer));
5967 Ok(ElementHandlerOutput::break_(event, allow_any))
5968 }
5969 }
5970 }
5971 fn handle_list<'de>(
5972 &mut self,
5973 helper: &mut DeserializeHelper,
5974 mut values: Option<super::List>,
5975 fallback: Option<<super::List as WithDeserializer>::Deserializer>,
5976 output: DeserializerOutput<'de, super::List>,
5977 ) -> Result<ElementHandlerOutput<'de>, Error> {
5978 use SimpleBaseTypeContentDeserializerState as S;
5979 let DeserializerOutput {
5980 artifact,
5981 event,
5982 allow_any,
5983 } = output;
5984 if artifact.is_none() {
5985 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
5986 }
5987 if let Some(deserializer) = fallback {
5988 let data = deserializer.finish(helper)?;
5989 SimpleBaseTypeContentDeserializer::store_list(&mut values, data)?;
5990 }
5991 match artifact {
5992 DeserializerArtifact::None => unreachable!(),
5993 DeserializerArtifact::Data(data) => {
5994 SimpleBaseTypeContentDeserializer::store_list(&mut values, data)?;
5995 let data = SimpleBaseTypeContentDeserializer::finish_state(
5996 helper,
5997 S::List(values, None, None),
5998 )?;
5999 *self.state__ = S::Done__(data);
6000 Ok(ElementHandlerOutput::break_(event, allow_any))
6001 }
6002 DeserializerArtifact::Deserializer(deserializer) => {
6003 *self.state__ = S::List(values, None, Some(deserializer));
6004 Ok(ElementHandlerOutput::break_(event, allow_any))
6005 }
6006 }
6007 }
6008 fn handle_union_<'de>(
6009 &mut self,
6010 helper: &mut DeserializeHelper,
6011 mut values: Option<super::Union>,
6012 fallback: Option<<super::Union as WithDeserializer>::Deserializer>,
6013 output: DeserializerOutput<'de, super::Union>,
6014 ) -> Result<ElementHandlerOutput<'de>, Error> {
6015 use SimpleBaseTypeContentDeserializerState as S;
6016 let DeserializerOutput {
6017 artifact,
6018 event,
6019 allow_any,
6020 } = output;
6021 if artifact.is_none() {
6022 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
6023 }
6024 if let Some(deserializer) = fallback {
6025 let data = deserializer.finish(helper)?;
6026 SimpleBaseTypeContentDeserializer::store_union_(&mut values, data)?;
6027 }
6028 match artifact {
6029 DeserializerArtifact::None => unreachable!(),
6030 DeserializerArtifact::Data(data) => {
6031 SimpleBaseTypeContentDeserializer::store_union_(&mut values, data)?;
6032 let data = SimpleBaseTypeContentDeserializer::finish_state(
6033 helper,
6034 S::Union(values, None, None),
6035 )?;
6036 *self.state__ = S::Done__(data);
6037 Ok(ElementHandlerOutput::break_(event, allow_any))
6038 }
6039 DeserializerArtifact::Deserializer(deserializer) => {
6040 *self.state__ = S::Union(values, None, Some(deserializer));
6041 Ok(ElementHandlerOutput::break_(event, allow_any))
6042 }
6043 }
6044 }
6045 }
6046 impl<'de> Deserializer<'de, super::SimpleBaseTypeContent>
6047 for Box<SimpleBaseTypeContentDeserializer>
6048 {
6049 fn init(
6050 helper: &mut DeserializeHelper,
6051 event: Event<'de>,
6052 ) -> DeserializerResult<'de, super::SimpleBaseTypeContent> {
6053 let deserializer = Box::new(SimpleBaseTypeContentDeserializer {
6054 state__: Box::new(SimpleBaseTypeContentDeserializerState::Init__),
6055 });
6056 let mut output = deserializer.next(helper, event)?;
6057 output.artifact = match output.artifact {
6058 DeserializerArtifact::Deserializer(x)
6059 if matches!(&*x.state__, SimpleBaseTypeContentDeserializerState::Init__) =>
6060 {
6061 DeserializerArtifact::None
6062 }
6063 artifact => artifact,
6064 };
6065 Ok(output)
6066 }
6067 fn next(
6068 mut self,
6069 helper: &mut DeserializeHelper,
6070 event: Event<'de>,
6071 ) -> DeserializerResult<'de, super::SimpleBaseTypeContent> {
6072 use SimpleBaseTypeContentDeserializerState as S;
6073 let mut event = event;
6074 let (event, allow_any) = loop {
6075 let state = replace(&mut *self.state__, S::Unknown__);
6076 event = match (state, event) {
6077 (S::Unknown__, _) => unreachable!(),
6078 (S::Annotation(values, fallback, Some(deserializer)), event) => {
6079 let output = deserializer.next(helper, event)?;
6080 match self.handle_annotation(helper, values, fallback, output)? {
6081 ElementHandlerOutput::Break { event, allow_any } => {
6082 break (event, allow_any)
6083 }
6084 ElementHandlerOutput::Continue { event, .. } => event,
6085 }
6086 }
6087 (S::Restriction(values, fallback, Some(deserializer)), event) => {
6088 let output = deserializer.next(helper, event)?;
6089 match self.handle_restriction(helper, values, fallback, output)? {
6090 ElementHandlerOutput::Break { event, allow_any } => {
6091 break (event, allow_any)
6092 }
6093 ElementHandlerOutput::Continue { event, .. } => event,
6094 }
6095 }
6096 (S::List(values, fallback, Some(deserializer)), event) => {
6097 let output = deserializer.next(helper, event)?;
6098 match self.handle_list(helper, values, fallback, output)? {
6099 ElementHandlerOutput::Break { event, allow_any } => {
6100 break (event, allow_any)
6101 }
6102 ElementHandlerOutput::Continue { event, .. } => event,
6103 }
6104 }
6105 (S::Union(values, fallback, Some(deserializer)), event) => {
6106 let output = deserializer.next(helper, event)?;
6107 match self.handle_union_(helper, values, fallback, output)? {
6108 ElementHandlerOutput::Break { event, allow_any } => {
6109 break (event, allow_any)
6110 }
6111 ElementHandlerOutput::Continue { event, .. } => event,
6112 }
6113 }
6114 (state, event @ Event::End(_)) => {
6115 return Ok(DeserializerOutput {
6116 artifact: DeserializerArtifact::Data(
6117 SimpleBaseTypeContentDeserializer::finish_state(helper, state)?,
6118 ),
6119 event: DeserializerEvent::Continue(event),
6120 allow_any: false,
6121 });
6122 }
6123 (S::Init__, event) => match self.find_suitable(helper, event)? {
6124 ElementHandlerOutput::Break { event, allow_any } => {
6125 break (event, allow_any)
6126 }
6127 ElementHandlerOutput::Continue { event, .. } => event,
6128 },
6129 (
6130 S::Annotation(values, fallback, None),
6131 event @ (Event::Start(_) | Event::Empty(_)),
6132 ) => {
6133 let output = helper.init_start_tag_deserializer(
6134 event,
6135 Some(&super::NS_XS),
6136 b"annotation",
6137 false,
6138 )?;
6139 match self.handle_annotation(helper, values, fallback, output)? {
6140 ElementHandlerOutput::Break { event, allow_any } => {
6141 break (event, allow_any)
6142 }
6143 ElementHandlerOutput::Continue { event, .. } => event,
6144 }
6145 }
6146 (
6147 S::Restriction(values, fallback, None),
6148 event @ (Event::Start(_) | Event::Empty(_)),
6149 ) => {
6150 let output = helper.init_start_tag_deserializer(
6151 event,
6152 Some(&super::NS_XS),
6153 b"restriction",
6154 true,
6155 )?;
6156 match self.handle_restriction(helper, values, fallback, output)? {
6157 ElementHandlerOutput::Break { event, allow_any } => {
6158 break (event, allow_any)
6159 }
6160 ElementHandlerOutput::Continue { event, .. } => event,
6161 }
6162 }
6163 (
6164 S::List(values, fallback, None),
6165 event @ (Event::Start(_) | Event::Empty(_)),
6166 ) => {
6167 let output = helper.init_start_tag_deserializer(
6168 event,
6169 Some(&super::NS_XS),
6170 b"list",
6171 false,
6172 )?;
6173 match self.handle_list(helper, values, fallback, output)? {
6174 ElementHandlerOutput::Break { event, allow_any } => {
6175 break (event, allow_any)
6176 }
6177 ElementHandlerOutput::Continue { event, .. } => event,
6178 }
6179 }
6180 (
6181 S::Union(values, fallback, None),
6182 event @ (Event::Start(_) | Event::Empty(_)),
6183 ) => {
6184 let output = helper.init_start_tag_deserializer(
6185 event,
6186 Some(&super::NS_XS),
6187 b"union",
6188 false,
6189 )?;
6190 match self.handle_union_(helper, values, fallback, output)? {
6191 ElementHandlerOutput::Break { event, allow_any } => {
6192 break (event, allow_any)
6193 }
6194 ElementHandlerOutput::Continue { event, .. } => event,
6195 }
6196 }
6197 (state @ S::Done__(_), event) => {
6198 *self.state__ = state;
6199 break (DeserializerEvent::Continue(event), false);
6200 }
6201 (state, event) => {
6202 *self.state__ = state;
6203 break (DeserializerEvent::Continue(event), false);
6204 }
6205 }
6206 };
6207 let artifact = if matches!(&*self.state__, S::Done__(_)) {
6208 DeserializerArtifact::Data(self.finish(helper)?)
6209 } else {
6210 DeserializerArtifact::Deserializer(self)
6211 };
6212 Ok(DeserializerOutput {
6213 artifact,
6214 event,
6215 allow_any,
6216 })
6217 }
6218 fn finish(
6219 self,
6220 helper: &mut DeserializeHelper,
6221 ) -> Result<super::SimpleBaseTypeContent, Error> {
6222 SimpleBaseTypeContentDeserializer::finish_state(helper, *self.state__)
6223 }
6224 }
6225 #[derive(Debug)]
6226 pub struct ComplexBaseTypeDeserializer {
6227 id: Option<String>,
6228 name: Option<String>,
6229 mixed: Option<bool>,
6230 abstract_: bool,
6231 final_: Option<super::DerivationSetType>,
6232 block: Option<super::DerivationSetType>,
6233 default_attributes_apply: bool,
6234 content: Vec<super::ComplexBaseTypeContent>,
6235 state__: Box<ComplexBaseTypeDeserializerState>,
6236 }
6237 #[derive(Debug)]
6238 enum ComplexBaseTypeDeserializerState {
6239 Init__,
6240 Next__,
6241 Content__(<super::ComplexBaseTypeContent as WithDeserializer>::Deserializer),
6242 Unknown__,
6243 }
6244 impl ComplexBaseTypeDeserializer {
6245 fn from_bytes_start(
6246 helper: &mut DeserializeHelper,
6247 bytes_start: &BytesStart<'_>,
6248 ) -> Result<Box<Self>, Error> {
6249 let mut id: Option<String> = None;
6250 let mut name: Option<String> = None;
6251 let mut mixed: Option<bool> = None;
6252 let mut abstract_: Option<bool> = None;
6253 let mut final_: Option<super::DerivationSetType> = None;
6254 let mut block: Option<super::DerivationSetType> = None;
6255 let mut default_attributes_apply: Option<bool> = None;
6256 for attrib in helper.filter_xmlns_attributes(bytes_start) {
6257 let attrib = attrib?;
6258 if matches!(
6259 helper.resolve_local_name(attrib.key, &super::NS_XS),
6260 Some(b"id")
6261 ) {
6262 helper.read_attrib(&mut id, b"id", &attrib.value)?;
6263 } else if matches!(
6264 helper.resolve_local_name(attrib.key, &super::NS_XS),
6265 Some(b"name")
6266 ) {
6267 helper.read_attrib(&mut name, b"name", &attrib.value)?;
6268 } else if matches!(
6269 helper.resolve_local_name(attrib.key, &super::NS_XS),
6270 Some(b"mixed")
6271 ) {
6272 helper.read_attrib(&mut mixed, b"mixed", &attrib.value)?;
6273 } else if matches!(
6274 helper.resolve_local_name(attrib.key, &super::NS_XS),
6275 Some(b"abstract")
6276 ) {
6277 helper.read_attrib(&mut abstract_, b"abstract", &attrib.value)?;
6278 } else if matches!(
6279 helper.resolve_local_name(attrib.key, &super::NS_XS),
6280 Some(b"final")
6281 ) {
6282 helper.read_attrib(&mut final_, b"final", &attrib.value)?;
6283 } else if matches!(
6284 helper.resolve_local_name(attrib.key, &super::NS_XS),
6285 Some(b"block")
6286 ) {
6287 helper.read_attrib(&mut block, b"block", &attrib.value)?;
6288 } else if matches!(
6289 helper.resolve_local_name(attrib.key, &super::NS_XS),
6290 Some(b"defaultAttributesApply")
6291 ) {
6292 helper.read_attrib(
6293 &mut default_attributes_apply,
6294 b"defaultAttributesApply",
6295 &attrib.value,
6296 )?;
6297 }
6298 }
6299 Ok(Box::new(Self {
6300 id: id,
6301 name: name,
6302 mixed: mixed,
6303 abstract_: abstract_.unwrap_or_else(super::ComplexBaseType::default_abstract_),
6304 final_: final_,
6305 block: block,
6306 default_attributes_apply: default_attributes_apply
6307 .unwrap_or_else(super::ComplexBaseType::default_default_attributes_apply),
6308 content: Vec::new(),
6309 state__: Box::new(ComplexBaseTypeDeserializerState::Init__),
6310 }))
6311 }
6312 fn finish_state(
6313 &mut self,
6314 helper: &mut DeserializeHelper,
6315 state: ComplexBaseTypeDeserializerState,
6316 ) -> Result<(), Error> {
6317 if let ComplexBaseTypeDeserializerState::Content__(deserializer) = state {
6318 self.store_content(deserializer.finish(helper)?)?;
6319 }
6320 Ok(())
6321 }
6322 fn store_content(&mut self, value: super::ComplexBaseTypeContent) -> Result<(), Error> {
6323 self.content.push(value);
6324 Ok(())
6325 }
6326 fn handle_content<'de>(
6327 &mut self,
6328 helper: &mut DeserializeHelper,
6329 output: DeserializerOutput<'de, super::ComplexBaseTypeContent>,
6330 fallback: &mut Option<ComplexBaseTypeDeserializerState>,
6331 ) -> Result<ElementHandlerOutput<'de>, Error> {
6332 use ComplexBaseTypeDeserializerState as S;
6333 let DeserializerOutput {
6334 artifact,
6335 event,
6336 allow_any,
6337 } = output;
6338 if artifact.is_none() {
6339 *self.state__ = fallback.take().unwrap_or(S::Next__);
6340 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
6341 }
6342 if let Some(fallback) = fallback.take() {
6343 self.finish_state(helper, fallback)?;
6344 }
6345 match artifact {
6346 DeserializerArtifact::None => unreachable!(),
6347 DeserializerArtifact::Data(data) => {
6348 self.store_content(data)?;
6349 *self.state__ = S::Next__;
6350 Ok(ElementHandlerOutput::from_event(event, allow_any))
6351 }
6352 DeserializerArtifact::Deserializer(deserializer) => {
6353 *fallback = Some(S::Content__(deserializer));
6354 *self.state__ = S::Next__;
6355 Ok(ElementHandlerOutput::from_event(event, allow_any))
6356 }
6357 }
6358 }
6359 }
6360 impl<'de> Deserializer<'de, super::ComplexBaseType> for Box<ComplexBaseTypeDeserializer> {
6361 fn init(
6362 helper: &mut DeserializeHelper,
6363 event: Event<'de>,
6364 ) -> DeserializerResult<'de, super::ComplexBaseType> {
6365 helper.init_deserializer_from_start_event(
6366 event,
6367 ComplexBaseTypeDeserializer::from_bytes_start,
6368 )
6369 }
6370 fn next(
6371 mut self,
6372 helper: &mut DeserializeHelper,
6373 event: Event<'de>,
6374 ) -> DeserializerResult<'de, super::ComplexBaseType> {
6375 use ComplexBaseTypeDeserializerState as S;
6376 let mut event = event;
6377 let mut fallback = None;
6378 let (event, allow_any) = loop {
6379 let state = replace(&mut *self.state__, S::Unknown__);
6380 event = match (state, event) {
6381 (S::Unknown__, _) => unreachable!(),
6382 (S::Content__(deserializer), event) => {
6383 let output = deserializer.next(helper, event)?;
6384 match self.handle_content(helper, output, &mut fallback)? {
6385 ElementHandlerOutput::Break { event, allow_any } => {
6386 break (event, allow_any)
6387 }
6388 ElementHandlerOutput::Continue { event, .. } => event,
6389 }
6390 }
6391 (_, Event::End(_)) => {
6392 return Ok(DeserializerOutput {
6393 artifact: DeserializerArtifact::Data(self.finish(helper)?),
6394 event: DeserializerEvent::None,
6395 allow_any: false,
6396 });
6397 }
6398 (state @ (S::Init__ | S::Next__), event) => {
6399 fallback.get_or_insert(state);
6400 let output = <super::ComplexBaseTypeContent as WithDeserializer>::init(
6401 helper, event,
6402 )?;
6403 match self.handle_content(helper, output, &mut fallback)? {
6404 ElementHandlerOutput::Break { event, allow_any } => {
6405 break (event, allow_any)
6406 }
6407 ElementHandlerOutput::Continue { event, .. } => event,
6408 }
6409 }
6410 }
6411 };
6412 if let Some(fallback) = fallback {
6413 *self.state__ = fallback;
6414 }
6415 let artifact = DeserializerArtifact::Deserializer(self);
6416 Ok(DeserializerOutput {
6417 artifact,
6418 event,
6419 allow_any,
6420 })
6421 }
6422 fn finish(
6423 mut self,
6424 helper: &mut DeserializeHelper,
6425 ) -> Result<super::ComplexBaseType, Error> {
6426 let state = replace(
6427 &mut *self.state__,
6428 ComplexBaseTypeDeserializerState::Unknown__,
6429 );
6430 self.finish_state(helper, state)?;
6431 Ok(super::ComplexBaseType {
6432 id: self.id,
6433 name: self.name,
6434 mixed: self.mixed,
6435 abstract_: self.abstract_,
6436 final_: self.final_,
6437 block: self.block,
6438 default_attributes_apply: self.default_attributes_apply,
6439 content: helper.finish_vec(0usize, None, self.content)?,
6440 })
6441 }
6442 }
6443 #[derive(Debug)]
6444 pub struct ComplexBaseTypeContentDeserializer {
6445 state__: Box<ComplexBaseTypeContentDeserializerState>,
6446 }
6447 #[derive(Debug)]
6448 pub enum ComplexBaseTypeContentDeserializerState {
6449 Init__,
6450 Annotation(
6451 Option<super::Annotation>,
6452 Option<<super::Annotation as WithDeserializer>::Deserializer>,
6453 Option<<super::Annotation as WithDeserializer>::Deserializer>,
6454 ),
6455 SimpleContent(
6456 Option<super::SimpleContent>,
6457 Option<<super::SimpleContent as WithDeserializer>::Deserializer>,
6458 Option<<super::SimpleContent as WithDeserializer>::Deserializer>,
6459 ),
6460 ComplexContent(
6461 Option<super::ComplexContent>,
6462 Option<<super::ComplexContent as WithDeserializer>::Deserializer>,
6463 Option<<super::ComplexContent as WithDeserializer>::Deserializer>,
6464 ),
6465 OpenContent(
6466 Option<super::OpenContent>,
6467 Option<<super::OpenContent as WithDeserializer>::Deserializer>,
6468 Option<<super::OpenContent as WithDeserializer>::Deserializer>,
6469 ),
6470 Group(
6471 Option<super::GroupType>,
6472 Option<<super::GroupType as WithDeserializer>::Deserializer>,
6473 Option<<super::GroupType as WithDeserializer>::Deserializer>,
6474 ),
6475 All(
6476 Option<super::GroupType>,
6477 Option<<super::GroupType as WithDeserializer>::Deserializer>,
6478 Option<<super::GroupType as WithDeserializer>::Deserializer>,
6479 ),
6480 Choice(
6481 Option<super::GroupType>,
6482 Option<<super::GroupType as WithDeserializer>::Deserializer>,
6483 Option<<super::GroupType as WithDeserializer>::Deserializer>,
6484 ),
6485 Sequence(
6486 Option<super::GroupType>,
6487 Option<<super::GroupType as WithDeserializer>::Deserializer>,
6488 Option<<super::GroupType as WithDeserializer>::Deserializer>,
6489 ),
6490 Attribute(
6491 Option<super::AttributeType>,
6492 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
6493 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
6494 ),
6495 AttributeGroup(
6496 Option<super::AttributeGroupType>,
6497 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
6498 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
6499 ),
6500 AnyAttribute(
6501 Option<super::AnyAttribute>,
6502 Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
6503 Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
6504 ),
6505 Assert(
6506 Option<super::AssertionType>,
6507 Option<<super::AssertionType as WithDeserializer>::Deserializer>,
6508 Option<<super::AssertionType as WithDeserializer>::Deserializer>,
6509 ),
6510 Done__(super::ComplexBaseTypeContent),
6511 Unknown__,
6512 }
6513 impl ComplexBaseTypeContentDeserializer {
6514 fn find_suitable<'de>(
6515 &mut self,
6516 helper: &mut DeserializeHelper,
6517 event: Event<'de>,
6518 ) -> Result<ElementHandlerOutput<'de>, Error> {
6519 if let Event::Start(x) | Event::Empty(x) = &event {
6520 if matches!(
6521 helper.resolve_local_name(x.name(), &super::NS_XS),
6522 Some(b"annotation")
6523 ) {
6524 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
6525 return self.handle_annotation(helper, Default::default(), None, output);
6526 }
6527 if matches!(
6528 helper.resolve_local_name(x.name(), &super::NS_XS),
6529 Some(b"simpleContent")
6530 ) {
6531 let output = <super::SimpleContent as WithDeserializer>::init(helper, event)?;
6532 return self.handle_simple_content(helper, Default::default(), None, output);
6533 }
6534 if matches!(
6535 helper.resolve_local_name(x.name(), &super::NS_XS),
6536 Some(b"complexContent")
6537 ) {
6538 let output = <super::ComplexContent as WithDeserializer>::init(helper, event)?;
6539 return self.handle_complex_content(helper, Default::default(), None, output);
6540 }
6541 if matches!(
6542 helper.resolve_local_name(x.name(), &super::NS_XS),
6543 Some(b"openContent")
6544 ) {
6545 let output = <super::OpenContent as WithDeserializer>::init(helper, event)?;
6546 return self.handle_open_content(helper, Default::default(), None, output);
6547 }
6548 if matches!(
6549 helper.resolve_local_name(x.name(), &super::NS_XS),
6550 Some(b"group")
6551 ) {
6552 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
6553 return self.handle_group(helper, Default::default(), None, output);
6554 }
6555 if matches!(
6556 helper.resolve_local_name(x.name(), &super::NS_XS),
6557 Some(b"all")
6558 ) {
6559 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
6560 return self.handle_all(helper, Default::default(), None, output);
6561 }
6562 if matches!(
6563 helper.resolve_local_name(x.name(), &super::NS_XS),
6564 Some(b"choice")
6565 ) {
6566 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
6567 return self.handle_choice(helper, Default::default(), None, output);
6568 }
6569 if matches!(
6570 helper.resolve_local_name(x.name(), &super::NS_XS),
6571 Some(b"sequence")
6572 ) {
6573 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
6574 return self.handle_sequence(helper, Default::default(), None, output);
6575 }
6576 if matches!(
6577 helper.resolve_local_name(x.name(), &super::NS_XS),
6578 Some(b"attribute")
6579 ) {
6580 let output = <super::AttributeType as WithDeserializer>::init(helper, event)?;
6581 return self.handle_attribute(helper, Default::default(), None, output);
6582 }
6583 if matches!(
6584 helper.resolve_local_name(x.name(), &super::NS_XS),
6585 Some(b"attributeGroup")
6586 ) {
6587 let output =
6588 <super::AttributeGroupType as WithDeserializer>::init(helper, event)?;
6589 return self.handle_attribute_group(helper, Default::default(), None, output);
6590 }
6591 if matches!(
6592 helper.resolve_local_name(x.name(), &super::NS_XS),
6593 Some(b"anyAttribute")
6594 ) {
6595 let output = <super::AnyAttribute as WithDeserializer>::init(helper, event)?;
6596 return self.handle_any_attribute(helper, Default::default(), None, output);
6597 }
6598 if matches!(
6599 helper.resolve_local_name(x.name(), &super::NS_XS),
6600 Some(b"assert")
6601 ) {
6602 let output = <super::AssertionType as WithDeserializer>::init(helper, event)?;
6603 return self.handle_assert(helper, Default::default(), None, output);
6604 }
6605 }
6606 *self.state__ = ComplexBaseTypeContentDeserializerState::Init__;
6607 Ok(ElementHandlerOutput::return_to_parent(event, false))
6608 }
6609 fn finish_state(
6610 helper: &mut DeserializeHelper,
6611 state: ComplexBaseTypeContentDeserializerState,
6612 ) -> Result<super::ComplexBaseTypeContent, Error> {
6613 use ComplexBaseTypeContentDeserializerState as S;
6614 match state {
6615 S::Init__ => Err(ErrorKind::MissingContent.into()),
6616 S::Annotation(mut values, None, deserializer) => {
6617 if let Some(deserializer) = deserializer {
6618 let value = deserializer.finish(helper)?;
6619 ComplexBaseTypeContentDeserializer::store_annotation(&mut values, value)?;
6620 }
6621 Ok(super::ComplexBaseTypeContent::Annotation(
6622 helper.finish_element("annotation", values)?,
6623 ))
6624 }
6625 S::SimpleContent(mut values, None, deserializer) => {
6626 if let Some(deserializer) = deserializer {
6627 let value = deserializer.finish(helper)?;
6628 ComplexBaseTypeContentDeserializer::store_simple_content(
6629 &mut values,
6630 value,
6631 )?;
6632 }
6633 Ok(super::ComplexBaseTypeContent::SimpleContent(
6634 helper.finish_element("simpleContent", values)?,
6635 ))
6636 }
6637 S::ComplexContent(mut values, None, deserializer) => {
6638 if let Some(deserializer) = deserializer {
6639 let value = deserializer.finish(helper)?;
6640 ComplexBaseTypeContentDeserializer::store_complex_content(
6641 &mut values,
6642 value,
6643 )?;
6644 }
6645 Ok(super::ComplexBaseTypeContent::ComplexContent(
6646 helper.finish_element("complexContent", values)?,
6647 ))
6648 }
6649 S::OpenContent(mut values, None, deserializer) => {
6650 if let Some(deserializer) = deserializer {
6651 let value = deserializer.finish(helper)?;
6652 ComplexBaseTypeContentDeserializer::store_open_content(&mut values, value)?;
6653 }
6654 Ok(super::ComplexBaseTypeContent::OpenContent(
6655 helper.finish_element("openContent", values)?,
6656 ))
6657 }
6658 S::Group(mut values, None, deserializer) => {
6659 if let Some(deserializer) = deserializer {
6660 let value = deserializer.finish(helper)?;
6661 ComplexBaseTypeContentDeserializer::store_group(&mut values, value)?;
6662 }
6663 Ok(super::ComplexBaseTypeContent::Group(
6664 helper.finish_element("group", values)?,
6665 ))
6666 }
6667 S::All(mut values, None, deserializer) => {
6668 if let Some(deserializer) = deserializer {
6669 let value = deserializer.finish(helper)?;
6670 ComplexBaseTypeContentDeserializer::store_all(&mut values, value)?;
6671 }
6672 Ok(super::ComplexBaseTypeContent::All(
6673 helper.finish_element("all", values)?,
6674 ))
6675 }
6676 S::Choice(mut values, None, deserializer) => {
6677 if let Some(deserializer) = deserializer {
6678 let value = deserializer.finish(helper)?;
6679 ComplexBaseTypeContentDeserializer::store_choice(&mut values, value)?;
6680 }
6681 Ok(super::ComplexBaseTypeContent::Choice(
6682 helper.finish_element("choice", values)?,
6683 ))
6684 }
6685 S::Sequence(mut values, None, deserializer) => {
6686 if let Some(deserializer) = deserializer {
6687 let value = deserializer.finish(helper)?;
6688 ComplexBaseTypeContentDeserializer::store_sequence(&mut values, value)?;
6689 }
6690 Ok(super::ComplexBaseTypeContent::Sequence(
6691 helper.finish_element("sequence", values)?,
6692 ))
6693 }
6694 S::Attribute(mut values, None, deserializer) => {
6695 if let Some(deserializer) = deserializer {
6696 let value = deserializer.finish(helper)?;
6697 ComplexBaseTypeContentDeserializer::store_attribute(&mut values, value)?;
6698 }
6699 Ok(super::ComplexBaseTypeContent::Attribute(
6700 helper.finish_element("attribute", values)?,
6701 ))
6702 }
6703 S::AttributeGroup(mut values, None, deserializer) => {
6704 if let Some(deserializer) = deserializer {
6705 let value = deserializer.finish(helper)?;
6706 ComplexBaseTypeContentDeserializer::store_attribute_group(
6707 &mut values,
6708 value,
6709 )?;
6710 }
6711 Ok(super::ComplexBaseTypeContent::AttributeGroup(
6712 helper.finish_element("attributeGroup", values)?,
6713 ))
6714 }
6715 S::AnyAttribute(mut values, None, deserializer) => {
6716 if let Some(deserializer) = deserializer {
6717 let value = deserializer.finish(helper)?;
6718 ComplexBaseTypeContentDeserializer::store_any_attribute(
6719 &mut values,
6720 value,
6721 )?;
6722 }
6723 Ok(super::ComplexBaseTypeContent::AnyAttribute(
6724 helper.finish_element("anyAttribute", values)?,
6725 ))
6726 }
6727 S::Assert(mut values, None, deserializer) => {
6728 if let Some(deserializer) = deserializer {
6729 let value = deserializer.finish(helper)?;
6730 ComplexBaseTypeContentDeserializer::store_assert(&mut values, value)?;
6731 }
6732 Ok(super::ComplexBaseTypeContent::Assert(
6733 helper.finish_element("assert", values)?,
6734 ))
6735 }
6736 S::Done__(data) => Ok(data),
6737 _ => unreachable!(),
6738 }
6739 }
6740 fn store_annotation(
6741 values: &mut Option<super::Annotation>,
6742 value: super::Annotation,
6743 ) -> Result<(), Error> {
6744 if values.is_some() {
6745 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6746 b"annotation",
6747 )))?;
6748 }
6749 *values = Some(value);
6750 Ok(())
6751 }
6752 fn store_simple_content(
6753 values: &mut Option<super::SimpleContent>,
6754 value: super::SimpleContent,
6755 ) -> Result<(), Error> {
6756 if values.is_some() {
6757 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6758 b"simpleContent",
6759 )))?;
6760 }
6761 *values = Some(value);
6762 Ok(())
6763 }
6764 fn store_complex_content(
6765 values: &mut Option<super::ComplexContent>,
6766 value: super::ComplexContent,
6767 ) -> Result<(), Error> {
6768 if values.is_some() {
6769 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6770 b"complexContent",
6771 )))?;
6772 }
6773 *values = Some(value);
6774 Ok(())
6775 }
6776 fn store_open_content(
6777 values: &mut Option<super::OpenContent>,
6778 value: super::OpenContent,
6779 ) -> Result<(), Error> {
6780 if values.is_some() {
6781 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6782 b"openContent",
6783 )))?;
6784 }
6785 *values = Some(value);
6786 Ok(())
6787 }
6788 fn store_group(
6789 values: &mut Option<super::GroupType>,
6790 value: super::GroupType,
6791 ) -> Result<(), Error> {
6792 if values.is_some() {
6793 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6794 b"group",
6795 )))?;
6796 }
6797 *values = Some(value);
6798 Ok(())
6799 }
6800 fn store_all(
6801 values: &mut Option<super::GroupType>,
6802 value: super::GroupType,
6803 ) -> Result<(), Error> {
6804 if values.is_some() {
6805 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"all")))?;
6806 }
6807 *values = Some(value);
6808 Ok(())
6809 }
6810 fn store_choice(
6811 values: &mut Option<super::GroupType>,
6812 value: super::GroupType,
6813 ) -> Result<(), Error> {
6814 if values.is_some() {
6815 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6816 b"choice",
6817 )))?;
6818 }
6819 *values = Some(value);
6820 Ok(())
6821 }
6822 fn store_sequence(
6823 values: &mut Option<super::GroupType>,
6824 value: super::GroupType,
6825 ) -> Result<(), Error> {
6826 if values.is_some() {
6827 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6828 b"sequence",
6829 )))?;
6830 }
6831 *values = Some(value);
6832 Ok(())
6833 }
6834 fn store_attribute(
6835 values: &mut Option<super::AttributeType>,
6836 value: super::AttributeType,
6837 ) -> Result<(), Error> {
6838 if values.is_some() {
6839 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6840 b"attribute",
6841 )))?;
6842 }
6843 *values = Some(value);
6844 Ok(())
6845 }
6846 fn store_attribute_group(
6847 values: &mut Option<super::AttributeGroupType>,
6848 value: super::AttributeGroupType,
6849 ) -> Result<(), Error> {
6850 if values.is_some() {
6851 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6852 b"attributeGroup",
6853 )))?;
6854 }
6855 *values = Some(value);
6856 Ok(())
6857 }
6858 fn store_any_attribute(
6859 values: &mut Option<super::AnyAttribute>,
6860 value: super::AnyAttribute,
6861 ) -> Result<(), Error> {
6862 if values.is_some() {
6863 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6864 b"anyAttribute",
6865 )))?;
6866 }
6867 *values = Some(value);
6868 Ok(())
6869 }
6870 fn store_assert(
6871 values: &mut Option<super::AssertionType>,
6872 value: super::AssertionType,
6873 ) -> Result<(), Error> {
6874 if values.is_some() {
6875 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
6876 b"assert",
6877 )))?;
6878 }
6879 *values = Some(value);
6880 Ok(())
6881 }
6882 fn handle_annotation<'de>(
6883 &mut self,
6884 helper: &mut DeserializeHelper,
6885 mut values: Option<super::Annotation>,
6886 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
6887 output: DeserializerOutput<'de, super::Annotation>,
6888 ) -> Result<ElementHandlerOutput<'de>, Error> {
6889 use ComplexBaseTypeContentDeserializerState as S;
6890 let DeserializerOutput {
6891 artifact,
6892 event,
6893 allow_any,
6894 } = output;
6895 if artifact.is_none() {
6896 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
6897 }
6898 if let Some(deserializer) = fallback {
6899 let data = deserializer.finish(helper)?;
6900 ComplexBaseTypeContentDeserializer::store_annotation(&mut values, data)?;
6901 }
6902 match artifact {
6903 DeserializerArtifact::None => unreachable!(),
6904 DeserializerArtifact::Data(data) => {
6905 ComplexBaseTypeContentDeserializer::store_annotation(&mut values, data)?;
6906 let data = ComplexBaseTypeContentDeserializer::finish_state(
6907 helper,
6908 S::Annotation(values, None, None),
6909 )?;
6910 *self.state__ = S::Done__(data);
6911 Ok(ElementHandlerOutput::break_(event, allow_any))
6912 }
6913 DeserializerArtifact::Deserializer(deserializer) => {
6914 *self.state__ = S::Annotation(values, None, Some(deserializer));
6915 Ok(ElementHandlerOutput::break_(event, allow_any))
6916 }
6917 }
6918 }
6919 fn handle_simple_content<'de>(
6920 &mut self,
6921 helper: &mut DeserializeHelper,
6922 mut values: Option<super::SimpleContent>,
6923 fallback: Option<<super::SimpleContent as WithDeserializer>::Deserializer>,
6924 output: DeserializerOutput<'de, super::SimpleContent>,
6925 ) -> Result<ElementHandlerOutput<'de>, Error> {
6926 use ComplexBaseTypeContentDeserializerState as S;
6927 let DeserializerOutput {
6928 artifact,
6929 event,
6930 allow_any,
6931 } = output;
6932 if artifact.is_none() {
6933 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
6934 }
6935 if let Some(deserializer) = fallback {
6936 let data = deserializer.finish(helper)?;
6937 ComplexBaseTypeContentDeserializer::store_simple_content(&mut values, data)?;
6938 }
6939 match artifact {
6940 DeserializerArtifact::None => unreachable!(),
6941 DeserializerArtifact::Data(data) => {
6942 ComplexBaseTypeContentDeserializer::store_simple_content(&mut values, data)?;
6943 let data = ComplexBaseTypeContentDeserializer::finish_state(
6944 helper,
6945 S::SimpleContent(values, None, None),
6946 )?;
6947 *self.state__ = S::Done__(data);
6948 Ok(ElementHandlerOutput::break_(event, allow_any))
6949 }
6950 DeserializerArtifact::Deserializer(deserializer) => {
6951 *self.state__ = S::SimpleContent(values, None, Some(deserializer));
6952 Ok(ElementHandlerOutput::break_(event, allow_any))
6953 }
6954 }
6955 }
6956 fn handle_complex_content<'de>(
6957 &mut self,
6958 helper: &mut DeserializeHelper,
6959 mut values: Option<super::ComplexContent>,
6960 fallback: Option<<super::ComplexContent as WithDeserializer>::Deserializer>,
6961 output: DeserializerOutput<'de, super::ComplexContent>,
6962 ) -> Result<ElementHandlerOutput<'de>, Error> {
6963 use ComplexBaseTypeContentDeserializerState as S;
6964 let DeserializerOutput {
6965 artifact,
6966 event,
6967 allow_any,
6968 } = output;
6969 if artifact.is_none() {
6970 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
6971 }
6972 if let Some(deserializer) = fallback {
6973 let data = deserializer.finish(helper)?;
6974 ComplexBaseTypeContentDeserializer::store_complex_content(&mut values, data)?;
6975 }
6976 match artifact {
6977 DeserializerArtifact::None => unreachable!(),
6978 DeserializerArtifact::Data(data) => {
6979 ComplexBaseTypeContentDeserializer::store_complex_content(&mut values, data)?;
6980 let data = ComplexBaseTypeContentDeserializer::finish_state(
6981 helper,
6982 S::ComplexContent(values, None, None),
6983 )?;
6984 *self.state__ = S::Done__(data);
6985 Ok(ElementHandlerOutput::break_(event, allow_any))
6986 }
6987 DeserializerArtifact::Deserializer(deserializer) => {
6988 *self.state__ = S::ComplexContent(values, None, Some(deserializer));
6989 Ok(ElementHandlerOutput::break_(event, allow_any))
6990 }
6991 }
6992 }
6993 fn handle_open_content<'de>(
6994 &mut self,
6995 helper: &mut DeserializeHelper,
6996 mut values: Option<super::OpenContent>,
6997 fallback: Option<<super::OpenContent as WithDeserializer>::Deserializer>,
6998 output: DeserializerOutput<'de, super::OpenContent>,
6999 ) -> Result<ElementHandlerOutput<'de>, Error> {
7000 use ComplexBaseTypeContentDeserializerState as S;
7001 let DeserializerOutput {
7002 artifact,
7003 event,
7004 allow_any,
7005 } = output;
7006 if artifact.is_none() {
7007 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
7008 }
7009 if let Some(deserializer) = fallback {
7010 let data = deserializer.finish(helper)?;
7011 ComplexBaseTypeContentDeserializer::store_open_content(&mut values, data)?;
7012 }
7013 match artifact {
7014 DeserializerArtifact::None => unreachable!(),
7015 DeserializerArtifact::Data(data) => {
7016 ComplexBaseTypeContentDeserializer::store_open_content(&mut values, data)?;
7017 let data = ComplexBaseTypeContentDeserializer::finish_state(
7018 helper,
7019 S::OpenContent(values, None, None),
7020 )?;
7021 *self.state__ = S::Done__(data);
7022 Ok(ElementHandlerOutput::break_(event, allow_any))
7023 }
7024 DeserializerArtifact::Deserializer(deserializer) => {
7025 *self.state__ = S::OpenContent(values, None, Some(deserializer));
7026 Ok(ElementHandlerOutput::break_(event, allow_any))
7027 }
7028 }
7029 }
7030 fn handle_group<'de>(
7031 &mut self,
7032 helper: &mut DeserializeHelper,
7033 mut values: Option<super::GroupType>,
7034 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
7035 output: DeserializerOutput<'de, super::GroupType>,
7036 ) -> Result<ElementHandlerOutput<'de>, Error> {
7037 use ComplexBaseTypeContentDeserializerState as S;
7038 let DeserializerOutput {
7039 artifact,
7040 event,
7041 allow_any,
7042 } = output;
7043 if artifact.is_none() {
7044 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
7045 }
7046 if let Some(deserializer) = fallback {
7047 let data = deserializer.finish(helper)?;
7048 ComplexBaseTypeContentDeserializer::store_group(&mut values, data)?;
7049 }
7050 match artifact {
7051 DeserializerArtifact::None => unreachable!(),
7052 DeserializerArtifact::Data(data) => {
7053 ComplexBaseTypeContentDeserializer::store_group(&mut values, data)?;
7054 let data = ComplexBaseTypeContentDeserializer::finish_state(
7055 helper,
7056 S::Group(values, None, None),
7057 )?;
7058 *self.state__ = S::Done__(data);
7059 Ok(ElementHandlerOutput::break_(event, allow_any))
7060 }
7061 DeserializerArtifact::Deserializer(deserializer) => {
7062 *self.state__ = S::Group(values, None, Some(deserializer));
7063 Ok(ElementHandlerOutput::break_(event, allow_any))
7064 }
7065 }
7066 }
7067 fn handle_all<'de>(
7068 &mut self,
7069 helper: &mut DeserializeHelper,
7070 mut values: Option<super::GroupType>,
7071 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
7072 output: DeserializerOutput<'de, super::GroupType>,
7073 ) -> Result<ElementHandlerOutput<'de>, Error> {
7074 use ComplexBaseTypeContentDeserializerState as S;
7075 let DeserializerOutput {
7076 artifact,
7077 event,
7078 allow_any,
7079 } = output;
7080 if artifact.is_none() {
7081 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
7082 }
7083 if let Some(deserializer) = fallback {
7084 let data = deserializer.finish(helper)?;
7085 ComplexBaseTypeContentDeserializer::store_all(&mut values, data)?;
7086 }
7087 match artifact {
7088 DeserializerArtifact::None => unreachable!(),
7089 DeserializerArtifact::Data(data) => {
7090 ComplexBaseTypeContentDeserializer::store_all(&mut values, data)?;
7091 let data = ComplexBaseTypeContentDeserializer::finish_state(
7092 helper,
7093 S::All(values, None, None),
7094 )?;
7095 *self.state__ = S::Done__(data);
7096 Ok(ElementHandlerOutput::break_(event, allow_any))
7097 }
7098 DeserializerArtifact::Deserializer(deserializer) => {
7099 *self.state__ = S::All(values, None, Some(deserializer));
7100 Ok(ElementHandlerOutput::break_(event, allow_any))
7101 }
7102 }
7103 }
7104 fn handle_choice<'de>(
7105 &mut self,
7106 helper: &mut DeserializeHelper,
7107 mut values: Option<super::GroupType>,
7108 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
7109 output: DeserializerOutput<'de, super::GroupType>,
7110 ) -> Result<ElementHandlerOutput<'de>, Error> {
7111 use ComplexBaseTypeContentDeserializerState as S;
7112 let DeserializerOutput {
7113 artifact,
7114 event,
7115 allow_any,
7116 } = output;
7117 if artifact.is_none() {
7118 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
7119 }
7120 if let Some(deserializer) = fallback {
7121 let data = deserializer.finish(helper)?;
7122 ComplexBaseTypeContentDeserializer::store_choice(&mut values, data)?;
7123 }
7124 match artifact {
7125 DeserializerArtifact::None => unreachable!(),
7126 DeserializerArtifact::Data(data) => {
7127 ComplexBaseTypeContentDeserializer::store_choice(&mut values, data)?;
7128 let data = ComplexBaseTypeContentDeserializer::finish_state(
7129 helper,
7130 S::Choice(values, None, None),
7131 )?;
7132 *self.state__ = S::Done__(data);
7133 Ok(ElementHandlerOutput::break_(event, allow_any))
7134 }
7135 DeserializerArtifact::Deserializer(deserializer) => {
7136 *self.state__ = S::Choice(values, None, Some(deserializer));
7137 Ok(ElementHandlerOutput::break_(event, allow_any))
7138 }
7139 }
7140 }
7141 fn handle_sequence<'de>(
7142 &mut self,
7143 helper: &mut DeserializeHelper,
7144 mut values: Option<super::GroupType>,
7145 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
7146 output: DeserializerOutput<'de, super::GroupType>,
7147 ) -> Result<ElementHandlerOutput<'de>, Error> {
7148 use ComplexBaseTypeContentDeserializerState as S;
7149 let DeserializerOutput {
7150 artifact,
7151 event,
7152 allow_any,
7153 } = output;
7154 if artifact.is_none() {
7155 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
7156 }
7157 if let Some(deserializer) = fallback {
7158 let data = deserializer.finish(helper)?;
7159 ComplexBaseTypeContentDeserializer::store_sequence(&mut values, data)?;
7160 }
7161 match artifact {
7162 DeserializerArtifact::None => unreachable!(),
7163 DeserializerArtifact::Data(data) => {
7164 ComplexBaseTypeContentDeserializer::store_sequence(&mut values, data)?;
7165 let data = ComplexBaseTypeContentDeserializer::finish_state(
7166 helper,
7167 S::Sequence(values, None, None),
7168 )?;
7169 *self.state__ = S::Done__(data);
7170 Ok(ElementHandlerOutput::break_(event, allow_any))
7171 }
7172 DeserializerArtifact::Deserializer(deserializer) => {
7173 *self.state__ = S::Sequence(values, None, Some(deserializer));
7174 Ok(ElementHandlerOutput::break_(event, allow_any))
7175 }
7176 }
7177 }
7178 fn handle_attribute<'de>(
7179 &mut self,
7180 helper: &mut DeserializeHelper,
7181 mut values: Option<super::AttributeType>,
7182 fallback: Option<<super::AttributeType as WithDeserializer>::Deserializer>,
7183 output: DeserializerOutput<'de, super::AttributeType>,
7184 ) -> Result<ElementHandlerOutput<'de>, Error> {
7185 use ComplexBaseTypeContentDeserializerState as S;
7186 let DeserializerOutput {
7187 artifact,
7188 event,
7189 allow_any,
7190 } = output;
7191 if artifact.is_none() {
7192 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
7193 }
7194 if let Some(deserializer) = fallback {
7195 let data = deserializer.finish(helper)?;
7196 ComplexBaseTypeContentDeserializer::store_attribute(&mut values, data)?;
7197 }
7198 match artifact {
7199 DeserializerArtifact::None => unreachable!(),
7200 DeserializerArtifact::Data(data) => {
7201 ComplexBaseTypeContentDeserializer::store_attribute(&mut values, data)?;
7202 let data = ComplexBaseTypeContentDeserializer::finish_state(
7203 helper,
7204 S::Attribute(values, None, None),
7205 )?;
7206 *self.state__ = S::Done__(data);
7207 Ok(ElementHandlerOutput::break_(event, allow_any))
7208 }
7209 DeserializerArtifact::Deserializer(deserializer) => {
7210 *self.state__ = S::Attribute(values, None, Some(deserializer));
7211 Ok(ElementHandlerOutput::break_(event, allow_any))
7212 }
7213 }
7214 }
7215 fn handle_attribute_group<'de>(
7216 &mut self,
7217 helper: &mut DeserializeHelper,
7218 mut values: Option<super::AttributeGroupType>,
7219 fallback: Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
7220 output: DeserializerOutput<'de, super::AttributeGroupType>,
7221 ) -> Result<ElementHandlerOutput<'de>, Error> {
7222 use ComplexBaseTypeContentDeserializerState as S;
7223 let DeserializerOutput {
7224 artifact,
7225 event,
7226 allow_any,
7227 } = output;
7228 if artifact.is_none() {
7229 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
7230 }
7231 if let Some(deserializer) = fallback {
7232 let data = deserializer.finish(helper)?;
7233 ComplexBaseTypeContentDeserializer::store_attribute_group(&mut values, data)?;
7234 }
7235 match artifact {
7236 DeserializerArtifact::None => unreachable!(),
7237 DeserializerArtifact::Data(data) => {
7238 ComplexBaseTypeContentDeserializer::store_attribute_group(&mut values, data)?;
7239 let data = ComplexBaseTypeContentDeserializer::finish_state(
7240 helper,
7241 S::AttributeGroup(values, None, None),
7242 )?;
7243 *self.state__ = S::Done__(data);
7244 Ok(ElementHandlerOutput::break_(event, allow_any))
7245 }
7246 DeserializerArtifact::Deserializer(deserializer) => {
7247 *self.state__ = S::AttributeGroup(values, None, Some(deserializer));
7248 Ok(ElementHandlerOutput::break_(event, allow_any))
7249 }
7250 }
7251 }
7252 fn handle_any_attribute<'de>(
7253 &mut self,
7254 helper: &mut DeserializeHelper,
7255 mut values: Option<super::AnyAttribute>,
7256 fallback: Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
7257 output: DeserializerOutput<'de, super::AnyAttribute>,
7258 ) -> Result<ElementHandlerOutput<'de>, Error> {
7259 use ComplexBaseTypeContentDeserializerState as S;
7260 let DeserializerOutput {
7261 artifact,
7262 event,
7263 allow_any,
7264 } = output;
7265 if artifact.is_none() {
7266 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
7267 }
7268 if let Some(deserializer) = fallback {
7269 let data = deserializer.finish(helper)?;
7270 ComplexBaseTypeContentDeserializer::store_any_attribute(&mut values, data)?;
7271 }
7272 match artifact {
7273 DeserializerArtifact::None => unreachable!(),
7274 DeserializerArtifact::Data(data) => {
7275 ComplexBaseTypeContentDeserializer::store_any_attribute(&mut values, data)?;
7276 let data = ComplexBaseTypeContentDeserializer::finish_state(
7277 helper,
7278 S::AnyAttribute(values, None, None),
7279 )?;
7280 *self.state__ = S::Done__(data);
7281 Ok(ElementHandlerOutput::break_(event, allow_any))
7282 }
7283 DeserializerArtifact::Deserializer(deserializer) => {
7284 *self.state__ = S::AnyAttribute(values, None, Some(deserializer));
7285 Ok(ElementHandlerOutput::break_(event, allow_any))
7286 }
7287 }
7288 }
7289 fn handle_assert<'de>(
7290 &mut self,
7291 helper: &mut DeserializeHelper,
7292 mut values: Option<super::AssertionType>,
7293 fallback: Option<<super::AssertionType as WithDeserializer>::Deserializer>,
7294 output: DeserializerOutput<'de, super::AssertionType>,
7295 ) -> Result<ElementHandlerOutput<'de>, Error> {
7296 use ComplexBaseTypeContentDeserializerState as S;
7297 let DeserializerOutput {
7298 artifact,
7299 event,
7300 allow_any,
7301 } = output;
7302 if artifact.is_none() {
7303 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
7304 }
7305 if let Some(deserializer) = fallback {
7306 let data = deserializer.finish(helper)?;
7307 ComplexBaseTypeContentDeserializer::store_assert(&mut values, data)?;
7308 }
7309 match artifact {
7310 DeserializerArtifact::None => unreachable!(),
7311 DeserializerArtifact::Data(data) => {
7312 ComplexBaseTypeContentDeserializer::store_assert(&mut values, data)?;
7313 let data = ComplexBaseTypeContentDeserializer::finish_state(
7314 helper,
7315 S::Assert(values, None, None),
7316 )?;
7317 *self.state__ = S::Done__(data);
7318 Ok(ElementHandlerOutput::break_(event, allow_any))
7319 }
7320 DeserializerArtifact::Deserializer(deserializer) => {
7321 *self.state__ = S::Assert(values, None, Some(deserializer));
7322 Ok(ElementHandlerOutput::break_(event, allow_any))
7323 }
7324 }
7325 }
7326 }
7327 impl<'de> Deserializer<'de, super::ComplexBaseTypeContent>
7328 for Box<ComplexBaseTypeContentDeserializer>
7329 {
7330 fn init(
7331 helper: &mut DeserializeHelper,
7332 event: Event<'de>,
7333 ) -> DeserializerResult<'de, super::ComplexBaseTypeContent> {
7334 let deserializer = Box::new(ComplexBaseTypeContentDeserializer {
7335 state__: Box::new(ComplexBaseTypeContentDeserializerState::Init__),
7336 });
7337 let mut output = deserializer.next(helper, event)?;
7338 output.artifact = match output.artifact {
7339 DeserializerArtifact::Deserializer(x)
7340 if matches!(&*x.state__, ComplexBaseTypeContentDeserializerState::Init__) =>
7341 {
7342 DeserializerArtifact::None
7343 }
7344 artifact => artifact,
7345 };
7346 Ok(output)
7347 }
7348 fn next(
7349 mut self,
7350 helper: &mut DeserializeHelper,
7351 event: Event<'de>,
7352 ) -> DeserializerResult<'de, super::ComplexBaseTypeContent> {
7353 use ComplexBaseTypeContentDeserializerState as S;
7354 let mut event = event;
7355 let (event, allow_any) = loop {
7356 let state = replace(&mut *self.state__, S::Unknown__);
7357 event = match (state, event) {
7358 (S::Unknown__, _) => unreachable!(),
7359 (S::Annotation(values, fallback, Some(deserializer)), event) => {
7360 let output = deserializer.next(helper, event)?;
7361 match self.handle_annotation(helper, values, fallback, output)? {
7362 ElementHandlerOutput::Break { event, allow_any } => {
7363 break (event, allow_any)
7364 }
7365 ElementHandlerOutput::Continue { event, .. } => event,
7366 }
7367 }
7368 (S::SimpleContent(values, fallback, Some(deserializer)), event) => {
7369 let output = deserializer.next(helper, event)?;
7370 match self.handle_simple_content(helper, values, fallback, output)? {
7371 ElementHandlerOutput::Break { event, allow_any } => {
7372 break (event, allow_any)
7373 }
7374 ElementHandlerOutput::Continue { event, .. } => event,
7375 }
7376 }
7377 (S::ComplexContent(values, fallback, Some(deserializer)), event) => {
7378 let output = deserializer.next(helper, event)?;
7379 match self.handle_complex_content(helper, values, fallback, output)? {
7380 ElementHandlerOutput::Break { event, allow_any } => {
7381 break (event, allow_any)
7382 }
7383 ElementHandlerOutput::Continue { event, .. } => event,
7384 }
7385 }
7386 (S::OpenContent(values, fallback, Some(deserializer)), event) => {
7387 let output = deserializer.next(helper, event)?;
7388 match self.handle_open_content(helper, values, fallback, output)? {
7389 ElementHandlerOutput::Break { event, allow_any } => {
7390 break (event, allow_any)
7391 }
7392 ElementHandlerOutput::Continue { event, .. } => event,
7393 }
7394 }
7395 (S::Group(values, fallback, Some(deserializer)), event) => {
7396 let output = deserializer.next(helper, event)?;
7397 match self.handle_group(helper, values, fallback, output)? {
7398 ElementHandlerOutput::Break { event, allow_any } => {
7399 break (event, allow_any)
7400 }
7401 ElementHandlerOutput::Continue { event, .. } => event,
7402 }
7403 }
7404 (S::All(values, fallback, Some(deserializer)), event) => {
7405 let output = deserializer.next(helper, event)?;
7406 match self.handle_all(helper, values, fallback, output)? {
7407 ElementHandlerOutput::Break { event, allow_any } => {
7408 break (event, allow_any)
7409 }
7410 ElementHandlerOutput::Continue { event, .. } => event,
7411 }
7412 }
7413 (S::Choice(values, fallback, Some(deserializer)), event) => {
7414 let output = deserializer.next(helper, event)?;
7415 match self.handle_choice(helper, values, fallback, output)? {
7416 ElementHandlerOutput::Break { event, allow_any } => {
7417 break (event, allow_any)
7418 }
7419 ElementHandlerOutput::Continue { event, .. } => event,
7420 }
7421 }
7422 (S::Sequence(values, fallback, Some(deserializer)), event) => {
7423 let output = deserializer.next(helper, event)?;
7424 match self.handle_sequence(helper, values, fallback, output)? {
7425 ElementHandlerOutput::Break { event, allow_any } => {
7426 break (event, allow_any)
7427 }
7428 ElementHandlerOutput::Continue { event, .. } => event,
7429 }
7430 }
7431 (S::Attribute(values, fallback, Some(deserializer)), event) => {
7432 let output = deserializer.next(helper, event)?;
7433 match self.handle_attribute(helper, values, fallback, output)? {
7434 ElementHandlerOutput::Break { event, allow_any } => {
7435 break (event, allow_any)
7436 }
7437 ElementHandlerOutput::Continue { event, .. } => event,
7438 }
7439 }
7440 (S::AttributeGroup(values, fallback, Some(deserializer)), event) => {
7441 let output = deserializer.next(helper, event)?;
7442 match self.handle_attribute_group(helper, values, fallback, output)? {
7443 ElementHandlerOutput::Break { event, allow_any } => {
7444 break (event, allow_any)
7445 }
7446 ElementHandlerOutput::Continue { event, .. } => event,
7447 }
7448 }
7449 (S::AnyAttribute(values, fallback, Some(deserializer)), event) => {
7450 let output = deserializer.next(helper, event)?;
7451 match self.handle_any_attribute(helper, values, fallback, output)? {
7452 ElementHandlerOutput::Break { event, allow_any } => {
7453 break (event, allow_any)
7454 }
7455 ElementHandlerOutput::Continue { event, .. } => event,
7456 }
7457 }
7458 (S::Assert(values, fallback, Some(deserializer)), event) => {
7459 let output = deserializer.next(helper, event)?;
7460 match self.handle_assert(helper, values, fallback, output)? {
7461 ElementHandlerOutput::Break { event, allow_any } => {
7462 break (event, allow_any)
7463 }
7464 ElementHandlerOutput::Continue { event, .. } => event,
7465 }
7466 }
7467 (state, event @ Event::End(_)) => {
7468 return Ok(DeserializerOutput {
7469 artifact: DeserializerArtifact::Data(
7470 ComplexBaseTypeContentDeserializer::finish_state(helper, state)?,
7471 ),
7472 event: DeserializerEvent::Continue(event),
7473 allow_any: false,
7474 });
7475 }
7476 (S::Init__, event) => match self.find_suitable(helper, event)? {
7477 ElementHandlerOutput::Break { event, allow_any } => {
7478 break (event, allow_any)
7479 }
7480 ElementHandlerOutput::Continue { event, .. } => event,
7481 },
7482 (
7483 S::Annotation(values, fallback, None),
7484 event @ (Event::Start(_) | Event::Empty(_)),
7485 ) => {
7486 let output = helper.init_start_tag_deserializer(
7487 event,
7488 Some(&super::NS_XS),
7489 b"annotation",
7490 false,
7491 )?;
7492 match self.handle_annotation(helper, values, fallback, output)? {
7493 ElementHandlerOutput::Break { event, allow_any } => {
7494 break (event, allow_any)
7495 }
7496 ElementHandlerOutput::Continue { event, .. } => event,
7497 }
7498 }
7499 (
7500 S::SimpleContent(values, fallback, None),
7501 event @ (Event::Start(_) | Event::Empty(_)),
7502 ) => {
7503 let output = helper.init_start_tag_deserializer(
7504 event,
7505 Some(&super::NS_XS),
7506 b"simpleContent",
7507 true,
7508 )?;
7509 match self.handle_simple_content(helper, values, fallback, output)? {
7510 ElementHandlerOutput::Break { event, allow_any } => {
7511 break (event, allow_any)
7512 }
7513 ElementHandlerOutput::Continue { event, .. } => event,
7514 }
7515 }
7516 (
7517 S::ComplexContent(values, fallback, None),
7518 event @ (Event::Start(_) | Event::Empty(_)),
7519 ) => {
7520 let output = helper.init_start_tag_deserializer(
7521 event,
7522 Some(&super::NS_XS),
7523 b"complexContent",
7524 true,
7525 )?;
7526 match self.handle_complex_content(helper, values, fallback, output)? {
7527 ElementHandlerOutput::Break { event, allow_any } => {
7528 break (event, allow_any)
7529 }
7530 ElementHandlerOutput::Continue { event, .. } => event,
7531 }
7532 }
7533 (
7534 S::OpenContent(values, fallback, None),
7535 event @ (Event::Start(_) | Event::Empty(_)),
7536 ) => {
7537 let output = helper.init_start_tag_deserializer(
7538 event,
7539 Some(&super::NS_XS),
7540 b"openContent",
7541 false,
7542 )?;
7543 match self.handle_open_content(helper, values, fallback, output)? {
7544 ElementHandlerOutput::Break { event, allow_any } => {
7545 break (event, allow_any)
7546 }
7547 ElementHandlerOutput::Continue { event, .. } => event,
7548 }
7549 }
7550 (
7551 S::Group(values, fallback, None),
7552 event @ (Event::Start(_) | Event::Empty(_)),
7553 ) => {
7554 let output = helper.init_start_tag_deserializer(
7555 event,
7556 Some(&super::NS_XS),
7557 b"group",
7558 true,
7559 )?;
7560 match self.handle_group(helper, values, fallback, output)? {
7561 ElementHandlerOutput::Break { event, allow_any } => {
7562 break (event, allow_any)
7563 }
7564 ElementHandlerOutput::Continue { event, .. } => event,
7565 }
7566 }
7567 (
7568 S::All(values, fallback, None),
7569 event @ (Event::Start(_) | Event::Empty(_)),
7570 ) => {
7571 let output = helper.init_start_tag_deserializer(
7572 event,
7573 Some(&super::NS_XS),
7574 b"all",
7575 true,
7576 )?;
7577 match self.handle_all(helper, values, fallback, output)? {
7578 ElementHandlerOutput::Break { event, allow_any } => {
7579 break (event, allow_any)
7580 }
7581 ElementHandlerOutput::Continue { event, .. } => event,
7582 }
7583 }
7584 (
7585 S::Choice(values, fallback, None),
7586 event @ (Event::Start(_) | Event::Empty(_)),
7587 ) => {
7588 let output = helper.init_start_tag_deserializer(
7589 event,
7590 Some(&super::NS_XS),
7591 b"choice",
7592 true,
7593 )?;
7594 match self.handle_choice(helper, values, fallback, output)? {
7595 ElementHandlerOutput::Break { event, allow_any } => {
7596 break (event, allow_any)
7597 }
7598 ElementHandlerOutput::Continue { event, .. } => event,
7599 }
7600 }
7601 (
7602 S::Sequence(values, fallback, None),
7603 event @ (Event::Start(_) | Event::Empty(_)),
7604 ) => {
7605 let output = helper.init_start_tag_deserializer(
7606 event,
7607 Some(&super::NS_XS),
7608 b"sequence",
7609 true,
7610 )?;
7611 match self.handle_sequence(helper, values, fallback, output)? {
7612 ElementHandlerOutput::Break { event, allow_any } => {
7613 break (event, allow_any)
7614 }
7615 ElementHandlerOutput::Continue { event, .. } => event,
7616 }
7617 }
7618 (
7619 S::Attribute(values, fallback, None),
7620 event @ (Event::Start(_) | Event::Empty(_)),
7621 ) => {
7622 let output = helper.init_start_tag_deserializer(
7623 event,
7624 Some(&super::NS_XS),
7625 b"attribute",
7626 false,
7627 )?;
7628 match self.handle_attribute(helper, values, fallback, output)? {
7629 ElementHandlerOutput::Break { event, allow_any } => {
7630 break (event, allow_any)
7631 }
7632 ElementHandlerOutput::Continue { event, .. } => event,
7633 }
7634 }
7635 (
7636 S::AttributeGroup(values, fallback, None),
7637 event @ (Event::Start(_) | Event::Empty(_)),
7638 ) => {
7639 let output = helper.init_start_tag_deserializer(
7640 event,
7641 Some(&super::NS_XS),
7642 b"attributeGroup",
7643 false,
7644 )?;
7645 match self.handle_attribute_group(helper, values, fallback, output)? {
7646 ElementHandlerOutput::Break { event, allow_any } => {
7647 break (event, allow_any)
7648 }
7649 ElementHandlerOutput::Continue { event, .. } => event,
7650 }
7651 }
7652 (
7653 S::AnyAttribute(values, fallback, None),
7654 event @ (Event::Start(_) | Event::Empty(_)),
7655 ) => {
7656 let output = helper.init_start_tag_deserializer(
7657 event,
7658 Some(&super::NS_XS),
7659 b"anyAttribute",
7660 false,
7661 )?;
7662 match self.handle_any_attribute(helper, values, fallback, output)? {
7663 ElementHandlerOutput::Break { event, allow_any } => {
7664 break (event, allow_any)
7665 }
7666 ElementHandlerOutput::Continue { event, .. } => event,
7667 }
7668 }
7669 (
7670 S::Assert(values, fallback, None),
7671 event @ (Event::Start(_) | Event::Empty(_)),
7672 ) => {
7673 let output = helper.init_start_tag_deserializer(
7674 event,
7675 Some(&super::NS_XS),
7676 b"assert",
7677 false,
7678 )?;
7679 match self.handle_assert(helper, values, fallback, output)? {
7680 ElementHandlerOutput::Break { event, allow_any } => {
7681 break (event, allow_any)
7682 }
7683 ElementHandlerOutput::Continue { event, .. } => event,
7684 }
7685 }
7686 (state @ S::Done__(_), event) => {
7687 *self.state__ = state;
7688 break (DeserializerEvent::Continue(event), false);
7689 }
7690 (state, event) => {
7691 *self.state__ = state;
7692 break (DeserializerEvent::Continue(event), false);
7693 }
7694 }
7695 };
7696 let artifact = if matches!(&*self.state__, S::Done__(_)) {
7697 DeserializerArtifact::Data(self.finish(helper)?)
7698 } else {
7699 DeserializerArtifact::Deserializer(self)
7700 };
7701 Ok(DeserializerOutput {
7702 artifact,
7703 event,
7704 allow_any,
7705 })
7706 }
7707 fn finish(
7708 self,
7709 helper: &mut DeserializeHelper,
7710 ) -> Result<super::ComplexBaseTypeContent, Error> {
7711 ComplexBaseTypeContentDeserializer::finish_state(helper, *self.state__)
7712 }
7713 }
7714 #[derive(Debug)]
7715 pub struct GroupTypeDeserializer {
7716 id: Option<String>,
7717 name: Option<String>,
7718 ref_: Option<QName>,
7719 min_occurs: usize,
7720 max_occurs: MaxOccurs,
7721 content: Vec<super::GroupTypeContent>,
7722 state__: Box<GroupTypeDeserializerState>,
7723 }
7724 #[derive(Debug)]
7725 enum GroupTypeDeserializerState {
7726 Init__,
7727 Next__,
7728 Content__(<super::GroupTypeContent as WithDeserializer>::Deserializer),
7729 Unknown__,
7730 }
7731 impl GroupTypeDeserializer {
7732 fn from_bytes_start(
7733 helper: &mut DeserializeHelper,
7734 bytes_start: &BytesStart<'_>,
7735 ) -> Result<Box<Self>, Error> {
7736 let mut id: Option<String> = None;
7737 let mut name: Option<String> = None;
7738 let mut ref_: Option<QName> = None;
7739 let mut min_occurs: Option<usize> = None;
7740 let mut max_occurs: Option<MaxOccurs> = None;
7741 for attrib in helper.filter_xmlns_attributes(bytes_start) {
7742 let attrib = attrib?;
7743 if matches!(
7744 helper.resolve_local_name(attrib.key, &super::NS_XS),
7745 Some(b"id")
7746 ) {
7747 helper.read_attrib(&mut id, b"id", &attrib.value)?;
7748 } else if matches!(
7749 helper.resolve_local_name(attrib.key, &super::NS_XS),
7750 Some(b"name")
7751 ) {
7752 helper.read_attrib(&mut name, b"name", &attrib.value)?;
7753 } else if matches!(
7754 helper.resolve_local_name(attrib.key, &super::NS_XS),
7755 Some(b"ref")
7756 ) {
7757 helper.read_attrib(&mut ref_, b"ref", &attrib.value)?;
7758 } else if matches!(
7759 helper.resolve_local_name(attrib.key, &super::NS_XS),
7760 Some(b"minOccurs")
7761 ) {
7762 helper.read_attrib(&mut min_occurs, b"minOccurs", &attrib.value)?;
7763 } else if matches!(
7764 helper.resolve_local_name(attrib.key, &super::NS_XS),
7765 Some(b"maxOccurs")
7766 ) {
7767 helper.read_attrib(&mut max_occurs, b"maxOccurs", &attrib.value)?;
7768 }
7769 }
7770 Ok(Box::new(Self {
7771 id: id,
7772 name: name,
7773 ref_: ref_,
7774 min_occurs: min_occurs.unwrap_or_else(super::GroupType::default_min_occurs),
7775 max_occurs: max_occurs.unwrap_or_else(super::GroupType::default_max_occurs),
7776 content: Vec::new(),
7777 state__: Box::new(GroupTypeDeserializerState::Init__),
7778 }))
7779 }
7780 fn finish_state(
7781 &mut self,
7782 helper: &mut DeserializeHelper,
7783 state: GroupTypeDeserializerState,
7784 ) -> Result<(), Error> {
7785 if let GroupTypeDeserializerState::Content__(deserializer) = state {
7786 self.store_content(deserializer.finish(helper)?)?;
7787 }
7788 Ok(())
7789 }
7790 fn store_content(&mut self, value: super::GroupTypeContent) -> Result<(), Error> {
7791 self.content.push(value);
7792 Ok(())
7793 }
7794 fn handle_content<'de>(
7795 &mut self,
7796 helper: &mut DeserializeHelper,
7797 output: DeserializerOutput<'de, super::GroupTypeContent>,
7798 fallback: &mut Option<GroupTypeDeserializerState>,
7799 ) -> Result<ElementHandlerOutput<'de>, Error> {
7800 use GroupTypeDeserializerState as S;
7801 let DeserializerOutput {
7802 artifact,
7803 event,
7804 allow_any,
7805 } = output;
7806 if artifact.is_none() {
7807 *self.state__ = fallback.take().unwrap_or(S::Next__);
7808 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
7809 }
7810 if let Some(fallback) = fallback.take() {
7811 self.finish_state(helper, fallback)?;
7812 }
7813 match artifact {
7814 DeserializerArtifact::None => unreachable!(),
7815 DeserializerArtifact::Data(data) => {
7816 self.store_content(data)?;
7817 *self.state__ = S::Next__;
7818 Ok(ElementHandlerOutput::from_event(event, allow_any))
7819 }
7820 DeserializerArtifact::Deserializer(deserializer) => {
7821 *fallback = Some(S::Content__(deserializer));
7822 *self.state__ = S::Next__;
7823 Ok(ElementHandlerOutput::from_event(event, allow_any))
7824 }
7825 }
7826 }
7827 }
7828 impl<'de> Deserializer<'de, super::GroupType> for Box<GroupTypeDeserializer> {
7829 fn init(
7830 helper: &mut DeserializeHelper,
7831 event: Event<'de>,
7832 ) -> DeserializerResult<'de, super::GroupType> {
7833 helper
7834 .init_deserializer_from_start_event(event, GroupTypeDeserializer::from_bytes_start)
7835 }
7836 fn next(
7837 mut self,
7838 helper: &mut DeserializeHelper,
7839 event: Event<'de>,
7840 ) -> DeserializerResult<'de, super::GroupType> {
7841 use GroupTypeDeserializerState as S;
7842 let mut event = event;
7843 let mut fallback = None;
7844 let (event, allow_any) = loop {
7845 let state = replace(&mut *self.state__, S::Unknown__);
7846 event = match (state, event) {
7847 (S::Unknown__, _) => unreachable!(),
7848 (S::Content__(deserializer), event) => {
7849 let output = deserializer.next(helper, event)?;
7850 match self.handle_content(helper, output, &mut fallback)? {
7851 ElementHandlerOutput::Break { event, allow_any } => {
7852 break (event, allow_any)
7853 }
7854 ElementHandlerOutput::Continue { event, .. } => event,
7855 }
7856 }
7857 (_, Event::End(_)) => {
7858 return Ok(DeserializerOutput {
7859 artifact: DeserializerArtifact::Data(self.finish(helper)?),
7860 event: DeserializerEvent::None,
7861 allow_any: false,
7862 });
7863 }
7864 (state @ (S::Init__ | S::Next__), event) => {
7865 fallback.get_or_insert(state);
7866 let output =
7867 <super::GroupTypeContent as WithDeserializer>::init(helper, event)?;
7868 match self.handle_content(helper, output, &mut fallback)? {
7869 ElementHandlerOutput::Break { event, allow_any } => {
7870 break (event, allow_any)
7871 }
7872 ElementHandlerOutput::Continue { event, .. } => event,
7873 }
7874 }
7875 }
7876 };
7877 if let Some(fallback) = fallback {
7878 *self.state__ = fallback;
7879 }
7880 let artifact = DeserializerArtifact::Deserializer(self);
7881 Ok(DeserializerOutput {
7882 artifact,
7883 event,
7884 allow_any,
7885 })
7886 }
7887 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::GroupType, Error> {
7888 let state = replace(&mut *self.state__, GroupTypeDeserializerState::Unknown__);
7889 self.finish_state(helper, state)?;
7890 Ok(super::GroupType {
7891 id: self.id,
7892 name: self.name,
7893 ref_: self.ref_,
7894 min_occurs: self.min_occurs,
7895 max_occurs: self.max_occurs,
7896 content: helper.finish_vec(0usize, None, self.content)?,
7897 })
7898 }
7899 }
7900 #[derive(Debug)]
7901 pub struct GroupTypeContentDeserializer {
7902 state__: Box<GroupTypeContentDeserializerState>,
7903 }
7904 #[derive(Debug)]
7905 pub enum GroupTypeContentDeserializerState {
7906 Init__,
7907 Annotation(
7908 Option<super::Annotation>,
7909 Option<<super::Annotation as WithDeserializer>::Deserializer>,
7910 Option<<super::Annotation as WithDeserializer>::Deserializer>,
7911 ),
7912 Element(
7913 Option<super::ElementType>,
7914 Option<<super::ElementType as WithDeserializer>::Deserializer>,
7915 Option<<super::ElementType as WithDeserializer>::Deserializer>,
7916 ),
7917 Group(
7918 Option<super::GroupType>,
7919 Option<<super::GroupType as WithDeserializer>::Deserializer>,
7920 Option<<super::GroupType as WithDeserializer>::Deserializer>,
7921 ),
7922 All(
7923 Option<super::GroupType>,
7924 Option<<super::GroupType as WithDeserializer>::Deserializer>,
7925 Option<<super::GroupType as WithDeserializer>::Deserializer>,
7926 ),
7927 Choice(
7928 Option<super::GroupType>,
7929 Option<<super::GroupType as WithDeserializer>::Deserializer>,
7930 Option<<super::GroupType as WithDeserializer>::Deserializer>,
7931 ),
7932 Sequence(
7933 Option<super::GroupType>,
7934 Option<<super::GroupType as WithDeserializer>::Deserializer>,
7935 Option<<super::GroupType as WithDeserializer>::Deserializer>,
7936 ),
7937 Any(
7938 Option<super::Any>,
7939 Option<<super::Any as WithDeserializer>::Deserializer>,
7940 Option<<super::Any as WithDeserializer>::Deserializer>,
7941 ),
7942 Done__(super::GroupTypeContent),
7943 Unknown__,
7944 }
7945 impl GroupTypeContentDeserializer {
7946 fn find_suitable<'de>(
7947 &mut self,
7948 helper: &mut DeserializeHelper,
7949 event: Event<'de>,
7950 ) -> Result<ElementHandlerOutput<'de>, Error> {
7951 if let Event::Start(x) | Event::Empty(x) = &event {
7952 if matches!(
7953 helper.resolve_local_name(x.name(), &super::NS_XS),
7954 Some(b"annotation")
7955 ) {
7956 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
7957 return self.handle_annotation(helper, Default::default(), None, output);
7958 }
7959 if matches!(
7960 helper.resolve_local_name(x.name(), &super::NS_XS),
7961 Some(b"element")
7962 ) {
7963 let output = <super::ElementType as WithDeserializer>::init(helper, event)?;
7964 return self.handle_element(helper, Default::default(), None, output);
7965 }
7966 if matches!(
7967 helper.resolve_local_name(x.name(), &super::NS_XS),
7968 Some(b"group")
7969 ) {
7970 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
7971 return self.handle_group(helper, Default::default(), None, output);
7972 }
7973 if matches!(
7974 helper.resolve_local_name(x.name(), &super::NS_XS),
7975 Some(b"all")
7976 ) {
7977 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
7978 return self.handle_all(helper, Default::default(), None, output);
7979 }
7980 if matches!(
7981 helper.resolve_local_name(x.name(), &super::NS_XS),
7982 Some(b"choice")
7983 ) {
7984 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
7985 return self.handle_choice(helper, Default::default(), None, output);
7986 }
7987 if matches!(
7988 helper.resolve_local_name(x.name(), &super::NS_XS),
7989 Some(b"sequence")
7990 ) {
7991 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
7992 return self.handle_sequence(helper, Default::default(), None, output);
7993 }
7994 if matches!(
7995 helper.resolve_local_name(x.name(), &super::NS_XS),
7996 Some(b"any")
7997 ) {
7998 let output = <super::Any as WithDeserializer>::init(helper, event)?;
7999 return self.handle_any(helper, Default::default(), None, output);
8000 }
8001 }
8002 *self.state__ = GroupTypeContentDeserializerState::Init__;
8003 Ok(ElementHandlerOutput::return_to_parent(event, false))
8004 }
8005 fn finish_state(
8006 helper: &mut DeserializeHelper,
8007 state: GroupTypeContentDeserializerState,
8008 ) -> Result<super::GroupTypeContent, Error> {
8009 use GroupTypeContentDeserializerState as S;
8010 match state {
8011 S::Init__ => Err(ErrorKind::MissingContent.into()),
8012 S::Annotation(mut values, None, deserializer) => {
8013 if let Some(deserializer) = deserializer {
8014 let value = deserializer.finish(helper)?;
8015 GroupTypeContentDeserializer::store_annotation(&mut values, value)?;
8016 }
8017 Ok(super::GroupTypeContent::Annotation(
8018 helper.finish_element("annotation", values)?,
8019 ))
8020 }
8021 S::Element(mut values, None, deserializer) => {
8022 if let Some(deserializer) = deserializer {
8023 let value = deserializer.finish(helper)?;
8024 GroupTypeContentDeserializer::store_element(&mut values, value)?;
8025 }
8026 Ok(super::GroupTypeContent::Element(
8027 helper.finish_element("element", values)?,
8028 ))
8029 }
8030 S::Group(mut values, None, deserializer) => {
8031 if let Some(deserializer) = deserializer {
8032 let value = deserializer.finish(helper)?;
8033 GroupTypeContentDeserializer::store_group(&mut values, value)?;
8034 }
8035 Ok(super::GroupTypeContent::Group(
8036 helper.finish_element("group", values)?,
8037 ))
8038 }
8039 S::All(mut values, None, deserializer) => {
8040 if let Some(deserializer) = deserializer {
8041 let value = deserializer.finish(helper)?;
8042 GroupTypeContentDeserializer::store_all(&mut values, value)?;
8043 }
8044 Ok(super::GroupTypeContent::All(
8045 helper.finish_element("all", values)?,
8046 ))
8047 }
8048 S::Choice(mut values, None, deserializer) => {
8049 if let Some(deserializer) = deserializer {
8050 let value = deserializer.finish(helper)?;
8051 GroupTypeContentDeserializer::store_choice(&mut values, value)?;
8052 }
8053 Ok(super::GroupTypeContent::Choice(
8054 helper.finish_element("choice", values)?,
8055 ))
8056 }
8057 S::Sequence(mut values, None, deserializer) => {
8058 if let Some(deserializer) = deserializer {
8059 let value = deserializer.finish(helper)?;
8060 GroupTypeContentDeserializer::store_sequence(&mut values, value)?;
8061 }
8062 Ok(super::GroupTypeContent::Sequence(
8063 helper.finish_element("sequence", values)?,
8064 ))
8065 }
8066 S::Any(mut values, None, deserializer) => {
8067 if let Some(deserializer) = deserializer {
8068 let value = deserializer.finish(helper)?;
8069 GroupTypeContentDeserializer::store_any(&mut values, value)?;
8070 }
8071 Ok(super::GroupTypeContent::Any(
8072 helper.finish_element("any", values)?,
8073 ))
8074 }
8075 S::Done__(data) => Ok(data),
8076 _ => unreachable!(),
8077 }
8078 }
8079 fn store_annotation(
8080 values: &mut Option<super::Annotation>,
8081 value: super::Annotation,
8082 ) -> Result<(), Error> {
8083 if values.is_some() {
8084 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8085 b"annotation",
8086 )))?;
8087 }
8088 *values = Some(value);
8089 Ok(())
8090 }
8091 fn store_element(
8092 values: &mut Option<super::ElementType>,
8093 value: super::ElementType,
8094 ) -> Result<(), Error> {
8095 if values.is_some() {
8096 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8097 b"element",
8098 )))?;
8099 }
8100 *values = Some(value);
8101 Ok(())
8102 }
8103 fn store_group(
8104 values: &mut Option<super::GroupType>,
8105 value: super::GroupType,
8106 ) -> Result<(), Error> {
8107 if values.is_some() {
8108 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8109 b"group",
8110 )))?;
8111 }
8112 *values = Some(value);
8113 Ok(())
8114 }
8115 fn store_all(
8116 values: &mut Option<super::GroupType>,
8117 value: super::GroupType,
8118 ) -> Result<(), Error> {
8119 if values.is_some() {
8120 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"all")))?;
8121 }
8122 *values = Some(value);
8123 Ok(())
8124 }
8125 fn store_choice(
8126 values: &mut Option<super::GroupType>,
8127 value: super::GroupType,
8128 ) -> Result<(), Error> {
8129 if values.is_some() {
8130 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8131 b"choice",
8132 )))?;
8133 }
8134 *values = Some(value);
8135 Ok(())
8136 }
8137 fn store_sequence(
8138 values: &mut Option<super::GroupType>,
8139 value: super::GroupType,
8140 ) -> Result<(), Error> {
8141 if values.is_some() {
8142 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8143 b"sequence",
8144 )))?;
8145 }
8146 *values = Some(value);
8147 Ok(())
8148 }
8149 fn store_any(values: &mut Option<super::Any>, value: super::Any) -> Result<(), Error> {
8150 if values.is_some() {
8151 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"any")))?;
8152 }
8153 *values = Some(value);
8154 Ok(())
8155 }
8156 fn handle_annotation<'de>(
8157 &mut self,
8158 helper: &mut DeserializeHelper,
8159 mut values: Option<super::Annotation>,
8160 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
8161 output: DeserializerOutput<'de, super::Annotation>,
8162 ) -> Result<ElementHandlerOutput<'de>, Error> {
8163 use GroupTypeContentDeserializerState as S;
8164 let DeserializerOutput {
8165 artifact,
8166 event,
8167 allow_any,
8168 } = output;
8169 if artifact.is_none() {
8170 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
8171 }
8172 if let Some(deserializer) = fallback {
8173 let data = deserializer.finish(helper)?;
8174 GroupTypeContentDeserializer::store_annotation(&mut values, data)?;
8175 }
8176 match artifact {
8177 DeserializerArtifact::None => unreachable!(),
8178 DeserializerArtifact::Data(data) => {
8179 GroupTypeContentDeserializer::store_annotation(&mut values, data)?;
8180 let data = GroupTypeContentDeserializer::finish_state(
8181 helper,
8182 S::Annotation(values, None, None),
8183 )?;
8184 *self.state__ = S::Done__(data);
8185 Ok(ElementHandlerOutput::break_(event, allow_any))
8186 }
8187 DeserializerArtifact::Deserializer(deserializer) => {
8188 *self.state__ = S::Annotation(values, None, Some(deserializer));
8189 Ok(ElementHandlerOutput::break_(event, allow_any))
8190 }
8191 }
8192 }
8193 fn handle_element<'de>(
8194 &mut self,
8195 helper: &mut DeserializeHelper,
8196 mut values: Option<super::ElementType>,
8197 fallback: Option<<super::ElementType as WithDeserializer>::Deserializer>,
8198 output: DeserializerOutput<'de, super::ElementType>,
8199 ) -> Result<ElementHandlerOutput<'de>, Error> {
8200 use GroupTypeContentDeserializerState as S;
8201 let DeserializerOutput {
8202 artifact,
8203 event,
8204 allow_any,
8205 } = output;
8206 if artifact.is_none() {
8207 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
8208 }
8209 if let Some(deserializer) = fallback {
8210 let data = deserializer.finish(helper)?;
8211 GroupTypeContentDeserializer::store_element(&mut values, data)?;
8212 }
8213 match artifact {
8214 DeserializerArtifact::None => unreachable!(),
8215 DeserializerArtifact::Data(data) => {
8216 GroupTypeContentDeserializer::store_element(&mut values, data)?;
8217 let data = GroupTypeContentDeserializer::finish_state(
8218 helper,
8219 S::Element(values, None, None),
8220 )?;
8221 *self.state__ = S::Done__(data);
8222 Ok(ElementHandlerOutput::break_(event, allow_any))
8223 }
8224 DeserializerArtifact::Deserializer(deserializer) => {
8225 *self.state__ = S::Element(values, None, Some(deserializer));
8226 Ok(ElementHandlerOutput::break_(event, allow_any))
8227 }
8228 }
8229 }
8230 fn handle_group<'de>(
8231 &mut self,
8232 helper: &mut DeserializeHelper,
8233 mut values: Option<super::GroupType>,
8234 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
8235 output: DeserializerOutput<'de, super::GroupType>,
8236 ) -> Result<ElementHandlerOutput<'de>, Error> {
8237 use GroupTypeContentDeserializerState as S;
8238 let DeserializerOutput {
8239 artifact,
8240 event,
8241 allow_any,
8242 } = output;
8243 if artifact.is_none() {
8244 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
8245 }
8246 if let Some(deserializer) = fallback {
8247 let data = deserializer.finish(helper)?;
8248 GroupTypeContentDeserializer::store_group(&mut values, data)?;
8249 }
8250 match artifact {
8251 DeserializerArtifact::None => unreachable!(),
8252 DeserializerArtifact::Data(data) => {
8253 GroupTypeContentDeserializer::store_group(&mut values, data)?;
8254 let data = GroupTypeContentDeserializer::finish_state(
8255 helper,
8256 S::Group(values, None, None),
8257 )?;
8258 *self.state__ = S::Done__(data);
8259 Ok(ElementHandlerOutput::break_(event, allow_any))
8260 }
8261 DeserializerArtifact::Deserializer(deserializer) => {
8262 *self.state__ = S::Group(values, None, Some(deserializer));
8263 Ok(ElementHandlerOutput::break_(event, allow_any))
8264 }
8265 }
8266 }
8267 fn handle_all<'de>(
8268 &mut self,
8269 helper: &mut DeserializeHelper,
8270 mut values: Option<super::GroupType>,
8271 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
8272 output: DeserializerOutput<'de, super::GroupType>,
8273 ) -> Result<ElementHandlerOutput<'de>, Error> {
8274 use GroupTypeContentDeserializerState as S;
8275 let DeserializerOutput {
8276 artifact,
8277 event,
8278 allow_any,
8279 } = output;
8280 if artifact.is_none() {
8281 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
8282 }
8283 if let Some(deserializer) = fallback {
8284 let data = deserializer.finish(helper)?;
8285 GroupTypeContentDeserializer::store_all(&mut values, data)?;
8286 }
8287 match artifact {
8288 DeserializerArtifact::None => unreachable!(),
8289 DeserializerArtifact::Data(data) => {
8290 GroupTypeContentDeserializer::store_all(&mut values, data)?;
8291 let data = GroupTypeContentDeserializer::finish_state(
8292 helper,
8293 S::All(values, None, None),
8294 )?;
8295 *self.state__ = S::Done__(data);
8296 Ok(ElementHandlerOutput::break_(event, allow_any))
8297 }
8298 DeserializerArtifact::Deserializer(deserializer) => {
8299 *self.state__ = S::All(values, None, Some(deserializer));
8300 Ok(ElementHandlerOutput::break_(event, allow_any))
8301 }
8302 }
8303 }
8304 fn handle_choice<'de>(
8305 &mut self,
8306 helper: &mut DeserializeHelper,
8307 mut values: Option<super::GroupType>,
8308 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
8309 output: DeserializerOutput<'de, super::GroupType>,
8310 ) -> Result<ElementHandlerOutput<'de>, Error> {
8311 use GroupTypeContentDeserializerState as S;
8312 let DeserializerOutput {
8313 artifact,
8314 event,
8315 allow_any,
8316 } = output;
8317 if artifact.is_none() {
8318 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
8319 }
8320 if let Some(deserializer) = fallback {
8321 let data = deserializer.finish(helper)?;
8322 GroupTypeContentDeserializer::store_choice(&mut values, data)?;
8323 }
8324 match artifact {
8325 DeserializerArtifact::None => unreachable!(),
8326 DeserializerArtifact::Data(data) => {
8327 GroupTypeContentDeserializer::store_choice(&mut values, data)?;
8328 let data = GroupTypeContentDeserializer::finish_state(
8329 helper,
8330 S::Choice(values, None, None),
8331 )?;
8332 *self.state__ = S::Done__(data);
8333 Ok(ElementHandlerOutput::break_(event, allow_any))
8334 }
8335 DeserializerArtifact::Deserializer(deserializer) => {
8336 *self.state__ = S::Choice(values, None, Some(deserializer));
8337 Ok(ElementHandlerOutput::break_(event, allow_any))
8338 }
8339 }
8340 }
8341 fn handle_sequence<'de>(
8342 &mut self,
8343 helper: &mut DeserializeHelper,
8344 mut values: Option<super::GroupType>,
8345 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
8346 output: DeserializerOutput<'de, super::GroupType>,
8347 ) -> Result<ElementHandlerOutput<'de>, Error> {
8348 use GroupTypeContentDeserializerState as S;
8349 let DeserializerOutput {
8350 artifact,
8351 event,
8352 allow_any,
8353 } = output;
8354 if artifact.is_none() {
8355 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
8356 }
8357 if let Some(deserializer) = fallback {
8358 let data = deserializer.finish(helper)?;
8359 GroupTypeContentDeserializer::store_sequence(&mut values, data)?;
8360 }
8361 match artifact {
8362 DeserializerArtifact::None => unreachable!(),
8363 DeserializerArtifact::Data(data) => {
8364 GroupTypeContentDeserializer::store_sequence(&mut values, data)?;
8365 let data = GroupTypeContentDeserializer::finish_state(
8366 helper,
8367 S::Sequence(values, None, None),
8368 )?;
8369 *self.state__ = S::Done__(data);
8370 Ok(ElementHandlerOutput::break_(event, allow_any))
8371 }
8372 DeserializerArtifact::Deserializer(deserializer) => {
8373 *self.state__ = S::Sequence(values, None, Some(deserializer));
8374 Ok(ElementHandlerOutput::break_(event, allow_any))
8375 }
8376 }
8377 }
8378 fn handle_any<'de>(
8379 &mut self,
8380 helper: &mut DeserializeHelper,
8381 mut values: Option<super::Any>,
8382 fallback: Option<<super::Any as WithDeserializer>::Deserializer>,
8383 output: DeserializerOutput<'de, super::Any>,
8384 ) -> Result<ElementHandlerOutput<'de>, Error> {
8385 use GroupTypeContentDeserializerState as S;
8386 let DeserializerOutput {
8387 artifact,
8388 event,
8389 allow_any,
8390 } = output;
8391 if artifact.is_none() {
8392 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
8393 }
8394 if let Some(deserializer) = fallback {
8395 let data = deserializer.finish(helper)?;
8396 GroupTypeContentDeserializer::store_any(&mut values, data)?;
8397 }
8398 match artifact {
8399 DeserializerArtifact::None => unreachable!(),
8400 DeserializerArtifact::Data(data) => {
8401 GroupTypeContentDeserializer::store_any(&mut values, data)?;
8402 let data = GroupTypeContentDeserializer::finish_state(
8403 helper,
8404 S::Any(values, None, None),
8405 )?;
8406 *self.state__ = S::Done__(data);
8407 Ok(ElementHandlerOutput::break_(event, allow_any))
8408 }
8409 DeserializerArtifact::Deserializer(deserializer) => {
8410 *self.state__ = S::Any(values, None, Some(deserializer));
8411 Ok(ElementHandlerOutput::break_(event, allow_any))
8412 }
8413 }
8414 }
8415 }
8416 impl<'de> Deserializer<'de, super::GroupTypeContent> for Box<GroupTypeContentDeserializer> {
8417 fn init(
8418 helper: &mut DeserializeHelper,
8419 event: Event<'de>,
8420 ) -> DeserializerResult<'de, super::GroupTypeContent> {
8421 let deserializer = Box::new(GroupTypeContentDeserializer {
8422 state__: Box::new(GroupTypeContentDeserializerState::Init__),
8423 });
8424 let mut output = deserializer.next(helper, event)?;
8425 output.artifact = match output.artifact {
8426 DeserializerArtifact::Deserializer(x)
8427 if matches!(&*x.state__, GroupTypeContentDeserializerState::Init__) =>
8428 {
8429 DeserializerArtifact::None
8430 }
8431 artifact => artifact,
8432 };
8433 Ok(output)
8434 }
8435 fn next(
8436 mut self,
8437 helper: &mut DeserializeHelper,
8438 event: Event<'de>,
8439 ) -> DeserializerResult<'de, super::GroupTypeContent> {
8440 use GroupTypeContentDeserializerState as S;
8441 let mut event = event;
8442 let (event, allow_any) = loop {
8443 let state = replace(&mut *self.state__, S::Unknown__);
8444 event = match (state, event) {
8445 (S::Unknown__, _) => unreachable!(),
8446 (S::Annotation(values, fallback, Some(deserializer)), event) => {
8447 let output = deserializer.next(helper, event)?;
8448 match self.handle_annotation(helper, values, fallback, output)? {
8449 ElementHandlerOutput::Break { event, allow_any } => {
8450 break (event, allow_any)
8451 }
8452 ElementHandlerOutput::Continue { event, .. } => event,
8453 }
8454 }
8455 (S::Element(values, fallback, Some(deserializer)), event) => {
8456 let output = deserializer.next(helper, event)?;
8457 match self.handle_element(helper, values, fallback, output)? {
8458 ElementHandlerOutput::Break { event, allow_any } => {
8459 break (event, allow_any)
8460 }
8461 ElementHandlerOutput::Continue { event, .. } => event,
8462 }
8463 }
8464 (S::Group(values, fallback, Some(deserializer)), event) => {
8465 let output = deserializer.next(helper, event)?;
8466 match self.handle_group(helper, values, fallback, output)? {
8467 ElementHandlerOutput::Break { event, allow_any } => {
8468 break (event, allow_any)
8469 }
8470 ElementHandlerOutput::Continue { event, .. } => event,
8471 }
8472 }
8473 (S::All(values, fallback, Some(deserializer)), event) => {
8474 let output = deserializer.next(helper, event)?;
8475 match self.handle_all(helper, values, fallback, output)? {
8476 ElementHandlerOutput::Break { event, allow_any } => {
8477 break (event, allow_any)
8478 }
8479 ElementHandlerOutput::Continue { event, .. } => event,
8480 }
8481 }
8482 (S::Choice(values, fallback, Some(deserializer)), event) => {
8483 let output = deserializer.next(helper, event)?;
8484 match self.handle_choice(helper, values, fallback, output)? {
8485 ElementHandlerOutput::Break { event, allow_any } => {
8486 break (event, allow_any)
8487 }
8488 ElementHandlerOutput::Continue { event, .. } => event,
8489 }
8490 }
8491 (S::Sequence(values, fallback, Some(deserializer)), event) => {
8492 let output = deserializer.next(helper, event)?;
8493 match self.handle_sequence(helper, values, fallback, output)? {
8494 ElementHandlerOutput::Break { event, allow_any } => {
8495 break (event, allow_any)
8496 }
8497 ElementHandlerOutput::Continue { event, .. } => event,
8498 }
8499 }
8500 (S::Any(values, fallback, Some(deserializer)), event) => {
8501 let output = deserializer.next(helper, event)?;
8502 match self.handle_any(helper, values, fallback, output)? {
8503 ElementHandlerOutput::Break { event, allow_any } => {
8504 break (event, allow_any)
8505 }
8506 ElementHandlerOutput::Continue { event, .. } => event,
8507 }
8508 }
8509 (state, event @ Event::End(_)) => {
8510 return Ok(DeserializerOutput {
8511 artifact: DeserializerArtifact::Data(
8512 GroupTypeContentDeserializer::finish_state(helper, state)?,
8513 ),
8514 event: DeserializerEvent::Continue(event),
8515 allow_any: false,
8516 });
8517 }
8518 (S::Init__, event) => match self.find_suitable(helper, event)? {
8519 ElementHandlerOutput::Break { event, allow_any } => {
8520 break (event, allow_any)
8521 }
8522 ElementHandlerOutput::Continue { event, .. } => event,
8523 },
8524 (
8525 S::Annotation(values, fallback, None),
8526 event @ (Event::Start(_) | Event::Empty(_)),
8527 ) => {
8528 let output = helper.init_start_tag_deserializer(
8529 event,
8530 Some(&super::NS_XS),
8531 b"annotation",
8532 false,
8533 )?;
8534 match self.handle_annotation(helper, values, fallback, output)? {
8535 ElementHandlerOutput::Break { event, allow_any } => {
8536 break (event, allow_any)
8537 }
8538 ElementHandlerOutput::Continue { event, .. } => event,
8539 }
8540 }
8541 (
8542 S::Element(values, fallback, None),
8543 event @ (Event::Start(_) | Event::Empty(_)),
8544 ) => {
8545 let output = helper.init_start_tag_deserializer(
8546 event,
8547 Some(&super::NS_XS),
8548 b"element",
8549 true,
8550 )?;
8551 match self.handle_element(helper, values, fallback, output)? {
8552 ElementHandlerOutput::Break { event, allow_any } => {
8553 break (event, allow_any)
8554 }
8555 ElementHandlerOutput::Continue { event, .. } => event,
8556 }
8557 }
8558 (
8559 S::Group(values, fallback, None),
8560 event @ (Event::Start(_) | Event::Empty(_)),
8561 ) => {
8562 let output = helper.init_start_tag_deserializer(
8563 event,
8564 Some(&super::NS_XS),
8565 b"group",
8566 true,
8567 )?;
8568 match self.handle_group(helper, values, fallback, output)? {
8569 ElementHandlerOutput::Break { event, allow_any } => {
8570 break (event, allow_any)
8571 }
8572 ElementHandlerOutput::Continue { event, .. } => event,
8573 }
8574 }
8575 (
8576 S::All(values, fallback, None),
8577 event @ (Event::Start(_) | Event::Empty(_)),
8578 ) => {
8579 let output = helper.init_start_tag_deserializer(
8580 event,
8581 Some(&super::NS_XS),
8582 b"all",
8583 true,
8584 )?;
8585 match self.handle_all(helper, values, fallback, output)? {
8586 ElementHandlerOutput::Break { event, allow_any } => {
8587 break (event, allow_any)
8588 }
8589 ElementHandlerOutput::Continue { event, .. } => event,
8590 }
8591 }
8592 (
8593 S::Choice(values, fallback, None),
8594 event @ (Event::Start(_) | Event::Empty(_)),
8595 ) => {
8596 let output = helper.init_start_tag_deserializer(
8597 event,
8598 Some(&super::NS_XS),
8599 b"choice",
8600 true,
8601 )?;
8602 match self.handle_choice(helper, values, fallback, output)? {
8603 ElementHandlerOutput::Break { event, allow_any } => {
8604 break (event, allow_any)
8605 }
8606 ElementHandlerOutput::Continue { event, .. } => event,
8607 }
8608 }
8609 (
8610 S::Sequence(values, fallback, None),
8611 event @ (Event::Start(_) | Event::Empty(_)),
8612 ) => {
8613 let output = helper.init_start_tag_deserializer(
8614 event,
8615 Some(&super::NS_XS),
8616 b"sequence",
8617 true,
8618 )?;
8619 match self.handle_sequence(helper, values, fallback, output)? {
8620 ElementHandlerOutput::Break { event, allow_any } => {
8621 break (event, allow_any)
8622 }
8623 ElementHandlerOutput::Continue { event, .. } => event,
8624 }
8625 }
8626 (
8627 S::Any(values, fallback, None),
8628 event @ (Event::Start(_) | Event::Empty(_)),
8629 ) => {
8630 let output = helper.init_start_tag_deserializer(
8631 event,
8632 Some(&super::NS_XS),
8633 b"any",
8634 false,
8635 )?;
8636 match self.handle_any(helper, values, fallback, output)? {
8637 ElementHandlerOutput::Break { event, allow_any } => {
8638 break (event, allow_any)
8639 }
8640 ElementHandlerOutput::Continue { event, .. } => event,
8641 }
8642 }
8643 (state @ S::Done__(_), event) => {
8644 *self.state__ = state;
8645 break (DeserializerEvent::Continue(event), false);
8646 }
8647 (state, event) => {
8648 *self.state__ = state;
8649 break (DeserializerEvent::Continue(event), false);
8650 }
8651 }
8652 };
8653 let artifact = if matches!(&*self.state__, S::Done__(_)) {
8654 DeserializerArtifact::Data(self.finish(helper)?)
8655 } else {
8656 DeserializerArtifact::Deserializer(self)
8657 };
8658 Ok(DeserializerOutput {
8659 artifact,
8660 event,
8661 allow_any,
8662 })
8663 }
8664 fn finish(self, helper: &mut DeserializeHelper) -> Result<super::GroupTypeContent, Error> {
8665 GroupTypeContentDeserializer::finish_state(helper, *self.state__)
8666 }
8667 }
8668 #[derive(Debug)]
8669 pub struct AttributeGroupTypeDeserializer {
8670 id: Option<String>,
8671 name: Option<String>,
8672 ref_: Option<QName>,
8673 content: Vec<super::AttributeGroupTypeContent>,
8674 state__: Box<AttributeGroupTypeDeserializerState>,
8675 }
8676 #[derive(Debug)]
8677 enum AttributeGroupTypeDeserializerState {
8678 Init__,
8679 Next__,
8680 Content__(<super::AttributeGroupTypeContent as WithDeserializer>::Deserializer),
8681 Unknown__,
8682 }
8683 impl AttributeGroupTypeDeserializer {
8684 fn from_bytes_start(
8685 helper: &mut DeserializeHelper,
8686 bytes_start: &BytesStart<'_>,
8687 ) -> Result<Box<Self>, Error> {
8688 let mut id: Option<String> = None;
8689 let mut name: Option<String> = None;
8690 let mut ref_: Option<QName> = None;
8691 for attrib in helper.filter_xmlns_attributes(bytes_start) {
8692 let attrib = attrib?;
8693 if matches!(
8694 helper.resolve_local_name(attrib.key, &super::NS_XS),
8695 Some(b"id")
8696 ) {
8697 helper.read_attrib(&mut id, b"id", &attrib.value)?;
8698 } else if matches!(
8699 helper.resolve_local_name(attrib.key, &super::NS_XS),
8700 Some(b"name")
8701 ) {
8702 helper.read_attrib(&mut name, b"name", &attrib.value)?;
8703 } else if matches!(
8704 helper.resolve_local_name(attrib.key, &super::NS_XS),
8705 Some(b"ref")
8706 ) {
8707 helper.read_attrib(&mut ref_, b"ref", &attrib.value)?;
8708 }
8709 }
8710 Ok(Box::new(Self {
8711 id: id,
8712 name: name,
8713 ref_: ref_,
8714 content: Vec::new(),
8715 state__: Box::new(AttributeGroupTypeDeserializerState::Init__),
8716 }))
8717 }
8718 fn finish_state(
8719 &mut self,
8720 helper: &mut DeserializeHelper,
8721 state: AttributeGroupTypeDeserializerState,
8722 ) -> Result<(), Error> {
8723 if let AttributeGroupTypeDeserializerState::Content__(deserializer) = state {
8724 self.store_content(deserializer.finish(helper)?)?;
8725 }
8726 Ok(())
8727 }
8728 fn store_content(&mut self, value: super::AttributeGroupTypeContent) -> Result<(), Error> {
8729 self.content.push(value);
8730 Ok(())
8731 }
8732 fn handle_content<'de>(
8733 &mut self,
8734 helper: &mut DeserializeHelper,
8735 output: DeserializerOutput<'de, super::AttributeGroupTypeContent>,
8736 fallback: &mut Option<AttributeGroupTypeDeserializerState>,
8737 ) -> Result<ElementHandlerOutput<'de>, Error> {
8738 use AttributeGroupTypeDeserializerState as S;
8739 let DeserializerOutput {
8740 artifact,
8741 event,
8742 allow_any,
8743 } = output;
8744 if artifact.is_none() {
8745 *self.state__ = fallback.take().unwrap_or(S::Next__);
8746 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
8747 }
8748 if let Some(fallback) = fallback.take() {
8749 self.finish_state(helper, fallback)?;
8750 }
8751 match artifact {
8752 DeserializerArtifact::None => unreachable!(),
8753 DeserializerArtifact::Data(data) => {
8754 self.store_content(data)?;
8755 *self.state__ = S::Next__;
8756 Ok(ElementHandlerOutput::from_event(event, allow_any))
8757 }
8758 DeserializerArtifact::Deserializer(deserializer) => {
8759 *fallback = Some(S::Content__(deserializer));
8760 *self.state__ = S::Next__;
8761 Ok(ElementHandlerOutput::from_event(event, allow_any))
8762 }
8763 }
8764 }
8765 }
8766 impl<'de> Deserializer<'de, super::AttributeGroupType> for Box<AttributeGroupTypeDeserializer> {
8767 fn init(
8768 helper: &mut DeserializeHelper,
8769 event: Event<'de>,
8770 ) -> DeserializerResult<'de, super::AttributeGroupType> {
8771 helper.init_deserializer_from_start_event(
8772 event,
8773 AttributeGroupTypeDeserializer::from_bytes_start,
8774 )
8775 }
8776 fn next(
8777 mut self,
8778 helper: &mut DeserializeHelper,
8779 event: Event<'de>,
8780 ) -> DeserializerResult<'de, super::AttributeGroupType> {
8781 use AttributeGroupTypeDeserializerState as S;
8782 let mut event = event;
8783 let mut fallback = None;
8784 let (event, allow_any) = loop {
8785 let state = replace(&mut *self.state__, S::Unknown__);
8786 event = match (state, event) {
8787 (S::Unknown__, _) => unreachable!(),
8788 (S::Content__(deserializer), event) => {
8789 let output = deserializer.next(helper, event)?;
8790 match self.handle_content(helper, output, &mut fallback)? {
8791 ElementHandlerOutput::Break { event, allow_any } => {
8792 break (event, allow_any)
8793 }
8794 ElementHandlerOutput::Continue { event, .. } => event,
8795 }
8796 }
8797 (_, Event::End(_)) => {
8798 return Ok(DeserializerOutput {
8799 artifact: DeserializerArtifact::Data(self.finish(helper)?),
8800 event: DeserializerEvent::None,
8801 allow_any: false,
8802 });
8803 }
8804 (state @ (S::Init__ | S::Next__), event) => {
8805 fallback.get_or_insert(state);
8806 let output = <super::AttributeGroupTypeContent as WithDeserializer>::init(
8807 helper, event,
8808 )?;
8809 match self.handle_content(helper, output, &mut fallback)? {
8810 ElementHandlerOutput::Break { event, allow_any } => {
8811 break (event, allow_any)
8812 }
8813 ElementHandlerOutput::Continue { event, .. } => event,
8814 }
8815 }
8816 }
8817 };
8818 if let Some(fallback) = fallback {
8819 *self.state__ = fallback;
8820 }
8821 let artifact = DeserializerArtifact::Deserializer(self);
8822 Ok(DeserializerOutput {
8823 artifact,
8824 event,
8825 allow_any,
8826 })
8827 }
8828 fn finish(
8829 mut self,
8830 helper: &mut DeserializeHelper,
8831 ) -> Result<super::AttributeGroupType, Error> {
8832 let state = replace(
8833 &mut *self.state__,
8834 AttributeGroupTypeDeserializerState::Unknown__,
8835 );
8836 self.finish_state(helper, state)?;
8837 Ok(super::AttributeGroupType {
8838 id: self.id,
8839 name: self.name,
8840 ref_: self.ref_,
8841 content: helper.finish_vec(0usize, None, self.content)?,
8842 })
8843 }
8844 }
8845 #[derive(Debug)]
8846 pub struct AttributeGroupTypeContentDeserializer {
8847 state__: Box<AttributeGroupTypeContentDeserializerState>,
8848 }
8849 #[derive(Debug)]
8850 pub enum AttributeGroupTypeContentDeserializerState {
8851 Init__,
8852 Annotation(
8853 Option<super::Annotation>,
8854 Option<<super::Annotation as WithDeserializer>::Deserializer>,
8855 Option<<super::Annotation as WithDeserializer>::Deserializer>,
8856 ),
8857 Attribute(
8858 Option<super::AttributeType>,
8859 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
8860 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
8861 ),
8862 AttributeGroup(
8863 Option<super::AttributeGroupType>,
8864 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
8865 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
8866 ),
8867 AnyAttribute(
8868 Option<super::AnyAttribute>,
8869 Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
8870 Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
8871 ),
8872 Done__(super::AttributeGroupTypeContent),
8873 Unknown__,
8874 }
8875 impl AttributeGroupTypeContentDeserializer {
8876 fn find_suitable<'de>(
8877 &mut self,
8878 helper: &mut DeserializeHelper,
8879 event: Event<'de>,
8880 ) -> Result<ElementHandlerOutput<'de>, Error> {
8881 if let Event::Start(x) | Event::Empty(x) = &event {
8882 if matches!(
8883 helper.resolve_local_name(x.name(), &super::NS_XS),
8884 Some(b"annotation")
8885 ) {
8886 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
8887 return self.handle_annotation(helper, Default::default(), None, output);
8888 }
8889 if matches!(
8890 helper.resolve_local_name(x.name(), &super::NS_XS),
8891 Some(b"attribute")
8892 ) {
8893 let output = <super::AttributeType as WithDeserializer>::init(helper, event)?;
8894 return self.handle_attribute(helper, Default::default(), None, output);
8895 }
8896 if matches!(
8897 helper.resolve_local_name(x.name(), &super::NS_XS),
8898 Some(b"attributeGroup")
8899 ) {
8900 let output =
8901 <super::AttributeGroupType as WithDeserializer>::init(helper, event)?;
8902 return self.handle_attribute_group(helper, Default::default(), None, output);
8903 }
8904 if matches!(
8905 helper.resolve_local_name(x.name(), &super::NS_XS),
8906 Some(b"anyAttribute")
8907 ) {
8908 let output = <super::AnyAttribute as WithDeserializer>::init(helper, event)?;
8909 return self.handle_any_attribute(helper, Default::default(), None, output);
8910 }
8911 }
8912 *self.state__ = AttributeGroupTypeContentDeserializerState::Init__;
8913 Ok(ElementHandlerOutput::return_to_parent(event, false))
8914 }
8915 fn finish_state(
8916 helper: &mut DeserializeHelper,
8917 state: AttributeGroupTypeContentDeserializerState,
8918 ) -> Result<super::AttributeGroupTypeContent, Error> {
8919 use AttributeGroupTypeContentDeserializerState as S;
8920 match state {
8921 S::Init__ => Err(ErrorKind::MissingContent.into()),
8922 S::Annotation(mut values, None, deserializer) => {
8923 if let Some(deserializer) = deserializer {
8924 let value = deserializer.finish(helper)?;
8925 AttributeGroupTypeContentDeserializer::store_annotation(
8926 &mut values,
8927 value,
8928 )?;
8929 }
8930 Ok(super::AttributeGroupTypeContent::Annotation(
8931 helper.finish_element("annotation", values)?,
8932 ))
8933 }
8934 S::Attribute(mut values, None, deserializer) => {
8935 if let Some(deserializer) = deserializer {
8936 let value = deserializer.finish(helper)?;
8937 AttributeGroupTypeContentDeserializer::store_attribute(&mut values, value)?;
8938 }
8939 Ok(super::AttributeGroupTypeContent::Attribute(
8940 helper.finish_element("attribute", values)?,
8941 ))
8942 }
8943 S::AttributeGroup(mut values, None, deserializer) => {
8944 if let Some(deserializer) = deserializer {
8945 let value = deserializer.finish(helper)?;
8946 AttributeGroupTypeContentDeserializer::store_attribute_group(
8947 &mut values,
8948 value,
8949 )?;
8950 }
8951 Ok(super::AttributeGroupTypeContent::AttributeGroup(
8952 helper.finish_element("attributeGroup", values)?,
8953 ))
8954 }
8955 S::AnyAttribute(mut values, None, deserializer) => {
8956 if let Some(deserializer) = deserializer {
8957 let value = deserializer.finish(helper)?;
8958 AttributeGroupTypeContentDeserializer::store_any_attribute(
8959 &mut values,
8960 value,
8961 )?;
8962 }
8963 Ok(super::AttributeGroupTypeContent::AnyAttribute(
8964 helper.finish_element("anyAttribute", values)?,
8965 ))
8966 }
8967 S::Done__(data) => Ok(data),
8968 _ => unreachable!(),
8969 }
8970 }
8971 fn store_annotation(
8972 values: &mut Option<super::Annotation>,
8973 value: super::Annotation,
8974 ) -> Result<(), Error> {
8975 if values.is_some() {
8976 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8977 b"annotation",
8978 )))?;
8979 }
8980 *values = Some(value);
8981 Ok(())
8982 }
8983 fn store_attribute(
8984 values: &mut Option<super::AttributeType>,
8985 value: super::AttributeType,
8986 ) -> Result<(), Error> {
8987 if values.is_some() {
8988 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
8989 b"attribute",
8990 )))?;
8991 }
8992 *values = Some(value);
8993 Ok(())
8994 }
8995 fn store_attribute_group(
8996 values: &mut Option<super::AttributeGroupType>,
8997 value: super::AttributeGroupType,
8998 ) -> Result<(), Error> {
8999 if values.is_some() {
9000 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9001 b"attributeGroup",
9002 )))?;
9003 }
9004 *values = Some(value);
9005 Ok(())
9006 }
9007 fn store_any_attribute(
9008 values: &mut Option<super::AnyAttribute>,
9009 value: super::AnyAttribute,
9010 ) -> Result<(), Error> {
9011 if values.is_some() {
9012 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9013 b"anyAttribute",
9014 )))?;
9015 }
9016 *values = Some(value);
9017 Ok(())
9018 }
9019 fn handle_annotation<'de>(
9020 &mut self,
9021 helper: &mut DeserializeHelper,
9022 mut values: Option<super::Annotation>,
9023 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
9024 output: DeserializerOutput<'de, super::Annotation>,
9025 ) -> Result<ElementHandlerOutput<'de>, Error> {
9026 use AttributeGroupTypeContentDeserializerState as S;
9027 let DeserializerOutput {
9028 artifact,
9029 event,
9030 allow_any,
9031 } = output;
9032 if artifact.is_none() {
9033 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
9034 }
9035 if let Some(deserializer) = fallback {
9036 let data = deserializer.finish(helper)?;
9037 AttributeGroupTypeContentDeserializer::store_annotation(&mut values, data)?;
9038 }
9039 match artifact {
9040 DeserializerArtifact::None => unreachable!(),
9041 DeserializerArtifact::Data(data) => {
9042 AttributeGroupTypeContentDeserializer::store_annotation(&mut values, data)?;
9043 let data = AttributeGroupTypeContentDeserializer::finish_state(
9044 helper,
9045 S::Annotation(values, None, None),
9046 )?;
9047 *self.state__ = S::Done__(data);
9048 Ok(ElementHandlerOutput::break_(event, allow_any))
9049 }
9050 DeserializerArtifact::Deserializer(deserializer) => {
9051 *self.state__ = S::Annotation(values, None, Some(deserializer));
9052 Ok(ElementHandlerOutput::break_(event, allow_any))
9053 }
9054 }
9055 }
9056 fn handle_attribute<'de>(
9057 &mut self,
9058 helper: &mut DeserializeHelper,
9059 mut values: Option<super::AttributeType>,
9060 fallback: Option<<super::AttributeType as WithDeserializer>::Deserializer>,
9061 output: DeserializerOutput<'de, super::AttributeType>,
9062 ) -> Result<ElementHandlerOutput<'de>, Error> {
9063 use AttributeGroupTypeContentDeserializerState as S;
9064 let DeserializerOutput {
9065 artifact,
9066 event,
9067 allow_any,
9068 } = output;
9069 if artifact.is_none() {
9070 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
9071 }
9072 if let Some(deserializer) = fallback {
9073 let data = deserializer.finish(helper)?;
9074 AttributeGroupTypeContentDeserializer::store_attribute(&mut values, data)?;
9075 }
9076 match artifact {
9077 DeserializerArtifact::None => unreachable!(),
9078 DeserializerArtifact::Data(data) => {
9079 AttributeGroupTypeContentDeserializer::store_attribute(&mut values, data)?;
9080 let data = AttributeGroupTypeContentDeserializer::finish_state(
9081 helper,
9082 S::Attribute(values, None, None),
9083 )?;
9084 *self.state__ = S::Done__(data);
9085 Ok(ElementHandlerOutput::break_(event, allow_any))
9086 }
9087 DeserializerArtifact::Deserializer(deserializer) => {
9088 *self.state__ = S::Attribute(values, None, Some(deserializer));
9089 Ok(ElementHandlerOutput::break_(event, allow_any))
9090 }
9091 }
9092 }
9093 fn handle_attribute_group<'de>(
9094 &mut self,
9095 helper: &mut DeserializeHelper,
9096 mut values: Option<super::AttributeGroupType>,
9097 fallback: Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
9098 output: DeserializerOutput<'de, super::AttributeGroupType>,
9099 ) -> Result<ElementHandlerOutput<'de>, Error> {
9100 use AttributeGroupTypeContentDeserializerState as S;
9101 let DeserializerOutput {
9102 artifact,
9103 event,
9104 allow_any,
9105 } = output;
9106 if artifact.is_none() {
9107 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
9108 }
9109 if let Some(deserializer) = fallback {
9110 let data = deserializer.finish(helper)?;
9111 AttributeGroupTypeContentDeserializer::store_attribute_group(&mut values, data)?;
9112 }
9113 match artifact {
9114 DeserializerArtifact::None => unreachable!(),
9115 DeserializerArtifact::Data(data) => {
9116 AttributeGroupTypeContentDeserializer::store_attribute_group(
9117 &mut values,
9118 data,
9119 )?;
9120 let data = AttributeGroupTypeContentDeserializer::finish_state(
9121 helper,
9122 S::AttributeGroup(values, None, None),
9123 )?;
9124 *self.state__ = S::Done__(data);
9125 Ok(ElementHandlerOutput::break_(event, allow_any))
9126 }
9127 DeserializerArtifact::Deserializer(deserializer) => {
9128 *self.state__ = S::AttributeGroup(values, None, Some(deserializer));
9129 Ok(ElementHandlerOutput::break_(event, allow_any))
9130 }
9131 }
9132 }
9133 fn handle_any_attribute<'de>(
9134 &mut self,
9135 helper: &mut DeserializeHelper,
9136 mut values: Option<super::AnyAttribute>,
9137 fallback: Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
9138 output: DeserializerOutput<'de, super::AnyAttribute>,
9139 ) -> Result<ElementHandlerOutput<'de>, Error> {
9140 use AttributeGroupTypeContentDeserializerState as S;
9141 let DeserializerOutput {
9142 artifact,
9143 event,
9144 allow_any,
9145 } = output;
9146 if artifact.is_none() {
9147 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
9148 }
9149 if let Some(deserializer) = fallback {
9150 let data = deserializer.finish(helper)?;
9151 AttributeGroupTypeContentDeserializer::store_any_attribute(&mut values, data)?;
9152 }
9153 match artifact {
9154 DeserializerArtifact::None => unreachable!(),
9155 DeserializerArtifact::Data(data) => {
9156 AttributeGroupTypeContentDeserializer::store_any_attribute(&mut values, data)?;
9157 let data = AttributeGroupTypeContentDeserializer::finish_state(
9158 helper,
9159 S::AnyAttribute(values, None, None),
9160 )?;
9161 *self.state__ = S::Done__(data);
9162 Ok(ElementHandlerOutput::break_(event, allow_any))
9163 }
9164 DeserializerArtifact::Deserializer(deserializer) => {
9165 *self.state__ = S::AnyAttribute(values, None, Some(deserializer));
9166 Ok(ElementHandlerOutput::break_(event, allow_any))
9167 }
9168 }
9169 }
9170 }
9171 impl<'de> Deserializer<'de, super::AttributeGroupTypeContent>
9172 for Box<AttributeGroupTypeContentDeserializer>
9173 {
9174 fn init(
9175 helper: &mut DeserializeHelper,
9176 event: Event<'de>,
9177 ) -> DeserializerResult<'de, super::AttributeGroupTypeContent> {
9178 let deserializer = Box::new(AttributeGroupTypeContentDeserializer {
9179 state__: Box::new(AttributeGroupTypeContentDeserializerState::Init__),
9180 });
9181 let mut output = deserializer.next(helper, event)?;
9182 output.artifact = match output.artifact {
9183 DeserializerArtifact::Deserializer(x)
9184 if matches!(
9185 &*x.state__,
9186 AttributeGroupTypeContentDeserializerState::Init__
9187 ) =>
9188 {
9189 DeserializerArtifact::None
9190 }
9191 artifact => artifact,
9192 };
9193 Ok(output)
9194 }
9195 fn next(
9196 mut self,
9197 helper: &mut DeserializeHelper,
9198 event: Event<'de>,
9199 ) -> DeserializerResult<'de, super::AttributeGroupTypeContent> {
9200 use AttributeGroupTypeContentDeserializerState as S;
9201 let mut event = event;
9202 let (event, allow_any) = loop {
9203 let state = replace(&mut *self.state__, S::Unknown__);
9204 event = match (state, event) {
9205 (S::Unknown__, _) => unreachable!(),
9206 (S::Annotation(values, fallback, Some(deserializer)), event) => {
9207 let output = deserializer.next(helper, event)?;
9208 match self.handle_annotation(helper, values, fallback, output)? {
9209 ElementHandlerOutput::Break { event, allow_any } => {
9210 break (event, allow_any)
9211 }
9212 ElementHandlerOutput::Continue { event, .. } => event,
9213 }
9214 }
9215 (S::Attribute(values, fallback, Some(deserializer)), event) => {
9216 let output = deserializer.next(helper, event)?;
9217 match self.handle_attribute(helper, values, fallback, output)? {
9218 ElementHandlerOutput::Break { event, allow_any } => {
9219 break (event, allow_any)
9220 }
9221 ElementHandlerOutput::Continue { event, .. } => event,
9222 }
9223 }
9224 (S::AttributeGroup(values, fallback, Some(deserializer)), event) => {
9225 let output = deserializer.next(helper, event)?;
9226 match self.handle_attribute_group(helper, values, fallback, output)? {
9227 ElementHandlerOutput::Break { event, allow_any } => {
9228 break (event, allow_any)
9229 }
9230 ElementHandlerOutput::Continue { event, .. } => event,
9231 }
9232 }
9233 (S::AnyAttribute(values, fallback, Some(deserializer)), event) => {
9234 let output = deserializer.next(helper, event)?;
9235 match self.handle_any_attribute(helper, values, fallback, output)? {
9236 ElementHandlerOutput::Break { event, allow_any } => {
9237 break (event, allow_any)
9238 }
9239 ElementHandlerOutput::Continue { event, .. } => event,
9240 }
9241 }
9242 (state, event @ Event::End(_)) => {
9243 return Ok(DeserializerOutput {
9244 artifact: DeserializerArtifact::Data(
9245 AttributeGroupTypeContentDeserializer::finish_state(helper, state)?,
9246 ),
9247 event: DeserializerEvent::Continue(event),
9248 allow_any: false,
9249 });
9250 }
9251 (S::Init__, event) => match self.find_suitable(helper, event)? {
9252 ElementHandlerOutput::Break { event, allow_any } => {
9253 break (event, allow_any)
9254 }
9255 ElementHandlerOutput::Continue { event, .. } => event,
9256 },
9257 (
9258 S::Annotation(values, fallback, None),
9259 event @ (Event::Start(_) | Event::Empty(_)),
9260 ) => {
9261 let output = helper.init_start_tag_deserializer(
9262 event,
9263 Some(&super::NS_XS),
9264 b"annotation",
9265 false,
9266 )?;
9267 match self.handle_annotation(helper, values, fallback, output)? {
9268 ElementHandlerOutput::Break { event, allow_any } => {
9269 break (event, allow_any)
9270 }
9271 ElementHandlerOutput::Continue { event, .. } => event,
9272 }
9273 }
9274 (
9275 S::Attribute(values, fallback, None),
9276 event @ (Event::Start(_) | Event::Empty(_)),
9277 ) => {
9278 let output = helper.init_start_tag_deserializer(
9279 event,
9280 Some(&super::NS_XS),
9281 b"attribute",
9282 false,
9283 )?;
9284 match self.handle_attribute(helper, values, fallback, output)? {
9285 ElementHandlerOutput::Break { event, allow_any } => {
9286 break (event, allow_any)
9287 }
9288 ElementHandlerOutput::Continue { event, .. } => event,
9289 }
9290 }
9291 (
9292 S::AttributeGroup(values, fallback, None),
9293 event @ (Event::Start(_) | Event::Empty(_)),
9294 ) => {
9295 let output = helper.init_start_tag_deserializer(
9296 event,
9297 Some(&super::NS_XS),
9298 b"attributeGroup",
9299 false,
9300 )?;
9301 match self.handle_attribute_group(helper, values, fallback, output)? {
9302 ElementHandlerOutput::Break { event, allow_any } => {
9303 break (event, allow_any)
9304 }
9305 ElementHandlerOutput::Continue { event, .. } => event,
9306 }
9307 }
9308 (
9309 S::AnyAttribute(values, fallback, None),
9310 event @ (Event::Start(_) | Event::Empty(_)),
9311 ) => {
9312 let output = helper.init_start_tag_deserializer(
9313 event,
9314 Some(&super::NS_XS),
9315 b"anyAttribute",
9316 false,
9317 )?;
9318 match self.handle_any_attribute(helper, values, fallback, output)? {
9319 ElementHandlerOutput::Break { event, allow_any } => {
9320 break (event, allow_any)
9321 }
9322 ElementHandlerOutput::Continue { event, .. } => event,
9323 }
9324 }
9325 (state @ S::Done__(_), event) => {
9326 *self.state__ = state;
9327 break (DeserializerEvent::Continue(event), false);
9328 }
9329 (state, event) => {
9330 *self.state__ = state;
9331 break (DeserializerEvent::Continue(event), false);
9332 }
9333 }
9334 };
9335 let artifact = if matches!(&*self.state__, S::Done__(_)) {
9336 DeserializerArtifact::Data(self.finish(helper)?)
9337 } else {
9338 DeserializerArtifact::Deserializer(self)
9339 };
9340 Ok(DeserializerOutput {
9341 artifact,
9342 event,
9343 allow_any,
9344 })
9345 }
9346 fn finish(
9347 self,
9348 helper: &mut DeserializeHelper,
9349 ) -> Result<super::AttributeGroupTypeContent, Error> {
9350 AttributeGroupTypeContentDeserializer::finish_state(helper, *self.state__)
9351 }
9352 }
9353 #[derive(Debug)]
9354 pub struct ElementTypeDeserializer {
9355 id: Option<String>,
9356 name: Option<String>,
9357 ref_: Option<QName>,
9358 type_: Option<QName>,
9359 substitution_group: Option<super::QNameList>,
9360 min_occurs: usize,
9361 max_occurs: MaxOccurs,
9362 default: Option<String>,
9363 fixed: Option<String>,
9364 nillable: Option<bool>,
9365 abstract_: bool,
9366 final_: Option<super::DerivationSetType>,
9367 block: Option<super::BlockSetType>,
9368 form: Option<super::FormChoiceType>,
9369 target_namespace: Option<String>,
9370 content: Vec<super::ElementTypeContent>,
9371 state__: Box<ElementTypeDeserializerState>,
9372 }
9373 #[derive(Debug)]
9374 enum ElementTypeDeserializerState {
9375 Init__,
9376 Next__,
9377 Content__(<super::ElementTypeContent as WithDeserializer>::Deserializer),
9378 Unknown__,
9379 }
9380 impl ElementTypeDeserializer {
9381 fn from_bytes_start(
9382 helper: &mut DeserializeHelper,
9383 bytes_start: &BytesStart<'_>,
9384 ) -> Result<Box<Self>, Error> {
9385 let mut id: Option<String> = None;
9386 let mut name: Option<String> = None;
9387 let mut ref_: Option<QName> = None;
9388 let mut type_: Option<QName> = None;
9389 let mut substitution_group: Option<super::QNameList> = None;
9390 let mut min_occurs: Option<usize> = None;
9391 let mut max_occurs: Option<MaxOccurs> = None;
9392 let mut default: Option<String> = None;
9393 let mut fixed: Option<String> = None;
9394 let mut nillable: Option<bool> = None;
9395 let mut abstract_: Option<bool> = None;
9396 let mut final_: Option<super::DerivationSetType> = None;
9397 let mut block: Option<super::BlockSetType> = None;
9398 let mut form: Option<super::FormChoiceType> = None;
9399 let mut target_namespace: Option<String> = None;
9400 for attrib in helper.filter_xmlns_attributes(bytes_start) {
9401 let attrib = attrib?;
9402 if matches!(
9403 helper.resolve_local_name(attrib.key, &super::NS_XS),
9404 Some(b"id")
9405 ) {
9406 helper.read_attrib(&mut id, b"id", &attrib.value)?;
9407 } else if matches!(
9408 helper.resolve_local_name(attrib.key, &super::NS_XS),
9409 Some(b"name")
9410 ) {
9411 helper.read_attrib(&mut name, b"name", &attrib.value)?;
9412 } else if matches!(
9413 helper.resolve_local_name(attrib.key, &super::NS_XS),
9414 Some(b"ref")
9415 ) {
9416 helper.read_attrib(&mut ref_, b"ref", &attrib.value)?;
9417 } else if matches!(
9418 helper.resolve_local_name(attrib.key, &super::NS_XS),
9419 Some(b"type")
9420 ) {
9421 helper.read_attrib(&mut type_, b"type", &attrib.value)?;
9422 } else if matches!(
9423 helper.resolve_local_name(attrib.key, &super::NS_XS),
9424 Some(b"substitutionGroup")
9425 ) {
9426 helper.read_attrib(
9427 &mut substitution_group,
9428 b"substitutionGroup",
9429 &attrib.value,
9430 )?;
9431 } else if matches!(
9432 helper.resolve_local_name(attrib.key, &super::NS_XS),
9433 Some(b"minOccurs")
9434 ) {
9435 helper.read_attrib(&mut min_occurs, b"minOccurs", &attrib.value)?;
9436 } else if matches!(
9437 helper.resolve_local_name(attrib.key, &super::NS_XS),
9438 Some(b"maxOccurs")
9439 ) {
9440 helper.read_attrib(&mut max_occurs, b"maxOccurs", &attrib.value)?;
9441 } else if matches!(
9442 helper.resolve_local_name(attrib.key, &super::NS_XS),
9443 Some(b"default")
9444 ) {
9445 helper.read_attrib(&mut default, b"default", &attrib.value)?;
9446 } else if matches!(
9447 helper.resolve_local_name(attrib.key, &super::NS_XS),
9448 Some(b"fixed")
9449 ) {
9450 helper.read_attrib(&mut fixed, b"fixed", &attrib.value)?;
9451 } else if matches!(
9452 helper.resolve_local_name(attrib.key, &super::NS_XS),
9453 Some(b"nillable")
9454 ) {
9455 helper.read_attrib(&mut nillable, b"nillable", &attrib.value)?;
9456 } else if matches!(
9457 helper.resolve_local_name(attrib.key, &super::NS_XS),
9458 Some(b"abstract")
9459 ) {
9460 helper.read_attrib(&mut abstract_, b"abstract", &attrib.value)?;
9461 } else if matches!(
9462 helper.resolve_local_name(attrib.key, &super::NS_XS),
9463 Some(b"final")
9464 ) {
9465 helper.read_attrib(&mut final_, b"final", &attrib.value)?;
9466 } else if matches!(
9467 helper.resolve_local_name(attrib.key, &super::NS_XS),
9468 Some(b"block")
9469 ) {
9470 helper.read_attrib(&mut block, b"block", &attrib.value)?;
9471 } else if matches!(
9472 helper.resolve_local_name(attrib.key, &super::NS_XS),
9473 Some(b"form")
9474 ) {
9475 helper.read_attrib(&mut form, b"form", &attrib.value)?;
9476 } else if matches!(
9477 helper.resolve_local_name(attrib.key, &super::NS_XS),
9478 Some(b"targetNamespace")
9479 ) {
9480 helper.read_attrib(&mut target_namespace, b"targetNamespace", &attrib.value)?;
9481 }
9482 }
9483 Ok(Box::new(Self {
9484 id: id,
9485 name: name,
9486 ref_: ref_,
9487 type_: type_,
9488 substitution_group: substitution_group,
9489 min_occurs: min_occurs.unwrap_or_else(super::ElementType::default_min_occurs),
9490 max_occurs: max_occurs.unwrap_or_else(super::ElementType::default_max_occurs),
9491 default: default,
9492 fixed: fixed,
9493 nillable: nillable,
9494 abstract_: abstract_.unwrap_or_else(super::ElementType::default_abstract_),
9495 final_: final_,
9496 block: block,
9497 form: form,
9498 target_namespace: target_namespace,
9499 content: Vec::new(),
9500 state__: Box::new(ElementTypeDeserializerState::Init__),
9501 }))
9502 }
9503 fn finish_state(
9504 &mut self,
9505 helper: &mut DeserializeHelper,
9506 state: ElementTypeDeserializerState,
9507 ) -> Result<(), Error> {
9508 if let ElementTypeDeserializerState::Content__(deserializer) = state {
9509 self.store_content(deserializer.finish(helper)?)?;
9510 }
9511 Ok(())
9512 }
9513 fn store_content(&mut self, value: super::ElementTypeContent) -> Result<(), Error> {
9514 self.content.push(value);
9515 Ok(())
9516 }
9517 fn handle_content<'de>(
9518 &mut self,
9519 helper: &mut DeserializeHelper,
9520 output: DeserializerOutput<'de, super::ElementTypeContent>,
9521 fallback: &mut Option<ElementTypeDeserializerState>,
9522 ) -> Result<ElementHandlerOutput<'de>, Error> {
9523 use ElementTypeDeserializerState as S;
9524 let DeserializerOutput {
9525 artifact,
9526 event,
9527 allow_any,
9528 } = output;
9529 if artifact.is_none() {
9530 *self.state__ = fallback.take().unwrap_or(S::Next__);
9531 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
9532 }
9533 if let Some(fallback) = fallback.take() {
9534 self.finish_state(helper, fallback)?;
9535 }
9536 match artifact {
9537 DeserializerArtifact::None => unreachable!(),
9538 DeserializerArtifact::Data(data) => {
9539 self.store_content(data)?;
9540 *self.state__ = S::Next__;
9541 Ok(ElementHandlerOutput::from_event(event, allow_any))
9542 }
9543 DeserializerArtifact::Deserializer(deserializer) => {
9544 *fallback = Some(S::Content__(deserializer));
9545 *self.state__ = S::Next__;
9546 Ok(ElementHandlerOutput::from_event(event, allow_any))
9547 }
9548 }
9549 }
9550 }
9551 impl<'de> Deserializer<'de, super::ElementType> for Box<ElementTypeDeserializer> {
9552 fn init(
9553 helper: &mut DeserializeHelper,
9554 event: Event<'de>,
9555 ) -> DeserializerResult<'de, super::ElementType> {
9556 helper.init_deserializer_from_start_event(
9557 event,
9558 ElementTypeDeserializer::from_bytes_start,
9559 )
9560 }
9561 fn next(
9562 mut self,
9563 helper: &mut DeserializeHelper,
9564 event: Event<'de>,
9565 ) -> DeserializerResult<'de, super::ElementType> {
9566 use ElementTypeDeserializerState as S;
9567 let mut event = event;
9568 let mut fallback = None;
9569 let (event, allow_any) = loop {
9570 let state = replace(&mut *self.state__, S::Unknown__);
9571 event = match (state, event) {
9572 (S::Unknown__, _) => unreachable!(),
9573 (S::Content__(deserializer), event) => {
9574 let output = deserializer.next(helper, event)?;
9575 match self.handle_content(helper, output, &mut fallback)? {
9576 ElementHandlerOutput::Break { event, allow_any } => {
9577 break (event, allow_any)
9578 }
9579 ElementHandlerOutput::Continue { event, .. } => event,
9580 }
9581 }
9582 (_, Event::End(_)) => {
9583 return Ok(DeserializerOutput {
9584 artifact: DeserializerArtifact::Data(self.finish(helper)?),
9585 event: DeserializerEvent::None,
9586 allow_any: false,
9587 });
9588 }
9589 (state @ (S::Init__ | S::Next__), event) => {
9590 fallback.get_or_insert(state);
9591 let output =
9592 <super::ElementTypeContent as WithDeserializer>::init(helper, event)?;
9593 match self.handle_content(helper, output, &mut fallback)? {
9594 ElementHandlerOutput::Break { event, allow_any } => {
9595 break (event, allow_any)
9596 }
9597 ElementHandlerOutput::Continue { event, .. } => event,
9598 }
9599 }
9600 }
9601 };
9602 if let Some(fallback) = fallback {
9603 *self.state__ = fallback;
9604 }
9605 let artifact = DeserializerArtifact::Deserializer(self);
9606 Ok(DeserializerOutput {
9607 artifact,
9608 event,
9609 allow_any,
9610 })
9611 }
9612 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::ElementType, Error> {
9613 let state = replace(&mut *self.state__, ElementTypeDeserializerState::Unknown__);
9614 self.finish_state(helper, state)?;
9615 Ok(super::ElementType {
9616 id: self.id,
9617 name: self.name,
9618 ref_: self.ref_,
9619 type_: self.type_,
9620 substitution_group: self.substitution_group,
9621 min_occurs: self.min_occurs,
9622 max_occurs: self.max_occurs,
9623 default: self.default,
9624 fixed: self.fixed,
9625 nillable: self.nillable,
9626 abstract_: self.abstract_,
9627 final_: self.final_,
9628 block: self.block,
9629 form: self.form,
9630 target_namespace: self.target_namespace,
9631 content: helper.finish_vec(0usize, None, self.content)?,
9632 })
9633 }
9634 }
9635 #[derive(Debug)]
9636 pub struct ElementTypeContentDeserializer {
9637 state__: Box<ElementTypeContentDeserializerState>,
9638 }
9639 #[derive(Debug)]
9640 pub enum ElementTypeContentDeserializerState {
9641 Init__,
9642 Annotation(
9643 Option<super::Annotation>,
9644 Option<<super::Annotation as WithDeserializer>::Deserializer>,
9645 Option<<super::Annotation as WithDeserializer>::Deserializer>,
9646 ),
9647 SimpleType(
9648 Option<super::SimpleBaseType>,
9649 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
9650 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
9651 ),
9652 ComplexType(
9653 Option<super::ComplexBaseType>,
9654 Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
9655 Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
9656 ),
9657 Alternative(
9658 Option<super::AltType>,
9659 Option<<super::AltType as WithDeserializer>::Deserializer>,
9660 Option<<super::AltType as WithDeserializer>::Deserializer>,
9661 ),
9662 Unique(
9663 Option<super::KeybaseType>,
9664 Option<<super::KeybaseType as WithDeserializer>::Deserializer>,
9665 Option<<super::KeybaseType as WithDeserializer>::Deserializer>,
9666 ),
9667 Key(
9668 Option<super::KeybaseType>,
9669 Option<<super::KeybaseType as WithDeserializer>::Deserializer>,
9670 Option<<super::KeybaseType as WithDeserializer>::Deserializer>,
9671 ),
9672 Keyref(
9673 Option<super::Keyref>,
9674 Option<<super::Keyref as WithDeserializer>::Deserializer>,
9675 Option<<super::Keyref as WithDeserializer>::Deserializer>,
9676 ),
9677 Done__(super::ElementTypeContent),
9678 Unknown__,
9679 }
9680 impl ElementTypeContentDeserializer {
9681 fn find_suitable<'de>(
9682 &mut self,
9683 helper: &mut DeserializeHelper,
9684 event: Event<'de>,
9685 ) -> Result<ElementHandlerOutput<'de>, Error> {
9686 if let Event::Start(x) | Event::Empty(x) = &event {
9687 if matches!(
9688 helper.resolve_local_name(x.name(), &super::NS_XS),
9689 Some(b"annotation")
9690 ) {
9691 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
9692 return self.handle_annotation(helper, Default::default(), None, output);
9693 }
9694 if matches!(
9695 helper.resolve_local_name(x.name(), &super::NS_XS),
9696 Some(b"simpleType")
9697 ) {
9698 let output = <super::SimpleBaseType as WithDeserializer>::init(helper, event)?;
9699 return self.handle_simple_type(helper, Default::default(), None, output);
9700 }
9701 if matches!(
9702 helper.resolve_local_name(x.name(), &super::NS_XS),
9703 Some(b"complexType")
9704 ) {
9705 let output = <super::ComplexBaseType as WithDeserializer>::init(helper, event)?;
9706 return self.handle_complex_type(helper, Default::default(), None, output);
9707 }
9708 if matches!(
9709 helper.resolve_local_name(x.name(), &super::NS_XS),
9710 Some(b"alternative")
9711 ) {
9712 let output = <super::AltType as WithDeserializer>::init(helper, event)?;
9713 return self.handle_alternative(helper, Default::default(), None, output);
9714 }
9715 if matches!(
9716 helper.resolve_local_name(x.name(), &super::NS_XS),
9717 Some(b"unique")
9718 ) {
9719 let output = <super::KeybaseType as WithDeserializer>::init(helper, event)?;
9720 return self.handle_unique(helper, Default::default(), None, output);
9721 }
9722 if matches!(
9723 helper.resolve_local_name(x.name(), &super::NS_XS),
9724 Some(b"key")
9725 ) {
9726 let output = <super::KeybaseType as WithDeserializer>::init(helper, event)?;
9727 return self.handle_key(helper, Default::default(), None, output);
9728 }
9729 if matches!(
9730 helper.resolve_local_name(x.name(), &super::NS_XS),
9731 Some(b"keyref")
9732 ) {
9733 let output = <super::Keyref as WithDeserializer>::init(helper, event)?;
9734 return self.handle_keyref(helper, Default::default(), None, output);
9735 }
9736 }
9737 *self.state__ = ElementTypeContentDeserializerState::Init__;
9738 Ok(ElementHandlerOutput::return_to_parent(event, false))
9739 }
9740 fn finish_state(
9741 helper: &mut DeserializeHelper,
9742 state: ElementTypeContentDeserializerState,
9743 ) -> Result<super::ElementTypeContent, Error> {
9744 use ElementTypeContentDeserializerState as S;
9745 match state {
9746 S::Init__ => Err(ErrorKind::MissingContent.into()),
9747 S::Annotation(mut values, None, deserializer) => {
9748 if let Some(deserializer) = deserializer {
9749 let value = deserializer.finish(helper)?;
9750 ElementTypeContentDeserializer::store_annotation(&mut values, value)?;
9751 }
9752 Ok(super::ElementTypeContent::Annotation(
9753 helper.finish_element("annotation", values)?,
9754 ))
9755 }
9756 S::SimpleType(mut values, None, deserializer) => {
9757 if let Some(deserializer) = deserializer {
9758 let value = deserializer.finish(helper)?;
9759 ElementTypeContentDeserializer::store_simple_type(&mut values, value)?;
9760 }
9761 Ok(super::ElementTypeContent::SimpleType(
9762 helper.finish_element("simpleType", values)?,
9763 ))
9764 }
9765 S::ComplexType(mut values, None, deserializer) => {
9766 if let Some(deserializer) = deserializer {
9767 let value = deserializer.finish(helper)?;
9768 ElementTypeContentDeserializer::store_complex_type(&mut values, value)?;
9769 }
9770 Ok(super::ElementTypeContent::ComplexType(
9771 helper.finish_element("complexType", values)?,
9772 ))
9773 }
9774 S::Alternative(mut values, None, deserializer) => {
9775 if let Some(deserializer) = deserializer {
9776 let value = deserializer.finish(helper)?;
9777 ElementTypeContentDeserializer::store_alternative(&mut values, value)?;
9778 }
9779 Ok(super::ElementTypeContent::Alternative(
9780 helper.finish_element("alternative", values)?,
9781 ))
9782 }
9783 S::Unique(mut values, None, deserializer) => {
9784 if let Some(deserializer) = deserializer {
9785 let value = deserializer.finish(helper)?;
9786 ElementTypeContentDeserializer::store_unique(&mut values, value)?;
9787 }
9788 Ok(super::ElementTypeContent::Unique(
9789 helper.finish_element("unique", values)?,
9790 ))
9791 }
9792 S::Key(mut values, None, deserializer) => {
9793 if let Some(deserializer) = deserializer {
9794 let value = deserializer.finish(helper)?;
9795 ElementTypeContentDeserializer::store_key(&mut values, value)?;
9796 }
9797 Ok(super::ElementTypeContent::Key(
9798 helper.finish_element("key", values)?,
9799 ))
9800 }
9801 S::Keyref(mut values, None, deserializer) => {
9802 if let Some(deserializer) = deserializer {
9803 let value = deserializer.finish(helper)?;
9804 ElementTypeContentDeserializer::store_keyref(&mut values, value)?;
9805 }
9806 Ok(super::ElementTypeContent::Keyref(
9807 helper.finish_element("keyref", values)?,
9808 ))
9809 }
9810 S::Done__(data) => Ok(data),
9811 _ => unreachable!(),
9812 }
9813 }
9814 fn store_annotation(
9815 values: &mut Option<super::Annotation>,
9816 value: super::Annotation,
9817 ) -> Result<(), Error> {
9818 if values.is_some() {
9819 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9820 b"annotation",
9821 )))?;
9822 }
9823 *values = Some(value);
9824 Ok(())
9825 }
9826 fn store_simple_type(
9827 values: &mut Option<super::SimpleBaseType>,
9828 value: super::SimpleBaseType,
9829 ) -> Result<(), Error> {
9830 if values.is_some() {
9831 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9832 b"simpleType",
9833 )))?;
9834 }
9835 *values = Some(value);
9836 Ok(())
9837 }
9838 fn store_complex_type(
9839 values: &mut Option<super::ComplexBaseType>,
9840 value: super::ComplexBaseType,
9841 ) -> Result<(), Error> {
9842 if values.is_some() {
9843 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9844 b"complexType",
9845 )))?;
9846 }
9847 *values = Some(value);
9848 Ok(())
9849 }
9850 fn store_alternative(
9851 values: &mut Option<super::AltType>,
9852 value: super::AltType,
9853 ) -> Result<(), Error> {
9854 if values.is_some() {
9855 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9856 b"alternative",
9857 )))?;
9858 }
9859 *values = Some(value);
9860 Ok(())
9861 }
9862 fn store_unique(
9863 values: &mut Option<super::KeybaseType>,
9864 value: super::KeybaseType,
9865 ) -> Result<(), Error> {
9866 if values.is_some() {
9867 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9868 b"unique",
9869 )))?;
9870 }
9871 *values = Some(value);
9872 Ok(())
9873 }
9874 fn store_key(
9875 values: &mut Option<super::KeybaseType>,
9876 value: super::KeybaseType,
9877 ) -> Result<(), Error> {
9878 if values.is_some() {
9879 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"key")))?;
9880 }
9881 *values = Some(value);
9882 Ok(())
9883 }
9884 fn store_keyref(
9885 values: &mut Option<super::Keyref>,
9886 value: super::Keyref,
9887 ) -> Result<(), Error> {
9888 if values.is_some() {
9889 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
9890 b"keyref",
9891 )))?;
9892 }
9893 *values = Some(value);
9894 Ok(())
9895 }
9896 fn handle_annotation<'de>(
9897 &mut self,
9898 helper: &mut DeserializeHelper,
9899 mut values: Option<super::Annotation>,
9900 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
9901 output: DeserializerOutput<'de, super::Annotation>,
9902 ) -> Result<ElementHandlerOutput<'de>, Error> {
9903 use ElementTypeContentDeserializerState as S;
9904 let DeserializerOutput {
9905 artifact,
9906 event,
9907 allow_any,
9908 } = output;
9909 if artifact.is_none() {
9910 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
9911 }
9912 if let Some(deserializer) = fallback {
9913 let data = deserializer.finish(helper)?;
9914 ElementTypeContentDeserializer::store_annotation(&mut values, data)?;
9915 }
9916 match artifact {
9917 DeserializerArtifact::None => unreachable!(),
9918 DeserializerArtifact::Data(data) => {
9919 ElementTypeContentDeserializer::store_annotation(&mut values, data)?;
9920 let data = ElementTypeContentDeserializer::finish_state(
9921 helper,
9922 S::Annotation(values, None, None),
9923 )?;
9924 *self.state__ = S::Done__(data);
9925 Ok(ElementHandlerOutput::break_(event, allow_any))
9926 }
9927 DeserializerArtifact::Deserializer(deserializer) => {
9928 *self.state__ = S::Annotation(values, None, Some(deserializer));
9929 Ok(ElementHandlerOutput::break_(event, allow_any))
9930 }
9931 }
9932 }
9933 fn handle_simple_type<'de>(
9934 &mut self,
9935 helper: &mut DeserializeHelper,
9936 mut values: Option<super::SimpleBaseType>,
9937 fallback: Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
9938 output: DeserializerOutput<'de, super::SimpleBaseType>,
9939 ) -> Result<ElementHandlerOutput<'de>, Error> {
9940 use ElementTypeContentDeserializerState as S;
9941 let DeserializerOutput {
9942 artifact,
9943 event,
9944 allow_any,
9945 } = output;
9946 if artifact.is_none() {
9947 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
9948 }
9949 if let Some(deserializer) = fallback {
9950 let data = deserializer.finish(helper)?;
9951 ElementTypeContentDeserializer::store_simple_type(&mut values, data)?;
9952 }
9953 match artifact {
9954 DeserializerArtifact::None => unreachable!(),
9955 DeserializerArtifact::Data(data) => {
9956 ElementTypeContentDeserializer::store_simple_type(&mut values, data)?;
9957 let data = ElementTypeContentDeserializer::finish_state(
9958 helper,
9959 S::SimpleType(values, None, None),
9960 )?;
9961 *self.state__ = S::Done__(data);
9962 Ok(ElementHandlerOutput::break_(event, allow_any))
9963 }
9964 DeserializerArtifact::Deserializer(deserializer) => {
9965 *self.state__ = S::SimpleType(values, None, Some(deserializer));
9966 Ok(ElementHandlerOutput::break_(event, allow_any))
9967 }
9968 }
9969 }
9970 fn handle_complex_type<'de>(
9971 &mut self,
9972 helper: &mut DeserializeHelper,
9973 mut values: Option<super::ComplexBaseType>,
9974 fallback: Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
9975 output: DeserializerOutput<'de, super::ComplexBaseType>,
9976 ) -> Result<ElementHandlerOutput<'de>, Error> {
9977 use ElementTypeContentDeserializerState as S;
9978 let DeserializerOutput {
9979 artifact,
9980 event,
9981 allow_any,
9982 } = output;
9983 if artifact.is_none() {
9984 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
9985 }
9986 if let Some(deserializer) = fallback {
9987 let data = deserializer.finish(helper)?;
9988 ElementTypeContentDeserializer::store_complex_type(&mut values, data)?;
9989 }
9990 match artifact {
9991 DeserializerArtifact::None => unreachable!(),
9992 DeserializerArtifact::Data(data) => {
9993 ElementTypeContentDeserializer::store_complex_type(&mut values, data)?;
9994 let data = ElementTypeContentDeserializer::finish_state(
9995 helper,
9996 S::ComplexType(values, None, None),
9997 )?;
9998 *self.state__ = S::Done__(data);
9999 Ok(ElementHandlerOutput::break_(event, allow_any))
10000 }
10001 DeserializerArtifact::Deserializer(deserializer) => {
10002 *self.state__ = S::ComplexType(values, None, Some(deserializer));
10003 Ok(ElementHandlerOutput::break_(event, allow_any))
10004 }
10005 }
10006 }
10007 fn handle_alternative<'de>(
10008 &mut self,
10009 helper: &mut DeserializeHelper,
10010 mut values: Option<super::AltType>,
10011 fallback: Option<<super::AltType as WithDeserializer>::Deserializer>,
10012 output: DeserializerOutput<'de, super::AltType>,
10013 ) -> Result<ElementHandlerOutput<'de>, Error> {
10014 use ElementTypeContentDeserializerState as S;
10015 let DeserializerOutput {
10016 artifact,
10017 event,
10018 allow_any,
10019 } = output;
10020 if artifact.is_none() {
10021 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
10022 }
10023 if let Some(deserializer) = fallback {
10024 let data = deserializer.finish(helper)?;
10025 ElementTypeContentDeserializer::store_alternative(&mut values, data)?;
10026 }
10027 match artifact {
10028 DeserializerArtifact::None => unreachable!(),
10029 DeserializerArtifact::Data(data) => {
10030 ElementTypeContentDeserializer::store_alternative(&mut values, data)?;
10031 let data = ElementTypeContentDeserializer::finish_state(
10032 helper,
10033 S::Alternative(values, None, None),
10034 )?;
10035 *self.state__ = S::Done__(data);
10036 Ok(ElementHandlerOutput::break_(event, allow_any))
10037 }
10038 DeserializerArtifact::Deserializer(deserializer) => {
10039 *self.state__ = S::Alternative(values, None, Some(deserializer));
10040 Ok(ElementHandlerOutput::break_(event, allow_any))
10041 }
10042 }
10043 }
10044 fn handle_unique<'de>(
10045 &mut self,
10046 helper: &mut DeserializeHelper,
10047 mut values: Option<super::KeybaseType>,
10048 fallback: Option<<super::KeybaseType as WithDeserializer>::Deserializer>,
10049 output: DeserializerOutput<'de, super::KeybaseType>,
10050 ) -> Result<ElementHandlerOutput<'de>, Error> {
10051 use ElementTypeContentDeserializerState as S;
10052 let DeserializerOutput {
10053 artifact,
10054 event,
10055 allow_any,
10056 } = output;
10057 if artifact.is_none() {
10058 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
10059 }
10060 if let Some(deserializer) = fallback {
10061 let data = deserializer.finish(helper)?;
10062 ElementTypeContentDeserializer::store_unique(&mut values, data)?;
10063 }
10064 match artifact {
10065 DeserializerArtifact::None => unreachable!(),
10066 DeserializerArtifact::Data(data) => {
10067 ElementTypeContentDeserializer::store_unique(&mut values, data)?;
10068 let data = ElementTypeContentDeserializer::finish_state(
10069 helper,
10070 S::Unique(values, None, None),
10071 )?;
10072 *self.state__ = S::Done__(data);
10073 Ok(ElementHandlerOutput::break_(event, allow_any))
10074 }
10075 DeserializerArtifact::Deserializer(deserializer) => {
10076 *self.state__ = S::Unique(values, None, Some(deserializer));
10077 Ok(ElementHandlerOutput::break_(event, allow_any))
10078 }
10079 }
10080 }
10081 fn handle_key<'de>(
10082 &mut self,
10083 helper: &mut DeserializeHelper,
10084 mut values: Option<super::KeybaseType>,
10085 fallback: Option<<super::KeybaseType as WithDeserializer>::Deserializer>,
10086 output: DeserializerOutput<'de, super::KeybaseType>,
10087 ) -> Result<ElementHandlerOutput<'de>, Error> {
10088 use ElementTypeContentDeserializerState as S;
10089 let DeserializerOutput {
10090 artifact,
10091 event,
10092 allow_any,
10093 } = output;
10094 if artifact.is_none() {
10095 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
10096 }
10097 if let Some(deserializer) = fallback {
10098 let data = deserializer.finish(helper)?;
10099 ElementTypeContentDeserializer::store_key(&mut values, data)?;
10100 }
10101 match artifact {
10102 DeserializerArtifact::None => unreachable!(),
10103 DeserializerArtifact::Data(data) => {
10104 ElementTypeContentDeserializer::store_key(&mut values, data)?;
10105 let data = ElementTypeContentDeserializer::finish_state(
10106 helper,
10107 S::Key(values, None, None),
10108 )?;
10109 *self.state__ = S::Done__(data);
10110 Ok(ElementHandlerOutput::break_(event, allow_any))
10111 }
10112 DeserializerArtifact::Deserializer(deserializer) => {
10113 *self.state__ = S::Key(values, None, Some(deserializer));
10114 Ok(ElementHandlerOutput::break_(event, allow_any))
10115 }
10116 }
10117 }
10118 fn handle_keyref<'de>(
10119 &mut self,
10120 helper: &mut DeserializeHelper,
10121 mut values: Option<super::Keyref>,
10122 fallback: Option<<super::Keyref as WithDeserializer>::Deserializer>,
10123 output: DeserializerOutput<'de, super::Keyref>,
10124 ) -> Result<ElementHandlerOutput<'de>, Error> {
10125 use ElementTypeContentDeserializerState as S;
10126 let DeserializerOutput {
10127 artifact,
10128 event,
10129 allow_any,
10130 } = output;
10131 if artifact.is_none() {
10132 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
10133 }
10134 if let Some(deserializer) = fallback {
10135 let data = deserializer.finish(helper)?;
10136 ElementTypeContentDeserializer::store_keyref(&mut values, data)?;
10137 }
10138 match artifact {
10139 DeserializerArtifact::None => unreachable!(),
10140 DeserializerArtifact::Data(data) => {
10141 ElementTypeContentDeserializer::store_keyref(&mut values, data)?;
10142 let data = ElementTypeContentDeserializer::finish_state(
10143 helper,
10144 S::Keyref(values, None, None),
10145 )?;
10146 *self.state__ = S::Done__(data);
10147 Ok(ElementHandlerOutput::break_(event, allow_any))
10148 }
10149 DeserializerArtifact::Deserializer(deserializer) => {
10150 *self.state__ = S::Keyref(values, None, Some(deserializer));
10151 Ok(ElementHandlerOutput::break_(event, allow_any))
10152 }
10153 }
10154 }
10155 }
10156 impl<'de> Deserializer<'de, super::ElementTypeContent> for Box<ElementTypeContentDeserializer> {
10157 fn init(
10158 helper: &mut DeserializeHelper,
10159 event: Event<'de>,
10160 ) -> DeserializerResult<'de, super::ElementTypeContent> {
10161 let deserializer = Box::new(ElementTypeContentDeserializer {
10162 state__: Box::new(ElementTypeContentDeserializerState::Init__),
10163 });
10164 let mut output = deserializer.next(helper, event)?;
10165 output.artifact = match output.artifact {
10166 DeserializerArtifact::Deserializer(x)
10167 if matches!(&*x.state__, ElementTypeContentDeserializerState::Init__) =>
10168 {
10169 DeserializerArtifact::None
10170 }
10171 artifact => artifact,
10172 };
10173 Ok(output)
10174 }
10175 fn next(
10176 mut self,
10177 helper: &mut DeserializeHelper,
10178 event: Event<'de>,
10179 ) -> DeserializerResult<'de, super::ElementTypeContent> {
10180 use ElementTypeContentDeserializerState as S;
10181 let mut event = event;
10182 let (event, allow_any) = loop {
10183 let state = replace(&mut *self.state__, S::Unknown__);
10184 event = match (state, event) {
10185 (S::Unknown__, _) => unreachable!(),
10186 (S::Annotation(values, fallback, Some(deserializer)), event) => {
10187 let output = deserializer.next(helper, event)?;
10188 match self.handle_annotation(helper, values, fallback, output)? {
10189 ElementHandlerOutput::Break { event, allow_any } => {
10190 break (event, allow_any)
10191 }
10192 ElementHandlerOutput::Continue { event, .. } => event,
10193 }
10194 }
10195 (S::SimpleType(values, fallback, Some(deserializer)), event) => {
10196 let output = deserializer.next(helper, event)?;
10197 match self.handle_simple_type(helper, values, fallback, output)? {
10198 ElementHandlerOutput::Break { event, allow_any } => {
10199 break (event, allow_any)
10200 }
10201 ElementHandlerOutput::Continue { event, .. } => event,
10202 }
10203 }
10204 (S::ComplexType(values, fallback, Some(deserializer)), event) => {
10205 let output = deserializer.next(helper, event)?;
10206 match self.handle_complex_type(helper, values, fallback, output)? {
10207 ElementHandlerOutput::Break { event, allow_any } => {
10208 break (event, allow_any)
10209 }
10210 ElementHandlerOutput::Continue { event, .. } => event,
10211 }
10212 }
10213 (S::Alternative(values, fallback, Some(deserializer)), event) => {
10214 let output = deserializer.next(helper, event)?;
10215 match self.handle_alternative(helper, values, fallback, output)? {
10216 ElementHandlerOutput::Break { event, allow_any } => {
10217 break (event, allow_any)
10218 }
10219 ElementHandlerOutput::Continue { event, .. } => event,
10220 }
10221 }
10222 (S::Unique(values, fallback, Some(deserializer)), event) => {
10223 let output = deserializer.next(helper, event)?;
10224 match self.handle_unique(helper, values, fallback, output)? {
10225 ElementHandlerOutput::Break { event, allow_any } => {
10226 break (event, allow_any)
10227 }
10228 ElementHandlerOutput::Continue { event, .. } => event,
10229 }
10230 }
10231 (S::Key(values, fallback, Some(deserializer)), event) => {
10232 let output = deserializer.next(helper, event)?;
10233 match self.handle_key(helper, values, fallback, output)? {
10234 ElementHandlerOutput::Break { event, allow_any } => {
10235 break (event, allow_any)
10236 }
10237 ElementHandlerOutput::Continue { event, .. } => event,
10238 }
10239 }
10240 (S::Keyref(values, fallback, Some(deserializer)), event) => {
10241 let output = deserializer.next(helper, event)?;
10242 match self.handle_keyref(helper, values, fallback, output)? {
10243 ElementHandlerOutput::Break { event, allow_any } => {
10244 break (event, allow_any)
10245 }
10246 ElementHandlerOutput::Continue { event, .. } => event,
10247 }
10248 }
10249 (state, event @ Event::End(_)) => {
10250 return Ok(DeserializerOutput {
10251 artifact: DeserializerArtifact::Data(
10252 ElementTypeContentDeserializer::finish_state(helper, state)?,
10253 ),
10254 event: DeserializerEvent::Continue(event),
10255 allow_any: false,
10256 });
10257 }
10258 (S::Init__, event) => match self.find_suitable(helper, event)? {
10259 ElementHandlerOutput::Break { event, allow_any } => {
10260 break (event, allow_any)
10261 }
10262 ElementHandlerOutput::Continue { event, .. } => event,
10263 },
10264 (
10265 S::Annotation(values, fallback, None),
10266 event @ (Event::Start(_) | Event::Empty(_)),
10267 ) => {
10268 let output = helper.init_start_tag_deserializer(
10269 event,
10270 Some(&super::NS_XS),
10271 b"annotation",
10272 false,
10273 )?;
10274 match self.handle_annotation(helper, values, fallback, output)? {
10275 ElementHandlerOutput::Break { event, allow_any } => {
10276 break (event, allow_any)
10277 }
10278 ElementHandlerOutput::Continue { event, .. } => event,
10279 }
10280 }
10281 (
10282 S::SimpleType(values, fallback, None),
10283 event @ (Event::Start(_) | Event::Empty(_)),
10284 ) => {
10285 let output = helper.init_start_tag_deserializer(
10286 event,
10287 Some(&super::NS_XS),
10288 b"simpleType",
10289 true,
10290 )?;
10291 match self.handle_simple_type(helper, values, fallback, output)? {
10292 ElementHandlerOutput::Break { event, allow_any } => {
10293 break (event, allow_any)
10294 }
10295 ElementHandlerOutput::Continue { event, .. } => event,
10296 }
10297 }
10298 (
10299 S::ComplexType(values, fallback, None),
10300 event @ (Event::Start(_) | Event::Empty(_)),
10301 ) => {
10302 let output = helper.init_start_tag_deserializer(
10303 event,
10304 Some(&super::NS_XS),
10305 b"complexType",
10306 true,
10307 )?;
10308 match self.handle_complex_type(helper, values, fallback, output)? {
10309 ElementHandlerOutput::Break { event, allow_any } => {
10310 break (event, allow_any)
10311 }
10312 ElementHandlerOutput::Continue { event, .. } => event,
10313 }
10314 }
10315 (
10316 S::Alternative(values, fallback, None),
10317 event @ (Event::Start(_) | Event::Empty(_)),
10318 ) => {
10319 let output = helper.init_start_tag_deserializer(
10320 event,
10321 Some(&super::NS_XS),
10322 b"alternative",
10323 true,
10324 )?;
10325 match self.handle_alternative(helper, values, fallback, output)? {
10326 ElementHandlerOutput::Break { event, allow_any } => {
10327 break (event, allow_any)
10328 }
10329 ElementHandlerOutput::Continue { event, .. } => event,
10330 }
10331 }
10332 (
10333 S::Unique(values, fallback, None),
10334 event @ (Event::Start(_) | Event::Empty(_)),
10335 ) => {
10336 let output = helper.init_start_tag_deserializer(
10337 event,
10338 Some(&super::NS_XS),
10339 b"unique",
10340 false,
10341 )?;
10342 match self.handle_unique(helper, values, fallback, output)? {
10343 ElementHandlerOutput::Break { event, allow_any } => {
10344 break (event, allow_any)
10345 }
10346 ElementHandlerOutput::Continue { event, .. } => event,
10347 }
10348 }
10349 (
10350 S::Key(values, fallback, None),
10351 event @ (Event::Start(_) | Event::Empty(_)),
10352 ) => {
10353 let output = helper.init_start_tag_deserializer(
10354 event,
10355 Some(&super::NS_XS),
10356 b"key",
10357 false,
10358 )?;
10359 match self.handle_key(helper, values, fallback, output)? {
10360 ElementHandlerOutput::Break { event, allow_any } => {
10361 break (event, allow_any)
10362 }
10363 ElementHandlerOutput::Continue { event, .. } => event,
10364 }
10365 }
10366 (
10367 S::Keyref(values, fallback, None),
10368 event @ (Event::Start(_) | Event::Empty(_)),
10369 ) => {
10370 let output = helper.init_start_tag_deserializer(
10371 event,
10372 Some(&super::NS_XS),
10373 b"keyref",
10374 false,
10375 )?;
10376 match self.handle_keyref(helper, values, fallback, output)? {
10377 ElementHandlerOutput::Break { event, allow_any } => {
10378 break (event, allow_any)
10379 }
10380 ElementHandlerOutput::Continue { event, .. } => event,
10381 }
10382 }
10383 (state @ S::Done__(_), event) => {
10384 *self.state__ = state;
10385 break (DeserializerEvent::Continue(event), false);
10386 }
10387 (state, event) => {
10388 *self.state__ = state;
10389 break (DeserializerEvent::Continue(event), false);
10390 }
10391 }
10392 };
10393 let artifact = if matches!(&*self.state__, S::Done__(_)) {
10394 DeserializerArtifact::Data(self.finish(helper)?)
10395 } else {
10396 DeserializerArtifact::Deserializer(self)
10397 };
10398 Ok(DeserializerOutput {
10399 artifact,
10400 event,
10401 allow_any,
10402 })
10403 }
10404 fn finish(
10405 self,
10406 helper: &mut DeserializeHelper,
10407 ) -> Result<super::ElementTypeContent, Error> {
10408 ElementTypeContentDeserializer::finish_state(helper, *self.state__)
10409 }
10410 }
10411 #[derive(Debug)]
10412 pub struct AttributeInnerTypeDeserializer {
10413 id: Option<String>,
10414 name: Option<String>,
10415 ref_: Option<QName>,
10416 type_: Option<QName>,
10417 use_: super::AttributeUseType,
10418 default: Option<String>,
10419 fixed: Option<String>,
10420 form: Option<super::FormChoiceType>,
10421 target_namespace: Option<String>,
10422 inheritable: Option<bool>,
10423 annotation: Option<super::Annotation>,
10424 simple_type: Option<super::SimpleBaseType>,
10425 state__: Box<AttributeInnerTypeDeserializerState>,
10426 }
10427 #[derive(Debug)]
10428 enum AttributeInnerTypeDeserializerState {
10429 Init__,
10430 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
10431 SimpleType(Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>),
10432 Done__,
10433 Unknown__,
10434 }
10435 impl AttributeInnerTypeDeserializer {
10436 fn from_bytes_start(
10437 helper: &mut DeserializeHelper,
10438 bytes_start: &BytesStart<'_>,
10439 ) -> Result<Box<Self>, Error> {
10440 let mut id: Option<String> = None;
10441 let mut name: Option<String> = None;
10442 let mut ref_: Option<QName> = None;
10443 let mut type_: Option<QName> = None;
10444 let mut use_: Option<super::AttributeUseType> = None;
10445 let mut default: Option<String> = None;
10446 let mut fixed: Option<String> = None;
10447 let mut form: Option<super::FormChoiceType> = None;
10448 let mut target_namespace: Option<String> = None;
10449 let mut inheritable: Option<bool> = None;
10450 for attrib in helper.filter_xmlns_attributes(bytes_start) {
10451 let attrib = attrib?;
10452 if matches!(
10453 helper.resolve_local_name(attrib.key, &super::NS_XS),
10454 Some(b"id")
10455 ) {
10456 helper.read_attrib(&mut id, b"id", &attrib.value)?;
10457 } else if matches!(
10458 helper.resolve_local_name(attrib.key, &super::NS_XS),
10459 Some(b"name")
10460 ) {
10461 helper.read_attrib(&mut name, b"name", &attrib.value)?;
10462 } else if matches!(
10463 helper.resolve_local_name(attrib.key, &super::NS_XS),
10464 Some(b"ref")
10465 ) {
10466 helper.read_attrib(&mut ref_, b"ref", &attrib.value)?;
10467 } else if matches!(
10468 helper.resolve_local_name(attrib.key, &super::NS_XS),
10469 Some(b"type")
10470 ) {
10471 helper.read_attrib(&mut type_, b"type", &attrib.value)?;
10472 } else if matches!(
10473 helper.resolve_local_name(attrib.key, &super::NS_XS),
10474 Some(b"use")
10475 ) {
10476 helper.read_attrib(&mut use_, b"use", &attrib.value)?;
10477 } else if matches!(
10478 helper.resolve_local_name(attrib.key, &super::NS_XS),
10479 Some(b"default")
10480 ) {
10481 helper.read_attrib(&mut default, b"default", &attrib.value)?;
10482 } else if matches!(
10483 helper.resolve_local_name(attrib.key, &super::NS_XS),
10484 Some(b"fixed")
10485 ) {
10486 helper.read_attrib(&mut fixed, b"fixed", &attrib.value)?;
10487 } else if matches!(
10488 helper.resolve_local_name(attrib.key, &super::NS_XS),
10489 Some(b"form")
10490 ) {
10491 helper.read_attrib(&mut form, b"form", &attrib.value)?;
10492 } else if matches!(
10493 helper.resolve_local_name(attrib.key, &super::NS_XS),
10494 Some(b"targetNamespace")
10495 ) {
10496 helper.read_attrib(&mut target_namespace, b"targetNamespace", &attrib.value)?;
10497 } else if matches!(
10498 helper.resolve_local_name(attrib.key, &super::NS_XS),
10499 Some(b"inheritable")
10500 ) {
10501 helper.read_attrib(&mut inheritable, b"inheritable", &attrib.value)?;
10502 }
10503 }
10504 Ok(Box::new(Self {
10505 id: id,
10506 name: name,
10507 ref_: ref_,
10508 type_: type_,
10509 use_: use_.unwrap_or_else(super::AttributeInnerType::default_use_),
10510 default: default,
10511 fixed: fixed,
10512 form: form,
10513 target_namespace: target_namespace,
10514 inheritable: inheritable,
10515 annotation: None,
10516 simple_type: None,
10517 state__: Box::new(AttributeInnerTypeDeserializerState::Init__),
10518 }))
10519 }
10520 fn finish_state(
10521 &mut self,
10522 helper: &mut DeserializeHelper,
10523 state: AttributeInnerTypeDeserializerState,
10524 ) -> Result<(), Error> {
10525 use AttributeInnerTypeDeserializerState as S;
10526 match state {
10527 S::Annotation(Some(deserializer)) => {
10528 self.store_annotation(deserializer.finish(helper)?)?
10529 }
10530 S::SimpleType(Some(deserializer)) => {
10531 self.store_simple_type(deserializer.finish(helper)?)?
10532 }
10533 _ => (),
10534 }
10535 Ok(())
10536 }
10537 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
10538 if self.annotation.is_some() {
10539 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10540 b"annotation",
10541 )))?;
10542 }
10543 self.annotation = Some(value);
10544 Ok(())
10545 }
10546 fn store_simple_type(&mut self, value: super::SimpleBaseType) -> Result<(), Error> {
10547 if self.simple_type.is_some() {
10548 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10549 b"simpleType",
10550 )))?;
10551 }
10552 self.simple_type = Some(value);
10553 Ok(())
10554 }
10555 fn handle_annotation<'de>(
10556 &mut self,
10557 helper: &mut DeserializeHelper,
10558 output: DeserializerOutput<'de, super::Annotation>,
10559 fallback: &mut Option<AttributeInnerTypeDeserializerState>,
10560 ) -> Result<ElementHandlerOutput<'de>, Error> {
10561 use AttributeInnerTypeDeserializerState as S;
10562 let DeserializerOutput {
10563 artifact,
10564 event,
10565 allow_any,
10566 } = output;
10567 if artifact.is_none() {
10568 fallback.get_or_insert(S::Annotation(None));
10569 *self.state__ = S::SimpleType(None);
10570 return Ok(ElementHandlerOutput::from_event(event, allow_any));
10571 }
10572 if let Some(fallback) = fallback.take() {
10573 self.finish_state(helper, fallback)?;
10574 }
10575 match artifact {
10576 DeserializerArtifact::None => unreachable!(),
10577 DeserializerArtifact::Data(data) => {
10578 self.store_annotation(data)?;
10579 *self.state__ = S::SimpleType(None);
10580 Ok(ElementHandlerOutput::from_event(event, allow_any))
10581 }
10582 DeserializerArtifact::Deserializer(deserializer) => {
10583 fallback.get_or_insert(S::Annotation(Some(deserializer)));
10584 *self.state__ = S::SimpleType(None);
10585 Ok(ElementHandlerOutput::from_event(event, allow_any))
10586 }
10587 }
10588 }
10589 fn handle_simple_type<'de>(
10590 &mut self,
10591 helper: &mut DeserializeHelper,
10592 output: DeserializerOutput<'de, super::SimpleBaseType>,
10593 fallback: &mut Option<AttributeInnerTypeDeserializerState>,
10594 ) -> Result<ElementHandlerOutput<'de>, Error> {
10595 use AttributeInnerTypeDeserializerState as S;
10596 let DeserializerOutput {
10597 artifact,
10598 event,
10599 allow_any,
10600 } = output;
10601 if artifact.is_none() {
10602 fallback.get_or_insert(S::SimpleType(None));
10603 *self.state__ = S::Done__;
10604 return Ok(ElementHandlerOutput::from_event(event, allow_any));
10605 }
10606 if let Some(fallback) = fallback.take() {
10607 self.finish_state(helper, fallback)?;
10608 }
10609 match artifact {
10610 DeserializerArtifact::None => unreachable!(),
10611 DeserializerArtifact::Data(data) => {
10612 self.store_simple_type(data)?;
10613 *self.state__ = S::Done__;
10614 Ok(ElementHandlerOutput::from_event(event, allow_any))
10615 }
10616 DeserializerArtifact::Deserializer(deserializer) => {
10617 fallback.get_or_insert(S::SimpleType(Some(deserializer)));
10618 *self.state__ = S::Done__;
10619 Ok(ElementHandlerOutput::from_event(event, allow_any))
10620 }
10621 }
10622 }
10623 }
10624 impl<'de> Deserializer<'de, super::AttributeInnerType> for Box<AttributeInnerTypeDeserializer> {
10625 fn init(
10626 helper: &mut DeserializeHelper,
10627 event: Event<'de>,
10628 ) -> DeserializerResult<'de, super::AttributeInnerType> {
10629 helper.init_deserializer_from_start_event(
10630 event,
10631 AttributeInnerTypeDeserializer::from_bytes_start,
10632 )
10633 }
10634 fn next(
10635 mut self,
10636 helper: &mut DeserializeHelper,
10637 event: Event<'de>,
10638 ) -> DeserializerResult<'de, super::AttributeInnerType> {
10639 use AttributeInnerTypeDeserializerState as S;
10640 let mut event = event;
10641 let mut fallback = None;
10642 let mut allow_any_element = false;
10643 let (event, allow_any) = loop {
10644 let state = replace(&mut *self.state__, S::Unknown__);
10645 event = match (state, event) {
10646 (S::Unknown__, _) => unreachable!(),
10647 (S::Annotation(Some(deserializer)), event) => {
10648 let output = deserializer.next(helper, event)?;
10649 match self.handle_annotation(helper, output, &mut fallback)? {
10650 ElementHandlerOutput::Continue { event, allow_any } => {
10651 allow_any_element = allow_any_element || allow_any;
10652 event
10653 }
10654 ElementHandlerOutput::Break { event, allow_any } => {
10655 break (event, allow_any)
10656 }
10657 }
10658 }
10659 (S::SimpleType(Some(deserializer)), event) => {
10660 let output = deserializer.next(helper, event)?;
10661 match self.handle_simple_type(helper, output, &mut fallback)? {
10662 ElementHandlerOutput::Continue { event, allow_any } => {
10663 allow_any_element = allow_any_element || allow_any;
10664 event
10665 }
10666 ElementHandlerOutput::Break { event, allow_any } => {
10667 break (event, allow_any)
10668 }
10669 }
10670 }
10671 (_, Event::End(_)) => {
10672 if let Some(fallback) = fallback.take() {
10673 self.finish_state(helper, fallback)?;
10674 }
10675 return Ok(DeserializerOutput {
10676 artifact: DeserializerArtifact::Data(self.finish(helper)?),
10677 event: DeserializerEvent::None,
10678 allow_any: false,
10679 });
10680 }
10681 (S::Init__, event) => {
10682 fallback.get_or_insert(S::Init__);
10683 *self.state__ = S::Annotation(None);
10684 event
10685 }
10686 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
10687 let output = helper.init_start_tag_deserializer(
10688 event,
10689 Some(&super::NS_XS),
10690 b"annotation",
10691 false,
10692 )?;
10693 match self.handle_annotation(helper, output, &mut fallback)? {
10694 ElementHandlerOutput::Continue { event, allow_any } => {
10695 allow_any_element = allow_any_element || allow_any;
10696 event
10697 }
10698 ElementHandlerOutput::Break { event, allow_any } => {
10699 break (event, allow_any)
10700 }
10701 }
10702 }
10703 (S::SimpleType(None), event @ (Event::Start(_) | Event::Empty(_))) => {
10704 let output = helper.init_start_tag_deserializer(
10705 event,
10706 Some(&super::NS_XS),
10707 b"simpleType",
10708 true,
10709 )?;
10710 match self.handle_simple_type(helper, output, &mut fallback)? {
10711 ElementHandlerOutput::Continue { event, allow_any } => {
10712 allow_any_element = allow_any_element || allow_any;
10713 event
10714 }
10715 ElementHandlerOutput::Break { event, allow_any } => {
10716 break (event, allow_any)
10717 }
10718 }
10719 }
10720 (S::Done__, event) => {
10721 *self.state__ = S::Done__;
10722 break (DeserializerEvent::Continue(event), allow_any_element);
10723 }
10724 (state, event) => {
10725 *self.state__ = state;
10726 break (DeserializerEvent::Break(event), false);
10727 }
10728 }
10729 };
10730 if let Some(fallback) = fallback {
10731 *self.state__ = fallback;
10732 }
10733 Ok(DeserializerOutput {
10734 artifact: DeserializerArtifact::Deserializer(self),
10735 event,
10736 allow_any,
10737 })
10738 }
10739 fn finish(
10740 mut self,
10741 helper: &mut DeserializeHelper,
10742 ) -> Result<super::AttributeInnerType, Error> {
10743 let state = replace(
10744 &mut *self.state__,
10745 AttributeInnerTypeDeserializerState::Unknown__,
10746 );
10747 self.finish_state(helper, state)?;
10748 Ok(super::AttributeInnerType {
10749 id: self.id,
10750 name: self.name,
10751 ref_: self.ref_,
10752 type_: self.type_,
10753 use_: self.use_,
10754 default: self.default,
10755 fixed: self.fixed,
10756 form: self.form,
10757 target_namespace: self.target_namespace,
10758 inheritable: self.inheritable,
10759 annotation: self.annotation,
10760 simple_type: self.simple_type,
10761 })
10762 }
10763 }
10764 #[derive(Debug)]
10765 pub struct NotationDeserializer {
10766 id: Option<String>,
10767 name: String,
10768 public: Option<String>,
10769 system: Option<String>,
10770 annotation: Option<super::Annotation>,
10771 state__: Box<NotationDeserializerState>,
10772 }
10773 #[derive(Debug)]
10774 enum NotationDeserializerState {
10775 Init__,
10776 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
10777 Done__,
10778 Unknown__,
10779 }
10780 impl NotationDeserializer {
10781 fn from_bytes_start(
10782 helper: &mut DeserializeHelper,
10783 bytes_start: &BytesStart<'_>,
10784 ) -> Result<Box<Self>, Error> {
10785 let mut id: Option<String> = None;
10786 let mut name: Option<String> = None;
10787 let mut public: Option<String> = None;
10788 let mut system: Option<String> = None;
10789 for attrib in helper.filter_xmlns_attributes(bytes_start) {
10790 let attrib = attrib?;
10791 if matches!(
10792 helper.resolve_local_name(attrib.key, &super::NS_XS),
10793 Some(b"id")
10794 ) {
10795 helper.read_attrib(&mut id, b"id", &attrib.value)?;
10796 } else if matches!(
10797 helper.resolve_local_name(attrib.key, &super::NS_XS),
10798 Some(b"name")
10799 ) {
10800 helper.read_attrib(&mut name, b"name", &attrib.value)?;
10801 } else if matches!(
10802 helper.resolve_local_name(attrib.key, &super::NS_XS),
10803 Some(b"public")
10804 ) {
10805 helper.read_attrib(&mut public, b"public", &attrib.value)?;
10806 } else if matches!(
10807 helper.resolve_local_name(attrib.key, &super::NS_XS),
10808 Some(b"system")
10809 ) {
10810 helper.read_attrib(&mut system, b"system", &attrib.value)?;
10811 }
10812 }
10813 Ok(Box::new(Self {
10814 id: id,
10815 name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?,
10816 public: public,
10817 system: system,
10818 annotation: None,
10819 state__: Box::new(NotationDeserializerState::Init__),
10820 }))
10821 }
10822 fn finish_state(
10823 &mut self,
10824 helper: &mut DeserializeHelper,
10825 state: NotationDeserializerState,
10826 ) -> Result<(), Error> {
10827 use NotationDeserializerState as S;
10828 match state {
10829 S::Annotation(Some(deserializer)) => {
10830 self.store_annotation(deserializer.finish(helper)?)?
10831 }
10832 _ => (),
10833 }
10834 Ok(())
10835 }
10836 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
10837 if self.annotation.is_some() {
10838 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
10839 b"annotation",
10840 )))?;
10841 }
10842 self.annotation = Some(value);
10843 Ok(())
10844 }
10845 fn handle_annotation<'de>(
10846 &mut self,
10847 helper: &mut DeserializeHelper,
10848 output: DeserializerOutput<'de, super::Annotation>,
10849 fallback: &mut Option<NotationDeserializerState>,
10850 ) -> Result<ElementHandlerOutput<'de>, Error> {
10851 use NotationDeserializerState as S;
10852 let DeserializerOutput {
10853 artifact,
10854 event,
10855 allow_any,
10856 } = output;
10857 if artifact.is_none() {
10858 fallback.get_or_insert(S::Annotation(None));
10859 *self.state__ = S::Done__;
10860 return Ok(ElementHandlerOutput::from_event(event, allow_any));
10861 }
10862 if let Some(fallback) = fallback.take() {
10863 self.finish_state(helper, fallback)?;
10864 }
10865 match artifact {
10866 DeserializerArtifact::None => unreachable!(),
10867 DeserializerArtifact::Data(data) => {
10868 self.store_annotation(data)?;
10869 *self.state__ = S::Done__;
10870 Ok(ElementHandlerOutput::from_event(event, allow_any))
10871 }
10872 DeserializerArtifact::Deserializer(deserializer) => {
10873 fallback.get_or_insert(S::Annotation(Some(deserializer)));
10874 *self.state__ = S::Done__;
10875 Ok(ElementHandlerOutput::from_event(event, allow_any))
10876 }
10877 }
10878 }
10879 }
10880 impl<'de> Deserializer<'de, super::Notation> for Box<NotationDeserializer> {
10881 fn init(
10882 helper: &mut DeserializeHelper,
10883 event: Event<'de>,
10884 ) -> DeserializerResult<'de, super::Notation> {
10885 helper.init_deserializer_from_start_event(event, NotationDeserializer::from_bytes_start)
10886 }
10887 fn next(
10888 mut self,
10889 helper: &mut DeserializeHelper,
10890 event: Event<'de>,
10891 ) -> DeserializerResult<'de, super::Notation> {
10892 use NotationDeserializerState as S;
10893 let mut event = event;
10894 let mut fallback = None;
10895 let mut allow_any_element = false;
10896 let (event, allow_any) = loop {
10897 let state = replace(&mut *self.state__, S::Unknown__);
10898 event = match (state, event) {
10899 (S::Unknown__, _) => unreachable!(),
10900 (S::Annotation(Some(deserializer)), event) => {
10901 let output = deserializer.next(helper, event)?;
10902 match self.handle_annotation(helper, output, &mut fallback)? {
10903 ElementHandlerOutput::Continue { event, allow_any } => {
10904 allow_any_element = allow_any_element || allow_any;
10905 event
10906 }
10907 ElementHandlerOutput::Break { event, allow_any } => {
10908 break (event, allow_any)
10909 }
10910 }
10911 }
10912 (_, Event::End(_)) => {
10913 if let Some(fallback) = fallback.take() {
10914 self.finish_state(helper, fallback)?;
10915 }
10916 return Ok(DeserializerOutput {
10917 artifact: DeserializerArtifact::Data(self.finish(helper)?),
10918 event: DeserializerEvent::None,
10919 allow_any: false,
10920 });
10921 }
10922 (S::Init__, event) => {
10923 fallback.get_or_insert(S::Init__);
10924 *self.state__ = S::Annotation(None);
10925 event
10926 }
10927 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
10928 let output = helper.init_start_tag_deserializer(
10929 event,
10930 Some(&super::NS_XS),
10931 b"annotation",
10932 false,
10933 )?;
10934 match self.handle_annotation(helper, output, &mut fallback)? {
10935 ElementHandlerOutput::Continue { event, allow_any } => {
10936 allow_any_element = allow_any_element || allow_any;
10937 event
10938 }
10939 ElementHandlerOutput::Break { event, allow_any } => {
10940 break (event, allow_any)
10941 }
10942 }
10943 }
10944 (S::Done__, event) => {
10945 *self.state__ = S::Done__;
10946 break (DeserializerEvent::Continue(event), allow_any_element);
10947 }
10948 (state, event) => {
10949 *self.state__ = state;
10950 break (DeserializerEvent::Break(event), false);
10951 }
10952 }
10953 };
10954 if let Some(fallback) = fallback {
10955 *self.state__ = fallback;
10956 }
10957 Ok(DeserializerOutput {
10958 artifact: DeserializerArtifact::Deserializer(self),
10959 event,
10960 allow_any,
10961 })
10962 }
10963 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Notation, Error> {
10964 let state = replace(&mut *self.state__, NotationDeserializerState::Unknown__);
10965 self.finish_state(helper, state)?;
10966 Ok(super::Notation {
10967 id: self.id,
10968 name: self.name,
10969 public: self.public,
10970 system: self.system,
10971 annotation: self.annotation,
10972 })
10973 }
10974 }
10975 #[derive(Debug)]
10976 pub struct WildcardTypeDeserializer {
10977 id: Option<String>,
10978 namespace: Option<super::NamespaceListType>,
10979 not_namespace: Option<super::NotNamespaceType>,
10980 process_contents: super::ProcessContentsType,
10981 annotation: Option<super::Annotation>,
10982 state__: Box<WildcardTypeDeserializerState>,
10983 }
10984 #[derive(Debug)]
10985 enum WildcardTypeDeserializerState {
10986 Init__,
10987 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
10988 Done__,
10989 Unknown__,
10990 }
10991 impl WildcardTypeDeserializer {
10992 fn from_bytes_start(
10993 helper: &mut DeserializeHelper,
10994 bytes_start: &BytesStart<'_>,
10995 ) -> Result<Box<Self>, Error> {
10996 let mut id: Option<String> = None;
10997 let mut namespace: Option<super::NamespaceListType> = None;
10998 let mut not_namespace: Option<super::NotNamespaceType> = None;
10999 let mut process_contents: Option<super::ProcessContentsType> = None;
11000 for attrib in helper.filter_xmlns_attributes(bytes_start) {
11001 let attrib = attrib?;
11002 if matches!(
11003 helper.resolve_local_name(attrib.key, &super::NS_XS),
11004 Some(b"id")
11005 ) {
11006 helper.read_attrib(&mut id, b"id", &attrib.value)?;
11007 } else if matches!(
11008 helper.resolve_local_name(attrib.key, &super::NS_XS),
11009 Some(b"namespace")
11010 ) {
11011 helper.read_attrib(&mut namespace, b"namespace", &attrib.value)?;
11012 } else if matches!(
11013 helper.resolve_local_name(attrib.key, &super::NS_XS),
11014 Some(b"notNamespace")
11015 ) {
11016 helper.read_attrib(&mut not_namespace, b"notNamespace", &attrib.value)?;
11017 } else if matches!(
11018 helper.resolve_local_name(attrib.key, &super::NS_XS),
11019 Some(b"processContents")
11020 ) {
11021 helper.read_attrib(&mut process_contents, b"processContents", &attrib.value)?;
11022 }
11023 }
11024 Ok(Box::new(Self {
11025 id: id,
11026 namespace: namespace,
11027 not_namespace: not_namespace,
11028 process_contents: process_contents
11029 .unwrap_or_else(super::WildcardType::default_process_contents),
11030 annotation: None,
11031 state__: Box::new(WildcardTypeDeserializerState::Init__),
11032 }))
11033 }
11034 fn finish_state(
11035 &mut self,
11036 helper: &mut DeserializeHelper,
11037 state: WildcardTypeDeserializerState,
11038 ) -> Result<(), Error> {
11039 use WildcardTypeDeserializerState as S;
11040 match state {
11041 S::Annotation(Some(deserializer)) => {
11042 self.store_annotation(deserializer.finish(helper)?)?
11043 }
11044 _ => (),
11045 }
11046 Ok(())
11047 }
11048 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
11049 if self.annotation.is_some() {
11050 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11051 b"annotation",
11052 )))?;
11053 }
11054 self.annotation = Some(value);
11055 Ok(())
11056 }
11057 fn handle_annotation<'de>(
11058 &mut self,
11059 helper: &mut DeserializeHelper,
11060 output: DeserializerOutput<'de, super::Annotation>,
11061 fallback: &mut Option<WildcardTypeDeserializerState>,
11062 ) -> Result<ElementHandlerOutput<'de>, Error> {
11063 use WildcardTypeDeserializerState as S;
11064 let DeserializerOutput {
11065 artifact,
11066 event,
11067 allow_any,
11068 } = output;
11069 if artifact.is_none() {
11070 fallback.get_or_insert(S::Annotation(None));
11071 *self.state__ = S::Done__;
11072 return Ok(ElementHandlerOutput::from_event(event, allow_any));
11073 }
11074 if let Some(fallback) = fallback.take() {
11075 self.finish_state(helper, fallback)?;
11076 }
11077 match artifact {
11078 DeserializerArtifact::None => unreachable!(),
11079 DeserializerArtifact::Data(data) => {
11080 self.store_annotation(data)?;
11081 *self.state__ = S::Done__;
11082 Ok(ElementHandlerOutput::from_event(event, allow_any))
11083 }
11084 DeserializerArtifact::Deserializer(deserializer) => {
11085 fallback.get_or_insert(S::Annotation(Some(deserializer)));
11086 *self.state__ = S::Done__;
11087 Ok(ElementHandlerOutput::from_event(event, allow_any))
11088 }
11089 }
11090 }
11091 }
11092 impl<'de> Deserializer<'de, super::WildcardType> for Box<WildcardTypeDeserializer> {
11093 fn init(
11094 helper: &mut DeserializeHelper,
11095 event: Event<'de>,
11096 ) -> DeserializerResult<'de, super::WildcardType> {
11097 helper.init_deserializer_from_start_event(
11098 event,
11099 WildcardTypeDeserializer::from_bytes_start,
11100 )
11101 }
11102 fn next(
11103 mut self,
11104 helper: &mut DeserializeHelper,
11105 event: Event<'de>,
11106 ) -> DeserializerResult<'de, super::WildcardType> {
11107 use WildcardTypeDeserializerState as S;
11108 let mut event = event;
11109 let mut fallback = None;
11110 let mut allow_any_element = false;
11111 let (event, allow_any) = loop {
11112 let state = replace(&mut *self.state__, S::Unknown__);
11113 event = match (state, event) {
11114 (S::Unknown__, _) => unreachable!(),
11115 (S::Annotation(Some(deserializer)), event) => {
11116 let output = deserializer.next(helper, event)?;
11117 match self.handle_annotation(helper, output, &mut fallback)? {
11118 ElementHandlerOutput::Continue { event, allow_any } => {
11119 allow_any_element = allow_any_element || allow_any;
11120 event
11121 }
11122 ElementHandlerOutput::Break { event, allow_any } => {
11123 break (event, allow_any)
11124 }
11125 }
11126 }
11127 (_, Event::End(_)) => {
11128 if let Some(fallback) = fallback.take() {
11129 self.finish_state(helper, fallback)?;
11130 }
11131 return Ok(DeserializerOutput {
11132 artifact: DeserializerArtifact::Data(self.finish(helper)?),
11133 event: DeserializerEvent::None,
11134 allow_any: false,
11135 });
11136 }
11137 (S::Init__, event) => {
11138 fallback.get_or_insert(S::Init__);
11139 *self.state__ = S::Annotation(None);
11140 event
11141 }
11142 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
11143 let output = helper.init_start_tag_deserializer(
11144 event,
11145 Some(&super::NS_XS),
11146 b"annotation",
11147 false,
11148 )?;
11149 match self.handle_annotation(helper, output, &mut fallback)? {
11150 ElementHandlerOutput::Continue { event, allow_any } => {
11151 allow_any_element = allow_any_element || allow_any;
11152 event
11153 }
11154 ElementHandlerOutput::Break { event, allow_any } => {
11155 break (event, allow_any)
11156 }
11157 }
11158 }
11159 (S::Done__, event) => {
11160 *self.state__ = S::Done__;
11161 break (DeserializerEvent::Continue(event), allow_any_element);
11162 }
11163 (state, event) => {
11164 *self.state__ = state;
11165 break (DeserializerEvent::Break(event), false);
11166 }
11167 }
11168 };
11169 if let Some(fallback) = fallback {
11170 *self.state__ = fallback;
11171 }
11172 Ok(DeserializerOutput {
11173 artifact: DeserializerArtifact::Deserializer(self),
11174 event,
11175 allow_any,
11176 })
11177 }
11178 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::WildcardType, Error> {
11179 let state = replace(&mut *self.state__, WildcardTypeDeserializerState::Unknown__);
11180 self.finish_state(helper, state)?;
11181 Ok(super::WildcardType {
11182 id: self.id,
11183 namespace: self.namespace,
11184 not_namespace: self.not_namespace,
11185 process_contents: self.process_contents,
11186 annotation: self.annotation,
11187 })
11188 }
11189 }
11190 #[derive(Debug)]
11191 pub struct RestrictionDeserializer {
11192 id: Option<String>,
11193 base: Option<QName>,
11194 content: Vec<super::RestrictionContent>,
11195 state__: Box<RestrictionDeserializerState>,
11196 }
11197 #[derive(Debug)]
11198 enum RestrictionDeserializerState {
11199 Init__,
11200 Next__,
11201 Content__(<super::RestrictionContent as WithDeserializer>::Deserializer),
11202 Unknown__,
11203 }
11204 impl RestrictionDeserializer {
11205 fn from_bytes_start(
11206 helper: &mut DeserializeHelper,
11207 bytes_start: &BytesStart<'_>,
11208 ) -> Result<Box<Self>, Error> {
11209 let mut id: Option<String> = None;
11210 let mut base: Option<QName> = None;
11211 for attrib in helper.filter_xmlns_attributes(bytes_start) {
11212 let attrib = attrib?;
11213 if matches!(
11214 helper.resolve_local_name(attrib.key, &super::NS_XS),
11215 Some(b"id")
11216 ) {
11217 helper.read_attrib(&mut id, b"id", &attrib.value)?;
11218 } else if matches!(
11219 helper.resolve_local_name(attrib.key, &super::NS_XS),
11220 Some(b"base")
11221 ) {
11222 helper.read_attrib(&mut base, b"base", &attrib.value)?;
11223 }
11224 }
11225 Ok(Box::new(Self {
11226 id: id,
11227 base: base,
11228 content: Vec::new(),
11229 state__: Box::new(RestrictionDeserializerState::Init__),
11230 }))
11231 }
11232 fn finish_state(
11233 &mut self,
11234 helper: &mut DeserializeHelper,
11235 state: RestrictionDeserializerState,
11236 ) -> Result<(), Error> {
11237 if let RestrictionDeserializerState::Content__(deserializer) = state {
11238 self.store_content(deserializer.finish(helper)?)?;
11239 }
11240 Ok(())
11241 }
11242 fn store_content(&mut self, value: super::RestrictionContent) -> Result<(), Error> {
11243 self.content.push(value);
11244 Ok(())
11245 }
11246 fn handle_content<'de>(
11247 &mut self,
11248 helper: &mut DeserializeHelper,
11249 output: DeserializerOutput<'de, super::RestrictionContent>,
11250 fallback: &mut Option<RestrictionDeserializerState>,
11251 ) -> Result<ElementHandlerOutput<'de>, Error> {
11252 use RestrictionDeserializerState as S;
11253 let DeserializerOutput {
11254 artifact,
11255 event,
11256 allow_any,
11257 } = output;
11258 if artifact.is_none() {
11259 *self.state__ = fallback.take().unwrap_or(S::Next__);
11260 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
11261 }
11262 if let Some(fallback) = fallback.take() {
11263 self.finish_state(helper, fallback)?;
11264 }
11265 match artifact {
11266 DeserializerArtifact::None => unreachable!(),
11267 DeserializerArtifact::Data(data) => {
11268 self.store_content(data)?;
11269 *self.state__ = S::Next__;
11270 Ok(ElementHandlerOutput::from_event(event, allow_any))
11271 }
11272 DeserializerArtifact::Deserializer(deserializer) => {
11273 *fallback = Some(S::Content__(deserializer));
11274 *self.state__ = S::Next__;
11275 Ok(ElementHandlerOutput::from_event(event, allow_any))
11276 }
11277 }
11278 }
11279 }
11280 impl<'de> Deserializer<'de, super::Restriction> for Box<RestrictionDeserializer> {
11281 fn init(
11282 helper: &mut DeserializeHelper,
11283 event: Event<'de>,
11284 ) -> DeserializerResult<'de, super::Restriction> {
11285 helper.init_deserializer_from_start_event(
11286 event,
11287 RestrictionDeserializer::from_bytes_start,
11288 )
11289 }
11290 fn next(
11291 mut self,
11292 helper: &mut DeserializeHelper,
11293 event: Event<'de>,
11294 ) -> DeserializerResult<'de, super::Restriction> {
11295 use RestrictionDeserializerState as S;
11296 let mut event = event;
11297 let mut fallback = None;
11298 let (event, allow_any) = loop {
11299 let state = replace(&mut *self.state__, S::Unknown__);
11300 event = match (state, event) {
11301 (S::Unknown__, _) => unreachable!(),
11302 (S::Content__(deserializer), event) => {
11303 let output = deserializer.next(helper, event)?;
11304 match self.handle_content(helper, output, &mut fallback)? {
11305 ElementHandlerOutput::Break { event, allow_any } => {
11306 break (event, allow_any)
11307 }
11308 ElementHandlerOutput::Continue { event, .. } => event,
11309 }
11310 }
11311 (_, Event::End(_)) => {
11312 return Ok(DeserializerOutput {
11313 artifact: DeserializerArtifact::Data(self.finish(helper)?),
11314 event: DeserializerEvent::None,
11315 allow_any: false,
11316 });
11317 }
11318 (state @ (S::Init__ | S::Next__), event) => {
11319 fallback.get_or_insert(state);
11320 let output =
11321 <super::RestrictionContent as WithDeserializer>::init(helper, event)?;
11322 match self.handle_content(helper, output, &mut fallback)? {
11323 ElementHandlerOutput::Break { event, allow_any } => {
11324 break (event, allow_any)
11325 }
11326 ElementHandlerOutput::Continue { event, .. } => event,
11327 }
11328 }
11329 }
11330 };
11331 if let Some(fallback) = fallback {
11332 *self.state__ = fallback;
11333 }
11334 let artifact = DeserializerArtifact::Deserializer(self);
11335 Ok(DeserializerOutput {
11336 artifact,
11337 event,
11338 allow_any,
11339 })
11340 }
11341 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Restriction, Error> {
11342 let state = replace(&mut *self.state__, RestrictionDeserializerState::Unknown__);
11343 self.finish_state(helper, state)?;
11344 Ok(super::Restriction {
11345 id: self.id,
11346 base: self.base,
11347 content: helper.finish_vec(0usize, None, self.content)?,
11348 })
11349 }
11350 }
11351 #[derive(Debug)]
11352 pub struct RestrictionContentDeserializer {
11353 state__: Box<RestrictionContentDeserializerState>,
11354 }
11355 #[derive(Debug)]
11356 pub enum RestrictionContentDeserializerState {
11357 Init__,
11358 Annotation(
11359 Option<super::Annotation>,
11360 Option<<super::Annotation as WithDeserializer>::Deserializer>,
11361 Option<<super::Annotation as WithDeserializer>::Deserializer>,
11362 ),
11363 SimpleType(
11364 Option<super::SimpleBaseType>,
11365 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
11366 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
11367 ),
11368 Facet(
11369 Option<super::Facet>,
11370 Option<<super::Facet as WithDeserializer>::Deserializer>,
11371 Option<<super::Facet as WithDeserializer>::Deserializer>,
11372 ),
11373 Done__(super::RestrictionContent),
11374 Unknown__,
11375 }
11376 impl RestrictionContentDeserializer {
11377 fn find_suitable<'de>(
11378 &mut self,
11379 helper: &mut DeserializeHelper,
11380 event: Event<'de>,
11381 ) -> Result<ElementHandlerOutput<'de>, Error> {
11382 let mut event = event;
11383 if let Event::Start(x) | Event::Empty(x) = &event {
11384 if matches!(
11385 helper.resolve_local_name(x.name(), &super::NS_XS),
11386 Some(b"annotation")
11387 ) {
11388 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
11389 return self.handle_annotation(helper, Default::default(), None, output);
11390 }
11391 if matches!(
11392 helper.resolve_local_name(x.name(), &super::NS_XS),
11393 Some(b"simpleType")
11394 ) {
11395 let output = <super::SimpleBaseType as WithDeserializer>::init(helper, event)?;
11396 return self.handle_simple_type(helper, Default::default(), None, output);
11397 }
11398 event = {
11399 let output = <super::Facet as WithDeserializer>::init(helper, event)?;
11400 match self.handle_facet(helper, Default::default(), None, output)? {
11401 ElementHandlerOutput::Continue { event, .. } => event,
11402 output => {
11403 return Ok(output);
11404 }
11405 }
11406 };
11407 }
11408 *self.state__ = RestrictionContentDeserializerState::Init__;
11409 Ok(ElementHandlerOutput::return_to_parent(event, true))
11410 }
11411 fn finish_state(
11412 helper: &mut DeserializeHelper,
11413 state: RestrictionContentDeserializerState,
11414 ) -> Result<super::RestrictionContent, Error> {
11415 use RestrictionContentDeserializerState as S;
11416 match state {
11417 S::Init__ => Err(ErrorKind::MissingContent.into()),
11418 S::Annotation(mut values, None, deserializer) => {
11419 if let Some(deserializer) = deserializer {
11420 let value = deserializer.finish(helper)?;
11421 RestrictionContentDeserializer::store_annotation(&mut values, value)?;
11422 }
11423 Ok(super::RestrictionContent::Annotation(
11424 helper.finish_element("annotation", values)?,
11425 ))
11426 }
11427 S::SimpleType(mut values, None, deserializer) => {
11428 if let Some(deserializer) = deserializer {
11429 let value = deserializer.finish(helper)?;
11430 RestrictionContentDeserializer::store_simple_type(&mut values, value)?;
11431 }
11432 Ok(super::RestrictionContent::SimpleType(
11433 helper.finish_element("simpleType", values)?,
11434 ))
11435 }
11436 S::Facet(mut values, None, deserializer) => {
11437 if let Some(deserializer) = deserializer {
11438 let value = deserializer.finish(helper)?;
11439 RestrictionContentDeserializer::store_facet(&mut values, value)?;
11440 }
11441 Ok(super::RestrictionContent::Facet(
11442 helper.finish_element("facet", values)?,
11443 ))
11444 }
11445 S::Done__(data) => Ok(data),
11446 _ => unreachable!(),
11447 }
11448 }
11449 fn store_annotation(
11450 values: &mut Option<super::Annotation>,
11451 value: super::Annotation,
11452 ) -> Result<(), Error> {
11453 if values.is_some() {
11454 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11455 b"annotation",
11456 )))?;
11457 }
11458 *values = Some(value);
11459 Ok(())
11460 }
11461 fn store_simple_type(
11462 values: &mut Option<super::SimpleBaseType>,
11463 value: super::SimpleBaseType,
11464 ) -> Result<(), Error> {
11465 if values.is_some() {
11466 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11467 b"simpleType",
11468 )))?;
11469 }
11470 *values = Some(value);
11471 Ok(())
11472 }
11473 fn store_facet(
11474 values: &mut Option<super::Facet>,
11475 value: super::Facet,
11476 ) -> Result<(), Error> {
11477 if values.is_some() {
11478 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11479 b"facet",
11480 )))?;
11481 }
11482 *values = Some(value);
11483 Ok(())
11484 }
11485 fn handle_annotation<'de>(
11486 &mut self,
11487 helper: &mut DeserializeHelper,
11488 mut values: Option<super::Annotation>,
11489 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
11490 output: DeserializerOutput<'de, super::Annotation>,
11491 ) -> Result<ElementHandlerOutput<'de>, Error> {
11492 use RestrictionContentDeserializerState as S;
11493 let DeserializerOutput {
11494 artifact,
11495 event,
11496 allow_any,
11497 } = output;
11498 if artifact.is_none() {
11499 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
11500 }
11501 if let Some(deserializer) = fallback {
11502 let data = deserializer.finish(helper)?;
11503 RestrictionContentDeserializer::store_annotation(&mut values, data)?;
11504 }
11505 match artifact {
11506 DeserializerArtifact::None => unreachable!(),
11507 DeserializerArtifact::Data(data) => {
11508 RestrictionContentDeserializer::store_annotation(&mut values, data)?;
11509 let data = RestrictionContentDeserializer::finish_state(
11510 helper,
11511 S::Annotation(values, None, None),
11512 )?;
11513 *self.state__ = S::Done__(data);
11514 Ok(ElementHandlerOutput::break_(event, allow_any))
11515 }
11516 DeserializerArtifact::Deserializer(deserializer) => {
11517 *self.state__ = S::Annotation(values, None, Some(deserializer));
11518 Ok(ElementHandlerOutput::break_(event, allow_any))
11519 }
11520 }
11521 }
11522 fn handle_simple_type<'de>(
11523 &mut self,
11524 helper: &mut DeserializeHelper,
11525 mut values: Option<super::SimpleBaseType>,
11526 fallback: Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
11527 output: DeserializerOutput<'de, super::SimpleBaseType>,
11528 ) -> Result<ElementHandlerOutput<'de>, Error> {
11529 use RestrictionContentDeserializerState as S;
11530 let DeserializerOutput {
11531 artifact,
11532 event,
11533 allow_any,
11534 } = output;
11535 if artifact.is_none() {
11536 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
11537 }
11538 if let Some(deserializer) = fallback {
11539 let data = deserializer.finish(helper)?;
11540 RestrictionContentDeserializer::store_simple_type(&mut values, data)?;
11541 }
11542 match artifact {
11543 DeserializerArtifact::None => unreachable!(),
11544 DeserializerArtifact::Data(data) => {
11545 RestrictionContentDeserializer::store_simple_type(&mut values, data)?;
11546 let data = RestrictionContentDeserializer::finish_state(
11547 helper,
11548 S::SimpleType(values, None, None),
11549 )?;
11550 *self.state__ = S::Done__(data);
11551 Ok(ElementHandlerOutput::break_(event, allow_any))
11552 }
11553 DeserializerArtifact::Deserializer(deserializer) => {
11554 *self.state__ = S::SimpleType(values, None, Some(deserializer));
11555 Ok(ElementHandlerOutput::break_(event, allow_any))
11556 }
11557 }
11558 }
11559 fn handle_facet<'de>(
11560 &mut self,
11561 helper: &mut DeserializeHelper,
11562 mut values: Option<super::Facet>,
11563 fallback: Option<<super::Facet as WithDeserializer>::Deserializer>,
11564 output: DeserializerOutput<'de, super::Facet>,
11565 ) -> Result<ElementHandlerOutput<'de>, Error> {
11566 use RestrictionContentDeserializerState as S;
11567 let DeserializerOutput {
11568 artifact,
11569 event,
11570 allow_any,
11571 } = output;
11572 if artifact.is_none() {
11573 return Ok(ElementHandlerOutput::from_event(event, allow_any));
11574 }
11575 if let Some(deserializer) = fallback {
11576 let data = deserializer.finish(helper)?;
11577 RestrictionContentDeserializer::store_facet(&mut values, data)?;
11578 }
11579 match artifact {
11580 DeserializerArtifact::None => unreachable!(),
11581 DeserializerArtifact::Data(data) => {
11582 RestrictionContentDeserializer::store_facet(&mut values, data)?;
11583 let data = RestrictionContentDeserializer::finish_state(
11584 helper,
11585 S::Facet(values, None, None),
11586 )?;
11587 *self.state__ = S::Done__(data);
11588 Ok(ElementHandlerOutput::break_(event, allow_any))
11589 }
11590 DeserializerArtifact::Deserializer(deserializer) => {
11591 *self.state__ = S::Facet(values, None, Some(deserializer));
11592 Ok(ElementHandlerOutput::break_(event, allow_any))
11593 }
11594 }
11595 }
11596 }
11597 impl<'de> Deserializer<'de, super::RestrictionContent> for Box<RestrictionContentDeserializer> {
11598 fn init(
11599 helper: &mut DeserializeHelper,
11600 event: Event<'de>,
11601 ) -> DeserializerResult<'de, super::RestrictionContent> {
11602 let deserializer = Box::new(RestrictionContentDeserializer {
11603 state__: Box::new(RestrictionContentDeserializerState::Init__),
11604 });
11605 let mut output = deserializer.next(helper, event)?;
11606 output.artifact = match output.artifact {
11607 DeserializerArtifact::Deserializer(x)
11608 if matches!(&*x.state__, RestrictionContentDeserializerState::Init__) =>
11609 {
11610 DeserializerArtifact::None
11611 }
11612 artifact => artifact,
11613 };
11614 Ok(output)
11615 }
11616 fn next(
11617 mut self,
11618 helper: &mut DeserializeHelper,
11619 event: Event<'de>,
11620 ) -> DeserializerResult<'de, super::RestrictionContent> {
11621 use RestrictionContentDeserializerState as S;
11622 let mut event = event;
11623 let (event, allow_any) = loop {
11624 let state = replace(&mut *self.state__, S::Unknown__);
11625 event = match (state, event) {
11626 (S::Unknown__, _) => unreachable!(),
11627 (S::Annotation(values, fallback, Some(deserializer)), event) => {
11628 let output = deserializer.next(helper, event)?;
11629 match self.handle_annotation(helper, values, fallback, output)? {
11630 ElementHandlerOutput::Break { event, allow_any } => {
11631 break (event, allow_any)
11632 }
11633 ElementHandlerOutput::Continue { event, .. } => event,
11634 }
11635 }
11636 (S::SimpleType(values, fallback, Some(deserializer)), event) => {
11637 let output = deserializer.next(helper, event)?;
11638 match self.handle_simple_type(helper, values, fallback, output)? {
11639 ElementHandlerOutput::Break { event, allow_any } => {
11640 break (event, allow_any)
11641 }
11642 ElementHandlerOutput::Continue { event, .. } => event,
11643 }
11644 }
11645 (S::Facet(values, fallback, Some(deserializer)), event) => {
11646 let output = deserializer.next(helper, event)?;
11647 match self.handle_facet(helper, values, fallback, output)? {
11648 ElementHandlerOutput::Break { event, allow_any } => {
11649 break (event, allow_any)
11650 }
11651 ElementHandlerOutput::Continue { event, .. } => event,
11652 }
11653 }
11654 (state, event @ Event::End(_)) => {
11655 return Ok(DeserializerOutput {
11656 artifact: DeserializerArtifact::Data(
11657 RestrictionContentDeserializer::finish_state(helper, state)?,
11658 ),
11659 event: DeserializerEvent::Continue(event),
11660 allow_any: false,
11661 });
11662 }
11663 (S::Init__, event) => match self.find_suitable(helper, event)? {
11664 ElementHandlerOutput::Break { event, allow_any } => {
11665 break (event, allow_any)
11666 }
11667 ElementHandlerOutput::Continue { event, .. } => event,
11668 },
11669 (
11670 S::Annotation(values, fallback, None),
11671 event @ (Event::Start(_) | Event::Empty(_)),
11672 ) => {
11673 let output = helper.init_start_tag_deserializer(
11674 event,
11675 Some(&super::NS_XS),
11676 b"annotation",
11677 false,
11678 )?;
11679 match self.handle_annotation(helper, values, fallback, output)? {
11680 ElementHandlerOutput::Break { event, allow_any } => {
11681 break (event, allow_any)
11682 }
11683 ElementHandlerOutput::Continue { event, .. } => event,
11684 }
11685 }
11686 (
11687 S::SimpleType(values, fallback, None),
11688 event @ (Event::Start(_) | Event::Empty(_)),
11689 ) => {
11690 let output = helper.init_start_tag_deserializer(
11691 event,
11692 Some(&super::NS_XS),
11693 b"simpleType",
11694 true,
11695 )?;
11696 match self.handle_simple_type(helper, values, fallback, output)? {
11697 ElementHandlerOutput::Break { event, allow_any } => {
11698 break (event, allow_any)
11699 }
11700 ElementHandlerOutput::Continue { event, .. } => event,
11701 }
11702 }
11703 (
11704 S::Facet(values, fallback, None),
11705 event @ (Event::Start(_) | Event::Empty(_)),
11706 ) => {
11707 let output = <super::Facet as WithDeserializer>::init(helper, event)?;
11708 match self.handle_facet(helper, values, fallback, output)? {
11709 ElementHandlerOutput::Break { event, allow_any } => {
11710 break (event, allow_any)
11711 }
11712 ElementHandlerOutput::Continue { event, .. } => event,
11713 }
11714 }
11715 (state @ S::Done__(_), event) => {
11716 *self.state__ = state;
11717 break (DeserializerEvent::Continue(event), false);
11718 }
11719 (state, event) => {
11720 *self.state__ = state;
11721 break (DeserializerEvent::Continue(event), false);
11722 }
11723 }
11724 };
11725 let artifact = if matches!(&*self.state__, S::Done__(_)) {
11726 DeserializerArtifact::Data(self.finish(helper)?)
11727 } else {
11728 DeserializerArtifact::Deserializer(self)
11729 };
11730 Ok(DeserializerOutput {
11731 artifact,
11732 event,
11733 allow_any,
11734 })
11735 }
11736 fn finish(
11737 self,
11738 helper: &mut DeserializeHelper,
11739 ) -> Result<super::RestrictionContent, Error> {
11740 RestrictionContentDeserializer::finish_state(helper, *self.state__)
11741 }
11742 }
11743 #[derive(Debug)]
11744 pub struct ListDeserializer {
11745 id: Option<String>,
11746 item_type: Option<QName>,
11747 annotation: Option<super::Annotation>,
11748 simple_type: Option<super::SimpleBaseType>,
11749 state__: Box<ListDeserializerState>,
11750 }
11751 #[derive(Debug)]
11752 enum ListDeserializerState {
11753 Init__,
11754 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
11755 SimpleType(Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>),
11756 Done__,
11757 Unknown__,
11758 }
11759 impl ListDeserializer {
11760 fn from_bytes_start(
11761 helper: &mut DeserializeHelper,
11762 bytes_start: &BytesStart<'_>,
11763 ) -> Result<Box<Self>, Error> {
11764 let mut id: Option<String> = None;
11765 let mut item_type: Option<QName> = None;
11766 for attrib in helper.filter_xmlns_attributes(bytes_start) {
11767 let attrib = attrib?;
11768 if matches!(
11769 helper.resolve_local_name(attrib.key, &super::NS_XS),
11770 Some(b"id")
11771 ) {
11772 helper.read_attrib(&mut id, b"id", &attrib.value)?;
11773 } else if matches!(
11774 helper.resolve_local_name(attrib.key, &super::NS_XS),
11775 Some(b"itemType")
11776 ) {
11777 helper.read_attrib(&mut item_type, b"itemType", &attrib.value)?;
11778 }
11779 }
11780 Ok(Box::new(Self {
11781 id: id,
11782 item_type: item_type,
11783 annotation: None,
11784 simple_type: None,
11785 state__: Box::new(ListDeserializerState::Init__),
11786 }))
11787 }
11788 fn finish_state(
11789 &mut self,
11790 helper: &mut DeserializeHelper,
11791 state: ListDeserializerState,
11792 ) -> Result<(), Error> {
11793 use ListDeserializerState as S;
11794 match state {
11795 S::Annotation(Some(deserializer)) => {
11796 self.store_annotation(deserializer.finish(helper)?)?
11797 }
11798 S::SimpleType(Some(deserializer)) => {
11799 self.store_simple_type(deserializer.finish(helper)?)?
11800 }
11801 _ => (),
11802 }
11803 Ok(())
11804 }
11805 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
11806 if self.annotation.is_some() {
11807 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11808 b"annotation",
11809 )))?;
11810 }
11811 self.annotation = Some(value);
11812 Ok(())
11813 }
11814 fn store_simple_type(&mut self, value: super::SimpleBaseType) -> Result<(), Error> {
11815 if self.simple_type.is_some() {
11816 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
11817 b"simpleType",
11818 )))?;
11819 }
11820 self.simple_type = Some(value);
11821 Ok(())
11822 }
11823 fn handle_annotation<'de>(
11824 &mut self,
11825 helper: &mut DeserializeHelper,
11826 output: DeserializerOutput<'de, super::Annotation>,
11827 fallback: &mut Option<ListDeserializerState>,
11828 ) -> Result<ElementHandlerOutput<'de>, Error> {
11829 use ListDeserializerState as S;
11830 let DeserializerOutput {
11831 artifact,
11832 event,
11833 allow_any,
11834 } = output;
11835 if artifact.is_none() {
11836 fallback.get_or_insert(S::Annotation(None));
11837 *self.state__ = S::SimpleType(None);
11838 return Ok(ElementHandlerOutput::from_event(event, allow_any));
11839 }
11840 if let Some(fallback) = fallback.take() {
11841 self.finish_state(helper, fallback)?;
11842 }
11843 match artifact {
11844 DeserializerArtifact::None => unreachable!(),
11845 DeserializerArtifact::Data(data) => {
11846 self.store_annotation(data)?;
11847 *self.state__ = S::SimpleType(None);
11848 Ok(ElementHandlerOutput::from_event(event, allow_any))
11849 }
11850 DeserializerArtifact::Deserializer(deserializer) => {
11851 fallback.get_or_insert(S::Annotation(Some(deserializer)));
11852 *self.state__ = S::SimpleType(None);
11853 Ok(ElementHandlerOutput::from_event(event, allow_any))
11854 }
11855 }
11856 }
11857 fn handle_simple_type<'de>(
11858 &mut self,
11859 helper: &mut DeserializeHelper,
11860 output: DeserializerOutput<'de, super::SimpleBaseType>,
11861 fallback: &mut Option<ListDeserializerState>,
11862 ) -> Result<ElementHandlerOutput<'de>, Error> {
11863 use ListDeserializerState as S;
11864 let DeserializerOutput {
11865 artifact,
11866 event,
11867 allow_any,
11868 } = output;
11869 if artifact.is_none() {
11870 fallback.get_or_insert(S::SimpleType(None));
11871 *self.state__ = S::Done__;
11872 return Ok(ElementHandlerOutput::from_event(event, allow_any));
11873 }
11874 if let Some(fallback) = fallback.take() {
11875 self.finish_state(helper, fallback)?;
11876 }
11877 match artifact {
11878 DeserializerArtifact::None => unreachable!(),
11879 DeserializerArtifact::Data(data) => {
11880 self.store_simple_type(data)?;
11881 *self.state__ = S::Done__;
11882 Ok(ElementHandlerOutput::from_event(event, allow_any))
11883 }
11884 DeserializerArtifact::Deserializer(deserializer) => {
11885 fallback.get_or_insert(S::SimpleType(Some(deserializer)));
11886 *self.state__ = S::Done__;
11887 Ok(ElementHandlerOutput::from_event(event, allow_any))
11888 }
11889 }
11890 }
11891 }
11892 impl<'de> Deserializer<'de, super::List> for Box<ListDeserializer> {
11893 fn init(
11894 helper: &mut DeserializeHelper,
11895 event: Event<'de>,
11896 ) -> DeserializerResult<'de, super::List> {
11897 helper.init_deserializer_from_start_event(event, ListDeserializer::from_bytes_start)
11898 }
11899 fn next(
11900 mut self,
11901 helper: &mut DeserializeHelper,
11902 event: Event<'de>,
11903 ) -> DeserializerResult<'de, super::List> {
11904 use ListDeserializerState as S;
11905 let mut event = event;
11906 let mut fallback = None;
11907 let mut allow_any_element = false;
11908 let (event, allow_any) = loop {
11909 let state = replace(&mut *self.state__, S::Unknown__);
11910 event = match (state, event) {
11911 (S::Unknown__, _) => unreachable!(),
11912 (S::Annotation(Some(deserializer)), event) => {
11913 let output = deserializer.next(helper, event)?;
11914 match self.handle_annotation(helper, output, &mut fallback)? {
11915 ElementHandlerOutput::Continue { event, allow_any } => {
11916 allow_any_element = allow_any_element || allow_any;
11917 event
11918 }
11919 ElementHandlerOutput::Break { event, allow_any } => {
11920 break (event, allow_any)
11921 }
11922 }
11923 }
11924 (S::SimpleType(Some(deserializer)), event) => {
11925 let output = deserializer.next(helper, event)?;
11926 match self.handle_simple_type(helper, output, &mut fallback)? {
11927 ElementHandlerOutput::Continue { event, allow_any } => {
11928 allow_any_element = allow_any_element || allow_any;
11929 event
11930 }
11931 ElementHandlerOutput::Break { event, allow_any } => {
11932 break (event, allow_any)
11933 }
11934 }
11935 }
11936 (_, Event::End(_)) => {
11937 if let Some(fallback) = fallback.take() {
11938 self.finish_state(helper, fallback)?;
11939 }
11940 return Ok(DeserializerOutput {
11941 artifact: DeserializerArtifact::Data(self.finish(helper)?),
11942 event: DeserializerEvent::None,
11943 allow_any: false,
11944 });
11945 }
11946 (S::Init__, event) => {
11947 fallback.get_or_insert(S::Init__);
11948 *self.state__ = S::Annotation(None);
11949 event
11950 }
11951 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
11952 let output = helper.init_start_tag_deserializer(
11953 event,
11954 Some(&super::NS_XS),
11955 b"annotation",
11956 false,
11957 )?;
11958 match self.handle_annotation(helper, output, &mut fallback)? {
11959 ElementHandlerOutput::Continue { event, allow_any } => {
11960 allow_any_element = allow_any_element || allow_any;
11961 event
11962 }
11963 ElementHandlerOutput::Break { event, allow_any } => {
11964 break (event, allow_any)
11965 }
11966 }
11967 }
11968 (S::SimpleType(None), event @ (Event::Start(_) | Event::Empty(_))) => {
11969 let output = helper.init_start_tag_deserializer(
11970 event,
11971 Some(&super::NS_XS),
11972 b"simpleType",
11973 true,
11974 )?;
11975 match self.handle_simple_type(helper, output, &mut fallback)? {
11976 ElementHandlerOutput::Continue { event, allow_any } => {
11977 allow_any_element = allow_any_element || allow_any;
11978 event
11979 }
11980 ElementHandlerOutput::Break { event, allow_any } => {
11981 break (event, allow_any)
11982 }
11983 }
11984 }
11985 (S::Done__, event) => {
11986 *self.state__ = S::Done__;
11987 break (DeserializerEvent::Continue(event), allow_any_element);
11988 }
11989 (state, event) => {
11990 *self.state__ = state;
11991 break (DeserializerEvent::Break(event), false);
11992 }
11993 }
11994 };
11995 if let Some(fallback) = fallback {
11996 *self.state__ = fallback;
11997 }
11998 Ok(DeserializerOutput {
11999 artifact: DeserializerArtifact::Deserializer(self),
12000 event,
12001 allow_any,
12002 })
12003 }
12004 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::List, Error> {
12005 let state = replace(&mut *self.state__, ListDeserializerState::Unknown__);
12006 self.finish_state(helper, state)?;
12007 Ok(super::List {
12008 id: self.id,
12009 item_type: self.item_type,
12010 annotation: self.annotation,
12011 simple_type: self.simple_type.map(Box::new),
12012 })
12013 }
12014 }
12015 #[derive(Debug)]
12016 pub struct UnionDeserializer {
12017 id: Option<String>,
12018 member_types: Option<super::QNameList>,
12019 annotation: Option<super::Annotation>,
12020 simple_type: Vec<super::SimpleBaseType>,
12021 state__: Box<UnionDeserializerState>,
12022 }
12023 #[derive(Debug)]
12024 enum UnionDeserializerState {
12025 Init__,
12026 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
12027 SimpleType(Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>),
12028 Done__,
12029 Unknown__,
12030 }
12031 impl UnionDeserializer {
12032 fn from_bytes_start(
12033 helper: &mut DeserializeHelper,
12034 bytes_start: &BytesStart<'_>,
12035 ) -> Result<Box<Self>, Error> {
12036 let mut id: Option<String> = None;
12037 let mut member_types: Option<super::QNameList> = None;
12038 for attrib in helper.filter_xmlns_attributes(bytes_start) {
12039 let attrib = attrib?;
12040 if matches!(
12041 helper.resolve_local_name(attrib.key, &super::NS_XS),
12042 Some(b"id")
12043 ) {
12044 helper.read_attrib(&mut id, b"id", &attrib.value)?;
12045 } else if matches!(
12046 helper.resolve_local_name(attrib.key, &super::NS_XS),
12047 Some(b"memberTypes")
12048 ) {
12049 helper.read_attrib(&mut member_types, b"memberTypes", &attrib.value)?;
12050 }
12051 }
12052 Ok(Box::new(Self {
12053 id: id,
12054 member_types: member_types,
12055 annotation: None,
12056 simple_type: Vec::new(),
12057 state__: Box::new(UnionDeserializerState::Init__),
12058 }))
12059 }
12060 fn finish_state(
12061 &mut self,
12062 helper: &mut DeserializeHelper,
12063 state: UnionDeserializerState,
12064 ) -> Result<(), Error> {
12065 use UnionDeserializerState as S;
12066 match state {
12067 S::Annotation(Some(deserializer)) => {
12068 self.store_annotation(deserializer.finish(helper)?)?
12069 }
12070 S::SimpleType(Some(deserializer)) => {
12071 self.store_simple_type(deserializer.finish(helper)?)?
12072 }
12073 _ => (),
12074 }
12075 Ok(())
12076 }
12077 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
12078 if self.annotation.is_some() {
12079 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12080 b"annotation",
12081 )))?;
12082 }
12083 self.annotation = Some(value);
12084 Ok(())
12085 }
12086 fn store_simple_type(&mut self, value: super::SimpleBaseType) -> Result<(), Error> {
12087 self.simple_type.push(value);
12088 Ok(())
12089 }
12090 fn handle_annotation<'de>(
12091 &mut self,
12092 helper: &mut DeserializeHelper,
12093 output: DeserializerOutput<'de, super::Annotation>,
12094 fallback: &mut Option<UnionDeserializerState>,
12095 ) -> Result<ElementHandlerOutput<'de>, Error> {
12096 use UnionDeserializerState as S;
12097 let DeserializerOutput {
12098 artifact,
12099 event,
12100 allow_any,
12101 } = output;
12102 if artifact.is_none() {
12103 fallback.get_or_insert(S::Annotation(None));
12104 *self.state__ = S::SimpleType(None);
12105 return Ok(ElementHandlerOutput::from_event(event, allow_any));
12106 }
12107 if let Some(fallback) = fallback.take() {
12108 self.finish_state(helper, fallback)?;
12109 }
12110 match artifact {
12111 DeserializerArtifact::None => unreachable!(),
12112 DeserializerArtifact::Data(data) => {
12113 self.store_annotation(data)?;
12114 *self.state__ = S::SimpleType(None);
12115 Ok(ElementHandlerOutput::from_event(event, allow_any))
12116 }
12117 DeserializerArtifact::Deserializer(deserializer) => {
12118 fallback.get_or_insert(S::Annotation(Some(deserializer)));
12119 *self.state__ = S::SimpleType(None);
12120 Ok(ElementHandlerOutput::from_event(event, allow_any))
12121 }
12122 }
12123 }
12124 fn handle_simple_type<'de>(
12125 &mut self,
12126 helper: &mut DeserializeHelper,
12127 output: DeserializerOutput<'de, super::SimpleBaseType>,
12128 fallback: &mut Option<UnionDeserializerState>,
12129 ) -> Result<ElementHandlerOutput<'de>, Error> {
12130 use UnionDeserializerState as S;
12131 let DeserializerOutput {
12132 artifact,
12133 event,
12134 allow_any,
12135 } = output;
12136 if artifact.is_none() {
12137 fallback.get_or_insert(S::SimpleType(None));
12138 *self.state__ = S::Done__;
12139 return Ok(ElementHandlerOutput::from_event(event, allow_any));
12140 }
12141 if let Some(fallback) = fallback.take() {
12142 self.finish_state(helper, fallback)?;
12143 }
12144 match artifact {
12145 DeserializerArtifact::None => unreachable!(),
12146 DeserializerArtifact::Data(data) => {
12147 self.store_simple_type(data)?;
12148 *self.state__ = S::SimpleType(None);
12149 Ok(ElementHandlerOutput::from_event(event, allow_any))
12150 }
12151 DeserializerArtifact::Deserializer(deserializer) => {
12152 fallback.get_or_insert(S::SimpleType(Some(deserializer)));
12153 *self.state__ = S::SimpleType(None);
12154 Ok(ElementHandlerOutput::from_event(event, allow_any))
12155 }
12156 }
12157 }
12158 }
12159 impl<'de> Deserializer<'de, super::Union> for Box<UnionDeserializer> {
12160 fn init(
12161 helper: &mut DeserializeHelper,
12162 event: Event<'de>,
12163 ) -> DeserializerResult<'de, super::Union> {
12164 helper.init_deserializer_from_start_event(event, UnionDeserializer::from_bytes_start)
12165 }
12166 fn next(
12167 mut self,
12168 helper: &mut DeserializeHelper,
12169 event: Event<'de>,
12170 ) -> DeserializerResult<'de, super::Union> {
12171 use UnionDeserializerState as S;
12172 let mut event = event;
12173 let mut fallback = None;
12174 let mut allow_any_element = false;
12175 let (event, allow_any) = loop {
12176 let state = replace(&mut *self.state__, S::Unknown__);
12177 event = match (state, event) {
12178 (S::Unknown__, _) => unreachable!(),
12179 (S::Annotation(Some(deserializer)), event) => {
12180 let output = deserializer.next(helper, event)?;
12181 match self.handle_annotation(helper, output, &mut fallback)? {
12182 ElementHandlerOutput::Continue { event, allow_any } => {
12183 allow_any_element = allow_any_element || allow_any;
12184 event
12185 }
12186 ElementHandlerOutput::Break { event, allow_any } => {
12187 break (event, allow_any)
12188 }
12189 }
12190 }
12191 (S::SimpleType(Some(deserializer)), event) => {
12192 let output = deserializer.next(helper, event)?;
12193 match self.handle_simple_type(helper, output, &mut fallback)? {
12194 ElementHandlerOutput::Continue { event, allow_any } => {
12195 allow_any_element = allow_any_element || allow_any;
12196 event
12197 }
12198 ElementHandlerOutput::Break { event, allow_any } => {
12199 break (event, allow_any)
12200 }
12201 }
12202 }
12203 (_, Event::End(_)) => {
12204 if let Some(fallback) = fallback.take() {
12205 self.finish_state(helper, fallback)?;
12206 }
12207 return Ok(DeserializerOutput {
12208 artifact: DeserializerArtifact::Data(self.finish(helper)?),
12209 event: DeserializerEvent::None,
12210 allow_any: false,
12211 });
12212 }
12213 (S::Init__, event) => {
12214 fallback.get_or_insert(S::Init__);
12215 *self.state__ = S::Annotation(None);
12216 event
12217 }
12218 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
12219 let output = helper.init_start_tag_deserializer(
12220 event,
12221 Some(&super::NS_XS),
12222 b"annotation",
12223 false,
12224 )?;
12225 match self.handle_annotation(helper, output, &mut fallback)? {
12226 ElementHandlerOutput::Continue { event, allow_any } => {
12227 allow_any_element = allow_any_element || allow_any;
12228 event
12229 }
12230 ElementHandlerOutput::Break { event, allow_any } => {
12231 break (event, allow_any)
12232 }
12233 }
12234 }
12235 (S::SimpleType(None), event @ (Event::Start(_) | Event::Empty(_))) => {
12236 let output = helper.init_start_tag_deserializer(
12237 event,
12238 Some(&super::NS_XS),
12239 b"simpleType",
12240 true,
12241 )?;
12242 match self.handle_simple_type(helper, output, &mut fallback)? {
12243 ElementHandlerOutput::Continue { event, allow_any } => {
12244 allow_any_element = allow_any_element || allow_any;
12245 event
12246 }
12247 ElementHandlerOutput::Break { event, allow_any } => {
12248 break (event, allow_any)
12249 }
12250 }
12251 }
12252 (S::Done__, event) => {
12253 *self.state__ = S::Done__;
12254 break (DeserializerEvent::Continue(event), allow_any_element);
12255 }
12256 (state, event) => {
12257 *self.state__ = state;
12258 break (DeserializerEvent::Break(event), false);
12259 }
12260 }
12261 };
12262 if let Some(fallback) = fallback {
12263 *self.state__ = fallback;
12264 }
12265 Ok(DeserializerOutput {
12266 artifact: DeserializerArtifact::Deserializer(self),
12267 event,
12268 allow_any,
12269 })
12270 }
12271 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Union, Error> {
12272 let state = replace(&mut *self.state__, UnionDeserializerState::Unknown__);
12273 self.finish_state(helper, state)?;
12274 Ok(super::Union {
12275 id: self.id,
12276 member_types: self.member_types,
12277 annotation: self.annotation,
12278 simple_type: self.simple_type,
12279 })
12280 }
12281 }
12282 #[derive(Debug)]
12283 pub struct SimpleContentDeserializer {
12284 id: Option<String>,
12285 content: Vec<super::SimpleContentContent>,
12286 state__: Box<SimpleContentDeserializerState>,
12287 }
12288 #[derive(Debug)]
12289 enum SimpleContentDeserializerState {
12290 Init__,
12291 Next__,
12292 Content__(<super::SimpleContentContent as WithDeserializer>::Deserializer),
12293 Unknown__,
12294 }
12295 impl SimpleContentDeserializer {
12296 fn from_bytes_start(
12297 helper: &mut DeserializeHelper,
12298 bytes_start: &BytesStart<'_>,
12299 ) -> Result<Box<Self>, Error> {
12300 let mut id: Option<String> = None;
12301 for attrib in helper.filter_xmlns_attributes(bytes_start) {
12302 let attrib = attrib?;
12303 if matches!(
12304 helper.resolve_local_name(attrib.key, &super::NS_XS),
12305 Some(b"id")
12306 ) {
12307 helper.read_attrib(&mut id, b"id", &attrib.value)?;
12308 }
12309 }
12310 Ok(Box::new(Self {
12311 id: id,
12312 content: Vec::new(),
12313 state__: Box::new(SimpleContentDeserializerState::Init__),
12314 }))
12315 }
12316 fn finish_state(
12317 &mut self,
12318 helper: &mut DeserializeHelper,
12319 state: SimpleContentDeserializerState,
12320 ) -> Result<(), Error> {
12321 if let SimpleContentDeserializerState::Content__(deserializer) = state {
12322 self.store_content(deserializer.finish(helper)?)?;
12323 }
12324 Ok(())
12325 }
12326 fn store_content(&mut self, value: super::SimpleContentContent) -> Result<(), Error> {
12327 self.content.push(value);
12328 Ok(())
12329 }
12330 fn handle_content<'de>(
12331 &mut self,
12332 helper: &mut DeserializeHelper,
12333 output: DeserializerOutput<'de, super::SimpleContentContent>,
12334 fallback: &mut Option<SimpleContentDeserializerState>,
12335 ) -> Result<ElementHandlerOutput<'de>, Error> {
12336 use SimpleContentDeserializerState as S;
12337 let DeserializerOutput {
12338 artifact,
12339 event,
12340 allow_any,
12341 } = output;
12342 if artifact.is_none() {
12343 *self.state__ = fallback.take().unwrap_or(S::Next__);
12344 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
12345 }
12346 if let Some(fallback) = fallback.take() {
12347 self.finish_state(helper, fallback)?;
12348 }
12349 match artifact {
12350 DeserializerArtifact::None => unreachable!(),
12351 DeserializerArtifact::Data(data) => {
12352 self.store_content(data)?;
12353 *self.state__ = S::Next__;
12354 Ok(ElementHandlerOutput::from_event(event, allow_any))
12355 }
12356 DeserializerArtifact::Deserializer(deserializer) => {
12357 if self.content.len() < 1usize {
12358 *fallback = Some(S::Content__(deserializer));
12359 *self.state__ = S::Next__;
12360 Ok(ElementHandlerOutput::from_event(event, allow_any))
12361 } else {
12362 *self.state__ = S::Content__(deserializer);
12363 Ok(ElementHandlerOutput::from_event_end(event, allow_any))
12364 }
12365 }
12366 }
12367 }
12368 }
12369 impl<'de> Deserializer<'de, super::SimpleContent> for Box<SimpleContentDeserializer> {
12370 fn init(
12371 helper: &mut DeserializeHelper,
12372 event: Event<'de>,
12373 ) -> DeserializerResult<'de, super::SimpleContent> {
12374 helper.init_deserializer_from_start_event(
12375 event,
12376 SimpleContentDeserializer::from_bytes_start,
12377 )
12378 }
12379 fn next(
12380 mut self,
12381 helper: &mut DeserializeHelper,
12382 event: Event<'de>,
12383 ) -> DeserializerResult<'de, super::SimpleContent> {
12384 use SimpleContentDeserializerState as S;
12385 let mut event = event;
12386 let mut fallback = None;
12387 let (event, allow_any) = loop {
12388 let state = replace(&mut *self.state__, S::Unknown__);
12389 event = match (state, event) {
12390 (S::Unknown__, _) => unreachable!(),
12391 (S::Content__(deserializer), event) => {
12392 let output = deserializer.next(helper, event)?;
12393 match self.handle_content(helper, output, &mut fallback)? {
12394 ElementHandlerOutput::Break { event, allow_any } => {
12395 break (event, allow_any)
12396 }
12397 ElementHandlerOutput::Continue { event, .. } => event,
12398 }
12399 }
12400 (_, Event::End(_)) => {
12401 return Ok(DeserializerOutput {
12402 artifact: DeserializerArtifact::Data(self.finish(helper)?),
12403 event: DeserializerEvent::None,
12404 allow_any: false,
12405 });
12406 }
12407 (state @ (S::Init__ | S::Next__), event) => {
12408 fallback.get_or_insert(state);
12409 let output =
12410 <super::SimpleContentContent as WithDeserializer>::init(helper, event)?;
12411 match self.handle_content(helper, output, &mut fallback)? {
12412 ElementHandlerOutput::Break { event, allow_any } => {
12413 break (event, allow_any)
12414 }
12415 ElementHandlerOutput::Continue { event, .. } => event,
12416 }
12417 }
12418 }
12419 };
12420 if let Some(fallback) = fallback {
12421 *self.state__ = fallback;
12422 }
12423 let artifact = DeserializerArtifact::Deserializer(self);
12424 Ok(DeserializerOutput {
12425 artifact,
12426 event,
12427 allow_any,
12428 })
12429 }
12430 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::SimpleContent, Error> {
12431 let state = replace(
12432 &mut *self.state__,
12433 SimpleContentDeserializerState::Unknown__,
12434 );
12435 self.finish_state(helper, state)?;
12436 Ok(super::SimpleContent {
12437 id: self.id,
12438 content: helper.finish_vec(1usize, Some(2usize), self.content)?,
12439 })
12440 }
12441 }
12442 #[derive(Debug)]
12443 pub struct SimpleContentContentDeserializer {
12444 state__: Box<SimpleContentContentDeserializerState>,
12445 }
12446 #[derive(Debug)]
12447 pub enum SimpleContentContentDeserializerState {
12448 Init__,
12449 Annotation(
12450 Option<super::Annotation>,
12451 Option<<super::Annotation as WithDeserializer>::Deserializer>,
12452 Option<<super::Annotation as WithDeserializer>::Deserializer>,
12453 ),
12454 Restriction(
12455 Option<super::RestrictionType>,
12456 Option<<super::RestrictionType as WithDeserializer>::Deserializer>,
12457 Option<<super::RestrictionType as WithDeserializer>::Deserializer>,
12458 ),
12459 Extension(
12460 Option<super::ExtensionType>,
12461 Option<<super::ExtensionType as WithDeserializer>::Deserializer>,
12462 Option<<super::ExtensionType as WithDeserializer>::Deserializer>,
12463 ),
12464 Done__(super::SimpleContentContent),
12465 Unknown__,
12466 }
12467 impl SimpleContentContentDeserializer {
12468 fn find_suitable<'de>(
12469 &mut self,
12470 helper: &mut DeserializeHelper,
12471 event: Event<'de>,
12472 ) -> Result<ElementHandlerOutput<'de>, Error> {
12473 if let Event::Start(x) | Event::Empty(x) = &event {
12474 if matches!(
12475 helper.resolve_local_name(x.name(), &super::NS_XS),
12476 Some(b"annotation")
12477 ) {
12478 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
12479 return self.handle_annotation(helper, Default::default(), None, output);
12480 }
12481 if matches!(
12482 helper.resolve_local_name(x.name(), &super::NS_XS),
12483 Some(b"restriction")
12484 ) {
12485 let output = <super::RestrictionType as WithDeserializer>::init(helper, event)?;
12486 return self.handle_restriction(helper, Default::default(), None, output);
12487 }
12488 if matches!(
12489 helper.resolve_local_name(x.name(), &super::NS_XS),
12490 Some(b"extension")
12491 ) {
12492 let output = <super::ExtensionType as WithDeserializer>::init(helper, event)?;
12493 return self.handle_extension(helper, Default::default(), None, output);
12494 }
12495 }
12496 *self.state__ = SimpleContentContentDeserializerState::Init__;
12497 Ok(ElementHandlerOutput::return_to_parent(event, false))
12498 }
12499 fn finish_state(
12500 helper: &mut DeserializeHelper,
12501 state: SimpleContentContentDeserializerState,
12502 ) -> Result<super::SimpleContentContent, Error> {
12503 use SimpleContentContentDeserializerState as S;
12504 match state {
12505 S::Init__ => Err(ErrorKind::MissingContent.into()),
12506 S::Annotation(mut values, None, deserializer) => {
12507 if let Some(deserializer) = deserializer {
12508 let value = deserializer.finish(helper)?;
12509 SimpleContentContentDeserializer::store_annotation(&mut values, value)?;
12510 }
12511 Ok(super::SimpleContentContent::Annotation(
12512 helper.finish_element("annotation", values)?,
12513 ))
12514 }
12515 S::Restriction(mut values, None, deserializer) => {
12516 if let Some(deserializer) = deserializer {
12517 let value = deserializer.finish(helper)?;
12518 SimpleContentContentDeserializer::store_restriction(&mut values, value)?;
12519 }
12520 Ok(super::SimpleContentContent::Restriction(
12521 helper.finish_element("restriction", values)?,
12522 ))
12523 }
12524 S::Extension(mut values, None, deserializer) => {
12525 if let Some(deserializer) = deserializer {
12526 let value = deserializer.finish(helper)?;
12527 SimpleContentContentDeserializer::store_extension(&mut values, value)?;
12528 }
12529 Ok(super::SimpleContentContent::Extension(
12530 helper.finish_element("extension", values)?,
12531 ))
12532 }
12533 S::Done__(data) => Ok(data),
12534 _ => unreachable!(),
12535 }
12536 }
12537 fn store_annotation(
12538 values: &mut Option<super::Annotation>,
12539 value: super::Annotation,
12540 ) -> Result<(), Error> {
12541 if values.is_some() {
12542 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12543 b"annotation",
12544 )))?;
12545 }
12546 *values = Some(value);
12547 Ok(())
12548 }
12549 fn store_restriction(
12550 values: &mut Option<super::RestrictionType>,
12551 value: super::RestrictionType,
12552 ) -> Result<(), Error> {
12553 if values.is_some() {
12554 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12555 b"restriction",
12556 )))?;
12557 }
12558 *values = Some(value);
12559 Ok(())
12560 }
12561 fn store_extension(
12562 values: &mut Option<super::ExtensionType>,
12563 value: super::ExtensionType,
12564 ) -> Result<(), Error> {
12565 if values.is_some() {
12566 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
12567 b"extension",
12568 )))?;
12569 }
12570 *values = Some(value);
12571 Ok(())
12572 }
12573 fn handle_annotation<'de>(
12574 &mut self,
12575 helper: &mut DeserializeHelper,
12576 mut values: Option<super::Annotation>,
12577 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
12578 output: DeserializerOutput<'de, super::Annotation>,
12579 ) -> Result<ElementHandlerOutput<'de>, Error> {
12580 use SimpleContentContentDeserializerState as S;
12581 let DeserializerOutput {
12582 artifact,
12583 event,
12584 allow_any,
12585 } = output;
12586 if artifact.is_none() {
12587 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
12588 }
12589 if let Some(deserializer) = fallback {
12590 let data = deserializer.finish(helper)?;
12591 SimpleContentContentDeserializer::store_annotation(&mut values, data)?;
12592 }
12593 match artifact {
12594 DeserializerArtifact::None => unreachable!(),
12595 DeserializerArtifact::Data(data) => {
12596 SimpleContentContentDeserializer::store_annotation(&mut values, data)?;
12597 let data = SimpleContentContentDeserializer::finish_state(
12598 helper,
12599 S::Annotation(values, None, None),
12600 )?;
12601 *self.state__ = S::Done__(data);
12602 Ok(ElementHandlerOutput::break_(event, allow_any))
12603 }
12604 DeserializerArtifact::Deserializer(deserializer) => {
12605 *self.state__ = S::Annotation(values, None, Some(deserializer));
12606 Ok(ElementHandlerOutput::break_(event, allow_any))
12607 }
12608 }
12609 }
12610 fn handle_restriction<'de>(
12611 &mut self,
12612 helper: &mut DeserializeHelper,
12613 mut values: Option<super::RestrictionType>,
12614 fallback: Option<<super::RestrictionType as WithDeserializer>::Deserializer>,
12615 output: DeserializerOutput<'de, super::RestrictionType>,
12616 ) -> Result<ElementHandlerOutput<'de>, Error> {
12617 use SimpleContentContentDeserializerState as S;
12618 let DeserializerOutput {
12619 artifact,
12620 event,
12621 allow_any,
12622 } = output;
12623 if artifact.is_none() {
12624 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
12625 }
12626 if let Some(deserializer) = fallback {
12627 let data = deserializer.finish(helper)?;
12628 SimpleContentContentDeserializer::store_restriction(&mut values, data)?;
12629 }
12630 match artifact {
12631 DeserializerArtifact::None => unreachable!(),
12632 DeserializerArtifact::Data(data) => {
12633 SimpleContentContentDeserializer::store_restriction(&mut values, data)?;
12634 let data = SimpleContentContentDeserializer::finish_state(
12635 helper,
12636 S::Restriction(values, None, None),
12637 )?;
12638 *self.state__ = S::Done__(data);
12639 Ok(ElementHandlerOutput::break_(event, allow_any))
12640 }
12641 DeserializerArtifact::Deserializer(deserializer) => {
12642 *self.state__ = S::Restriction(values, None, Some(deserializer));
12643 Ok(ElementHandlerOutput::break_(event, allow_any))
12644 }
12645 }
12646 }
12647 fn handle_extension<'de>(
12648 &mut self,
12649 helper: &mut DeserializeHelper,
12650 mut values: Option<super::ExtensionType>,
12651 fallback: Option<<super::ExtensionType as WithDeserializer>::Deserializer>,
12652 output: DeserializerOutput<'de, super::ExtensionType>,
12653 ) -> Result<ElementHandlerOutput<'de>, Error> {
12654 use SimpleContentContentDeserializerState as S;
12655 let DeserializerOutput {
12656 artifact,
12657 event,
12658 allow_any,
12659 } = output;
12660 if artifact.is_none() {
12661 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
12662 }
12663 if let Some(deserializer) = fallback {
12664 let data = deserializer.finish(helper)?;
12665 SimpleContentContentDeserializer::store_extension(&mut values, data)?;
12666 }
12667 match artifact {
12668 DeserializerArtifact::None => unreachable!(),
12669 DeserializerArtifact::Data(data) => {
12670 SimpleContentContentDeserializer::store_extension(&mut values, data)?;
12671 let data = SimpleContentContentDeserializer::finish_state(
12672 helper,
12673 S::Extension(values, None, None),
12674 )?;
12675 *self.state__ = S::Done__(data);
12676 Ok(ElementHandlerOutput::break_(event, allow_any))
12677 }
12678 DeserializerArtifact::Deserializer(deserializer) => {
12679 *self.state__ = S::Extension(values, None, Some(deserializer));
12680 Ok(ElementHandlerOutput::break_(event, allow_any))
12681 }
12682 }
12683 }
12684 }
12685 impl<'de> Deserializer<'de, super::SimpleContentContent> for Box<SimpleContentContentDeserializer> {
12686 fn init(
12687 helper: &mut DeserializeHelper,
12688 event: Event<'de>,
12689 ) -> DeserializerResult<'de, super::SimpleContentContent> {
12690 let deserializer = Box::new(SimpleContentContentDeserializer {
12691 state__: Box::new(SimpleContentContentDeserializerState::Init__),
12692 });
12693 let mut output = deserializer.next(helper, event)?;
12694 output.artifact = match output.artifact {
12695 DeserializerArtifact::Deserializer(x)
12696 if matches!(&*x.state__, SimpleContentContentDeserializerState::Init__) =>
12697 {
12698 DeserializerArtifact::None
12699 }
12700 artifact => artifact,
12701 };
12702 Ok(output)
12703 }
12704 fn next(
12705 mut self,
12706 helper: &mut DeserializeHelper,
12707 event: Event<'de>,
12708 ) -> DeserializerResult<'de, super::SimpleContentContent> {
12709 use SimpleContentContentDeserializerState as S;
12710 let mut event = event;
12711 let (event, allow_any) = loop {
12712 let state = replace(&mut *self.state__, S::Unknown__);
12713 event = match (state, event) {
12714 (S::Unknown__, _) => unreachable!(),
12715 (S::Annotation(values, fallback, Some(deserializer)), event) => {
12716 let output = deserializer.next(helper, event)?;
12717 match self.handle_annotation(helper, values, fallback, output)? {
12718 ElementHandlerOutput::Break { event, allow_any } => {
12719 break (event, allow_any)
12720 }
12721 ElementHandlerOutput::Continue { event, .. } => event,
12722 }
12723 }
12724 (S::Restriction(values, fallback, Some(deserializer)), event) => {
12725 let output = deserializer.next(helper, event)?;
12726 match self.handle_restriction(helper, values, fallback, output)? {
12727 ElementHandlerOutput::Break { event, allow_any } => {
12728 break (event, allow_any)
12729 }
12730 ElementHandlerOutput::Continue { event, .. } => event,
12731 }
12732 }
12733 (S::Extension(values, fallback, Some(deserializer)), event) => {
12734 let output = deserializer.next(helper, event)?;
12735 match self.handle_extension(helper, values, fallback, output)? {
12736 ElementHandlerOutput::Break { event, allow_any } => {
12737 break (event, allow_any)
12738 }
12739 ElementHandlerOutput::Continue { event, .. } => event,
12740 }
12741 }
12742 (state, event @ Event::End(_)) => {
12743 return Ok(DeserializerOutput {
12744 artifact: DeserializerArtifact::Data(
12745 SimpleContentContentDeserializer::finish_state(helper, state)?,
12746 ),
12747 event: DeserializerEvent::Continue(event),
12748 allow_any: false,
12749 });
12750 }
12751 (S::Init__, event) => match self.find_suitable(helper, event)? {
12752 ElementHandlerOutput::Break { event, allow_any } => {
12753 break (event, allow_any)
12754 }
12755 ElementHandlerOutput::Continue { event, .. } => event,
12756 },
12757 (
12758 S::Annotation(values, fallback, None),
12759 event @ (Event::Start(_) | Event::Empty(_)),
12760 ) => {
12761 let output = helper.init_start_tag_deserializer(
12762 event,
12763 Some(&super::NS_XS),
12764 b"annotation",
12765 false,
12766 )?;
12767 match self.handle_annotation(helper, values, fallback, output)? {
12768 ElementHandlerOutput::Break { event, allow_any } => {
12769 break (event, allow_any)
12770 }
12771 ElementHandlerOutput::Continue { event, .. } => event,
12772 }
12773 }
12774 (
12775 S::Restriction(values, fallback, None),
12776 event @ (Event::Start(_) | Event::Empty(_)),
12777 ) => {
12778 let output = helper.init_start_tag_deserializer(
12779 event,
12780 Some(&super::NS_XS),
12781 b"restriction",
12782 true,
12783 )?;
12784 match self.handle_restriction(helper, values, fallback, output)? {
12785 ElementHandlerOutput::Break { event, allow_any } => {
12786 break (event, allow_any)
12787 }
12788 ElementHandlerOutput::Continue { event, .. } => event,
12789 }
12790 }
12791 (
12792 S::Extension(values, fallback, None),
12793 event @ (Event::Start(_) | Event::Empty(_)),
12794 ) => {
12795 let output = helper.init_start_tag_deserializer(
12796 event,
12797 Some(&super::NS_XS),
12798 b"extension",
12799 true,
12800 )?;
12801 match self.handle_extension(helper, values, fallback, output)? {
12802 ElementHandlerOutput::Break { event, allow_any } => {
12803 break (event, allow_any)
12804 }
12805 ElementHandlerOutput::Continue { event, .. } => event,
12806 }
12807 }
12808 (state @ S::Done__(_), event) => {
12809 *self.state__ = state;
12810 break (DeserializerEvent::Continue(event), false);
12811 }
12812 (state, event) => {
12813 *self.state__ = state;
12814 break (DeserializerEvent::Continue(event), false);
12815 }
12816 }
12817 };
12818 let artifact = if matches!(&*self.state__, S::Done__(_)) {
12819 DeserializerArtifact::Data(self.finish(helper)?)
12820 } else {
12821 DeserializerArtifact::Deserializer(self)
12822 };
12823 Ok(DeserializerOutput {
12824 artifact,
12825 event,
12826 allow_any,
12827 })
12828 }
12829 fn finish(
12830 self,
12831 helper: &mut DeserializeHelper,
12832 ) -> Result<super::SimpleContentContent, Error> {
12833 SimpleContentContentDeserializer::finish_state(helper, *self.state__)
12834 }
12835 }
12836 #[derive(Debug)]
12837 pub struct ComplexContentDeserializer {
12838 id: Option<String>,
12839 mixed: Option<bool>,
12840 content: Vec<super::ComplexContentContent>,
12841 state__: Box<ComplexContentDeserializerState>,
12842 }
12843 #[derive(Debug)]
12844 enum ComplexContentDeserializerState {
12845 Init__,
12846 Next__,
12847 Content__(<super::ComplexContentContent as WithDeserializer>::Deserializer),
12848 Unknown__,
12849 }
12850 impl ComplexContentDeserializer {
12851 fn from_bytes_start(
12852 helper: &mut DeserializeHelper,
12853 bytes_start: &BytesStart<'_>,
12854 ) -> Result<Box<Self>, Error> {
12855 let mut id: Option<String> = None;
12856 let mut mixed: Option<bool> = None;
12857 for attrib in helper.filter_xmlns_attributes(bytes_start) {
12858 let attrib = attrib?;
12859 if matches!(
12860 helper.resolve_local_name(attrib.key, &super::NS_XS),
12861 Some(b"id")
12862 ) {
12863 helper.read_attrib(&mut id, b"id", &attrib.value)?;
12864 } else if matches!(
12865 helper.resolve_local_name(attrib.key, &super::NS_XS),
12866 Some(b"mixed")
12867 ) {
12868 helper.read_attrib(&mut mixed, b"mixed", &attrib.value)?;
12869 }
12870 }
12871 Ok(Box::new(Self {
12872 id: id,
12873 mixed: mixed,
12874 content: Vec::new(),
12875 state__: Box::new(ComplexContentDeserializerState::Init__),
12876 }))
12877 }
12878 fn finish_state(
12879 &mut self,
12880 helper: &mut DeserializeHelper,
12881 state: ComplexContentDeserializerState,
12882 ) -> Result<(), Error> {
12883 if let ComplexContentDeserializerState::Content__(deserializer) = state {
12884 self.store_content(deserializer.finish(helper)?)?;
12885 }
12886 Ok(())
12887 }
12888 fn store_content(&mut self, value: super::ComplexContentContent) -> Result<(), Error> {
12889 self.content.push(value);
12890 Ok(())
12891 }
12892 fn handle_content<'de>(
12893 &mut self,
12894 helper: &mut DeserializeHelper,
12895 output: DeserializerOutput<'de, super::ComplexContentContent>,
12896 fallback: &mut Option<ComplexContentDeserializerState>,
12897 ) -> Result<ElementHandlerOutput<'de>, Error> {
12898 use ComplexContentDeserializerState as S;
12899 let DeserializerOutput {
12900 artifact,
12901 event,
12902 allow_any,
12903 } = output;
12904 if artifact.is_none() {
12905 *self.state__ = fallback.take().unwrap_or(S::Next__);
12906 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
12907 }
12908 if let Some(fallback) = fallback.take() {
12909 self.finish_state(helper, fallback)?;
12910 }
12911 match artifact {
12912 DeserializerArtifact::None => unreachable!(),
12913 DeserializerArtifact::Data(data) => {
12914 self.store_content(data)?;
12915 *self.state__ = S::Next__;
12916 Ok(ElementHandlerOutput::from_event(event, allow_any))
12917 }
12918 DeserializerArtifact::Deserializer(deserializer) => {
12919 if self.content.len() < 1usize {
12920 *fallback = Some(S::Content__(deserializer));
12921 *self.state__ = S::Next__;
12922 Ok(ElementHandlerOutput::from_event(event, allow_any))
12923 } else {
12924 *self.state__ = S::Content__(deserializer);
12925 Ok(ElementHandlerOutput::from_event_end(event, allow_any))
12926 }
12927 }
12928 }
12929 }
12930 }
12931 impl<'de> Deserializer<'de, super::ComplexContent> for Box<ComplexContentDeserializer> {
12932 fn init(
12933 helper: &mut DeserializeHelper,
12934 event: Event<'de>,
12935 ) -> DeserializerResult<'de, super::ComplexContent> {
12936 helper.init_deserializer_from_start_event(
12937 event,
12938 ComplexContentDeserializer::from_bytes_start,
12939 )
12940 }
12941 fn next(
12942 mut self,
12943 helper: &mut DeserializeHelper,
12944 event: Event<'de>,
12945 ) -> DeserializerResult<'de, super::ComplexContent> {
12946 use ComplexContentDeserializerState as S;
12947 let mut event = event;
12948 let mut fallback = None;
12949 let (event, allow_any) = loop {
12950 let state = replace(&mut *self.state__, S::Unknown__);
12951 event = match (state, event) {
12952 (S::Unknown__, _) => unreachable!(),
12953 (S::Content__(deserializer), event) => {
12954 let output = deserializer.next(helper, event)?;
12955 match self.handle_content(helper, output, &mut fallback)? {
12956 ElementHandlerOutput::Break { event, allow_any } => {
12957 break (event, allow_any)
12958 }
12959 ElementHandlerOutput::Continue { event, .. } => event,
12960 }
12961 }
12962 (_, Event::End(_)) => {
12963 return Ok(DeserializerOutput {
12964 artifact: DeserializerArtifact::Data(self.finish(helper)?),
12965 event: DeserializerEvent::None,
12966 allow_any: false,
12967 });
12968 }
12969 (state @ (S::Init__ | S::Next__), event) => {
12970 fallback.get_or_insert(state);
12971 let output = <super::ComplexContentContent as WithDeserializer>::init(
12972 helper, event,
12973 )?;
12974 match self.handle_content(helper, output, &mut fallback)? {
12975 ElementHandlerOutput::Break { event, allow_any } => {
12976 break (event, allow_any)
12977 }
12978 ElementHandlerOutput::Continue { event, .. } => event,
12979 }
12980 }
12981 }
12982 };
12983 if let Some(fallback) = fallback {
12984 *self.state__ = fallback;
12985 }
12986 let artifact = DeserializerArtifact::Deserializer(self);
12987 Ok(DeserializerOutput {
12988 artifact,
12989 event,
12990 allow_any,
12991 })
12992 }
12993 fn finish(
12994 mut self,
12995 helper: &mut DeserializeHelper,
12996 ) -> Result<super::ComplexContent, Error> {
12997 let state = replace(
12998 &mut *self.state__,
12999 ComplexContentDeserializerState::Unknown__,
13000 );
13001 self.finish_state(helper, state)?;
13002 Ok(super::ComplexContent {
13003 id: self.id,
13004 mixed: self.mixed,
13005 content: helper.finish_vec(1usize, Some(2usize), self.content)?,
13006 })
13007 }
13008 }
13009 #[derive(Debug)]
13010 pub struct ComplexContentContentDeserializer {
13011 state__: Box<ComplexContentContentDeserializerState>,
13012 }
13013 #[derive(Debug)]
13014 pub enum ComplexContentContentDeserializerState {
13015 Init__,
13016 Annotation(
13017 Option<super::Annotation>,
13018 Option<<super::Annotation as WithDeserializer>::Deserializer>,
13019 Option<<super::Annotation as WithDeserializer>::Deserializer>,
13020 ),
13021 Restriction(
13022 Option<super::RestrictionType>,
13023 Option<<super::RestrictionType as WithDeserializer>::Deserializer>,
13024 Option<<super::RestrictionType as WithDeserializer>::Deserializer>,
13025 ),
13026 Extension(
13027 Option<super::ExtensionType>,
13028 Option<<super::ExtensionType as WithDeserializer>::Deserializer>,
13029 Option<<super::ExtensionType as WithDeserializer>::Deserializer>,
13030 ),
13031 Done__(super::ComplexContentContent),
13032 Unknown__,
13033 }
13034 impl ComplexContentContentDeserializer {
13035 fn find_suitable<'de>(
13036 &mut self,
13037 helper: &mut DeserializeHelper,
13038 event: Event<'de>,
13039 ) -> Result<ElementHandlerOutput<'de>, Error> {
13040 if let Event::Start(x) | Event::Empty(x) = &event {
13041 if matches!(
13042 helper.resolve_local_name(x.name(), &super::NS_XS),
13043 Some(b"annotation")
13044 ) {
13045 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
13046 return self.handle_annotation(helper, Default::default(), None, output);
13047 }
13048 if matches!(
13049 helper.resolve_local_name(x.name(), &super::NS_XS),
13050 Some(b"restriction")
13051 ) {
13052 let output = <super::RestrictionType as WithDeserializer>::init(helper, event)?;
13053 return self.handle_restriction(helper, Default::default(), None, output);
13054 }
13055 if matches!(
13056 helper.resolve_local_name(x.name(), &super::NS_XS),
13057 Some(b"extension")
13058 ) {
13059 let output = <super::ExtensionType as WithDeserializer>::init(helper, event)?;
13060 return self.handle_extension(helper, Default::default(), None, output);
13061 }
13062 }
13063 *self.state__ = ComplexContentContentDeserializerState::Init__;
13064 Ok(ElementHandlerOutput::return_to_parent(event, false))
13065 }
13066 fn finish_state(
13067 helper: &mut DeserializeHelper,
13068 state: ComplexContentContentDeserializerState,
13069 ) -> Result<super::ComplexContentContent, Error> {
13070 use ComplexContentContentDeserializerState as S;
13071 match state {
13072 S::Init__ => Err(ErrorKind::MissingContent.into()),
13073 S::Annotation(mut values, None, deserializer) => {
13074 if let Some(deserializer) = deserializer {
13075 let value = deserializer.finish(helper)?;
13076 ComplexContentContentDeserializer::store_annotation(&mut values, value)?;
13077 }
13078 Ok(super::ComplexContentContent::Annotation(
13079 helper.finish_element("annotation", values)?,
13080 ))
13081 }
13082 S::Restriction(mut values, None, deserializer) => {
13083 if let Some(deserializer) = deserializer {
13084 let value = deserializer.finish(helper)?;
13085 ComplexContentContentDeserializer::store_restriction(&mut values, value)?;
13086 }
13087 Ok(super::ComplexContentContent::Restriction(
13088 helper.finish_element("restriction", values)?,
13089 ))
13090 }
13091 S::Extension(mut values, None, deserializer) => {
13092 if let Some(deserializer) = deserializer {
13093 let value = deserializer.finish(helper)?;
13094 ComplexContentContentDeserializer::store_extension(&mut values, value)?;
13095 }
13096 Ok(super::ComplexContentContent::Extension(
13097 helper.finish_element("extension", values)?,
13098 ))
13099 }
13100 S::Done__(data) => Ok(data),
13101 _ => unreachable!(),
13102 }
13103 }
13104 fn store_annotation(
13105 values: &mut Option<super::Annotation>,
13106 value: super::Annotation,
13107 ) -> Result<(), Error> {
13108 if values.is_some() {
13109 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
13110 b"annotation",
13111 )))?;
13112 }
13113 *values = Some(value);
13114 Ok(())
13115 }
13116 fn store_restriction(
13117 values: &mut Option<super::RestrictionType>,
13118 value: super::RestrictionType,
13119 ) -> Result<(), Error> {
13120 if values.is_some() {
13121 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
13122 b"restriction",
13123 )))?;
13124 }
13125 *values = Some(value);
13126 Ok(())
13127 }
13128 fn store_extension(
13129 values: &mut Option<super::ExtensionType>,
13130 value: super::ExtensionType,
13131 ) -> Result<(), Error> {
13132 if values.is_some() {
13133 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
13134 b"extension",
13135 )))?;
13136 }
13137 *values = Some(value);
13138 Ok(())
13139 }
13140 fn handle_annotation<'de>(
13141 &mut self,
13142 helper: &mut DeserializeHelper,
13143 mut values: Option<super::Annotation>,
13144 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
13145 output: DeserializerOutput<'de, super::Annotation>,
13146 ) -> Result<ElementHandlerOutput<'de>, Error> {
13147 use ComplexContentContentDeserializerState as S;
13148 let DeserializerOutput {
13149 artifact,
13150 event,
13151 allow_any,
13152 } = output;
13153 if artifact.is_none() {
13154 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
13155 }
13156 if let Some(deserializer) = fallback {
13157 let data = deserializer.finish(helper)?;
13158 ComplexContentContentDeserializer::store_annotation(&mut values, data)?;
13159 }
13160 match artifact {
13161 DeserializerArtifact::None => unreachable!(),
13162 DeserializerArtifact::Data(data) => {
13163 ComplexContentContentDeserializer::store_annotation(&mut values, data)?;
13164 let data = ComplexContentContentDeserializer::finish_state(
13165 helper,
13166 S::Annotation(values, None, None),
13167 )?;
13168 *self.state__ = S::Done__(data);
13169 Ok(ElementHandlerOutput::break_(event, allow_any))
13170 }
13171 DeserializerArtifact::Deserializer(deserializer) => {
13172 *self.state__ = S::Annotation(values, None, Some(deserializer));
13173 Ok(ElementHandlerOutput::break_(event, allow_any))
13174 }
13175 }
13176 }
13177 fn handle_restriction<'de>(
13178 &mut self,
13179 helper: &mut DeserializeHelper,
13180 mut values: Option<super::RestrictionType>,
13181 fallback: Option<<super::RestrictionType as WithDeserializer>::Deserializer>,
13182 output: DeserializerOutput<'de, super::RestrictionType>,
13183 ) -> Result<ElementHandlerOutput<'de>, Error> {
13184 use ComplexContentContentDeserializerState as S;
13185 let DeserializerOutput {
13186 artifact,
13187 event,
13188 allow_any,
13189 } = output;
13190 if artifact.is_none() {
13191 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
13192 }
13193 if let Some(deserializer) = fallback {
13194 let data = deserializer.finish(helper)?;
13195 ComplexContentContentDeserializer::store_restriction(&mut values, data)?;
13196 }
13197 match artifact {
13198 DeserializerArtifact::None => unreachable!(),
13199 DeserializerArtifact::Data(data) => {
13200 ComplexContentContentDeserializer::store_restriction(&mut values, data)?;
13201 let data = ComplexContentContentDeserializer::finish_state(
13202 helper,
13203 S::Restriction(values, None, None),
13204 )?;
13205 *self.state__ = S::Done__(data);
13206 Ok(ElementHandlerOutput::break_(event, allow_any))
13207 }
13208 DeserializerArtifact::Deserializer(deserializer) => {
13209 *self.state__ = S::Restriction(values, None, Some(deserializer));
13210 Ok(ElementHandlerOutput::break_(event, allow_any))
13211 }
13212 }
13213 }
13214 fn handle_extension<'de>(
13215 &mut self,
13216 helper: &mut DeserializeHelper,
13217 mut values: Option<super::ExtensionType>,
13218 fallback: Option<<super::ExtensionType as WithDeserializer>::Deserializer>,
13219 output: DeserializerOutput<'de, super::ExtensionType>,
13220 ) -> Result<ElementHandlerOutput<'de>, Error> {
13221 use ComplexContentContentDeserializerState as S;
13222 let DeserializerOutput {
13223 artifact,
13224 event,
13225 allow_any,
13226 } = output;
13227 if artifact.is_none() {
13228 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
13229 }
13230 if let Some(deserializer) = fallback {
13231 let data = deserializer.finish(helper)?;
13232 ComplexContentContentDeserializer::store_extension(&mut values, data)?;
13233 }
13234 match artifact {
13235 DeserializerArtifact::None => unreachable!(),
13236 DeserializerArtifact::Data(data) => {
13237 ComplexContentContentDeserializer::store_extension(&mut values, data)?;
13238 let data = ComplexContentContentDeserializer::finish_state(
13239 helper,
13240 S::Extension(values, None, None),
13241 )?;
13242 *self.state__ = S::Done__(data);
13243 Ok(ElementHandlerOutput::break_(event, allow_any))
13244 }
13245 DeserializerArtifact::Deserializer(deserializer) => {
13246 *self.state__ = S::Extension(values, None, Some(deserializer));
13247 Ok(ElementHandlerOutput::break_(event, allow_any))
13248 }
13249 }
13250 }
13251 }
13252 impl<'de> Deserializer<'de, super::ComplexContentContent>
13253 for Box<ComplexContentContentDeserializer>
13254 {
13255 fn init(
13256 helper: &mut DeserializeHelper,
13257 event: Event<'de>,
13258 ) -> DeserializerResult<'de, super::ComplexContentContent> {
13259 let deserializer = Box::new(ComplexContentContentDeserializer {
13260 state__: Box::new(ComplexContentContentDeserializerState::Init__),
13261 });
13262 let mut output = deserializer.next(helper, event)?;
13263 output.artifact = match output.artifact {
13264 DeserializerArtifact::Deserializer(x)
13265 if matches!(&*x.state__, ComplexContentContentDeserializerState::Init__) =>
13266 {
13267 DeserializerArtifact::None
13268 }
13269 artifact => artifact,
13270 };
13271 Ok(output)
13272 }
13273 fn next(
13274 mut self,
13275 helper: &mut DeserializeHelper,
13276 event: Event<'de>,
13277 ) -> DeserializerResult<'de, super::ComplexContentContent> {
13278 use ComplexContentContentDeserializerState as S;
13279 let mut event = event;
13280 let (event, allow_any) = loop {
13281 let state = replace(&mut *self.state__, S::Unknown__);
13282 event = match (state, event) {
13283 (S::Unknown__, _) => unreachable!(),
13284 (S::Annotation(values, fallback, Some(deserializer)), event) => {
13285 let output = deserializer.next(helper, event)?;
13286 match self.handle_annotation(helper, values, fallback, output)? {
13287 ElementHandlerOutput::Break { event, allow_any } => {
13288 break (event, allow_any)
13289 }
13290 ElementHandlerOutput::Continue { event, .. } => event,
13291 }
13292 }
13293 (S::Restriction(values, fallback, Some(deserializer)), event) => {
13294 let output = deserializer.next(helper, event)?;
13295 match self.handle_restriction(helper, values, fallback, output)? {
13296 ElementHandlerOutput::Break { event, allow_any } => {
13297 break (event, allow_any)
13298 }
13299 ElementHandlerOutput::Continue { event, .. } => event,
13300 }
13301 }
13302 (S::Extension(values, fallback, Some(deserializer)), event) => {
13303 let output = deserializer.next(helper, event)?;
13304 match self.handle_extension(helper, values, fallback, output)? {
13305 ElementHandlerOutput::Break { event, allow_any } => {
13306 break (event, allow_any)
13307 }
13308 ElementHandlerOutput::Continue { event, .. } => event,
13309 }
13310 }
13311 (state, event @ Event::End(_)) => {
13312 return Ok(DeserializerOutput {
13313 artifact: DeserializerArtifact::Data(
13314 ComplexContentContentDeserializer::finish_state(helper, state)?,
13315 ),
13316 event: DeserializerEvent::Continue(event),
13317 allow_any: false,
13318 });
13319 }
13320 (S::Init__, event) => match self.find_suitable(helper, event)? {
13321 ElementHandlerOutput::Break { event, allow_any } => {
13322 break (event, allow_any)
13323 }
13324 ElementHandlerOutput::Continue { event, .. } => event,
13325 },
13326 (
13327 S::Annotation(values, fallback, None),
13328 event @ (Event::Start(_) | Event::Empty(_)),
13329 ) => {
13330 let output = helper.init_start_tag_deserializer(
13331 event,
13332 Some(&super::NS_XS),
13333 b"annotation",
13334 false,
13335 )?;
13336 match self.handle_annotation(helper, values, fallback, output)? {
13337 ElementHandlerOutput::Break { event, allow_any } => {
13338 break (event, allow_any)
13339 }
13340 ElementHandlerOutput::Continue { event, .. } => event,
13341 }
13342 }
13343 (
13344 S::Restriction(values, fallback, None),
13345 event @ (Event::Start(_) | Event::Empty(_)),
13346 ) => {
13347 let output = helper.init_start_tag_deserializer(
13348 event,
13349 Some(&super::NS_XS),
13350 b"restriction",
13351 true,
13352 )?;
13353 match self.handle_restriction(helper, values, fallback, output)? {
13354 ElementHandlerOutput::Break { event, allow_any } => {
13355 break (event, allow_any)
13356 }
13357 ElementHandlerOutput::Continue { event, .. } => event,
13358 }
13359 }
13360 (
13361 S::Extension(values, fallback, None),
13362 event @ (Event::Start(_) | Event::Empty(_)),
13363 ) => {
13364 let output = helper.init_start_tag_deserializer(
13365 event,
13366 Some(&super::NS_XS),
13367 b"extension",
13368 true,
13369 )?;
13370 match self.handle_extension(helper, values, fallback, output)? {
13371 ElementHandlerOutput::Break { event, allow_any } => {
13372 break (event, allow_any)
13373 }
13374 ElementHandlerOutput::Continue { event, .. } => event,
13375 }
13376 }
13377 (state @ S::Done__(_), event) => {
13378 *self.state__ = state;
13379 break (DeserializerEvent::Continue(event), false);
13380 }
13381 (state, event) => {
13382 *self.state__ = state;
13383 break (DeserializerEvent::Continue(event), false);
13384 }
13385 }
13386 };
13387 let artifact = if matches!(&*self.state__, S::Done__(_)) {
13388 DeserializerArtifact::Data(self.finish(helper)?)
13389 } else {
13390 DeserializerArtifact::Deserializer(self)
13391 };
13392 Ok(DeserializerOutput {
13393 artifact,
13394 event,
13395 allow_any,
13396 })
13397 }
13398 fn finish(
13399 self,
13400 helper: &mut DeserializeHelper,
13401 ) -> Result<super::ComplexContentContent, Error> {
13402 ComplexContentContentDeserializer::finish_state(helper, *self.state__)
13403 }
13404 }
13405 #[derive(Debug)]
13406 pub struct OpenContentDeserializer {
13407 id: Option<String>,
13408 mode: super::OpenContentModeType,
13409 annotation: Option<super::Annotation>,
13410 any: Option<super::WildcardType>,
13411 state__: Box<OpenContentDeserializerState>,
13412 }
13413 #[derive(Debug)]
13414 enum OpenContentDeserializerState {
13415 Init__,
13416 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
13417 Any(Option<<super::WildcardType as WithDeserializer>::Deserializer>),
13418 Done__,
13419 Unknown__,
13420 }
13421 impl OpenContentDeserializer {
13422 fn from_bytes_start(
13423 helper: &mut DeserializeHelper,
13424 bytes_start: &BytesStart<'_>,
13425 ) -> Result<Box<Self>, Error> {
13426 let mut id: Option<String> = None;
13427 let mut mode: Option<super::OpenContentModeType> = None;
13428 for attrib in helper.filter_xmlns_attributes(bytes_start) {
13429 let attrib = attrib?;
13430 if matches!(
13431 helper.resolve_local_name(attrib.key, &super::NS_XS),
13432 Some(b"id")
13433 ) {
13434 helper.read_attrib(&mut id, b"id", &attrib.value)?;
13435 } else if matches!(
13436 helper.resolve_local_name(attrib.key, &super::NS_XS),
13437 Some(b"mode")
13438 ) {
13439 helper.read_attrib(&mut mode, b"mode", &attrib.value)?;
13440 }
13441 }
13442 Ok(Box::new(Self {
13443 id: id,
13444 mode: mode.unwrap_or_else(super::OpenContent::default_mode),
13445 annotation: None,
13446 any: None,
13447 state__: Box::new(OpenContentDeserializerState::Init__),
13448 }))
13449 }
13450 fn finish_state(
13451 &mut self,
13452 helper: &mut DeserializeHelper,
13453 state: OpenContentDeserializerState,
13454 ) -> Result<(), Error> {
13455 use OpenContentDeserializerState as S;
13456 match state {
13457 S::Annotation(Some(deserializer)) => {
13458 self.store_annotation(deserializer.finish(helper)?)?
13459 }
13460 S::Any(Some(deserializer)) => self.store_any(deserializer.finish(helper)?)?,
13461 _ => (),
13462 }
13463 Ok(())
13464 }
13465 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
13466 if self.annotation.is_some() {
13467 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
13468 b"annotation",
13469 )))?;
13470 }
13471 self.annotation = Some(value);
13472 Ok(())
13473 }
13474 fn store_any(&mut self, value: super::WildcardType) -> Result<(), Error> {
13475 if self.any.is_some() {
13476 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"any")))?;
13477 }
13478 self.any = Some(value);
13479 Ok(())
13480 }
13481 fn handle_annotation<'de>(
13482 &mut self,
13483 helper: &mut DeserializeHelper,
13484 output: DeserializerOutput<'de, super::Annotation>,
13485 fallback: &mut Option<OpenContentDeserializerState>,
13486 ) -> Result<ElementHandlerOutput<'de>, Error> {
13487 use OpenContentDeserializerState as S;
13488 let DeserializerOutput {
13489 artifact,
13490 event,
13491 allow_any,
13492 } = output;
13493 if artifact.is_none() {
13494 fallback.get_or_insert(S::Annotation(None));
13495 *self.state__ = S::Any(None);
13496 return Ok(ElementHandlerOutput::from_event(event, allow_any));
13497 }
13498 if let Some(fallback) = fallback.take() {
13499 self.finish_state(helper, fallback)?;
13500 }
13501 match artifact {
13502 DeserializerArtifact::None => unreachable!(),
13503 DeserializerArtifact::Data(data) => {
13504 self.store_annotation(data)?;
13505 *self.state__ = S::Any(None);
13506 Ok(ElementHandlerOutput::from_event(event, allow_any))
13507 }
13508 DeserializerArtifact::Deserializer(deserializer) => {
13509 fallback.get_or_insert(S::Annotation(Some(deserializer)));
13510 *self.state__ = S::Any(None);
13511 Ok(ElementHandlerOutput::from_event(event, allow_any))
13512 }
13513 }
13514 }
13515 fn handle_any<'de>(
13516 &mut self,
13517 helper: &mut DeserializeHelper,
13518 output: DeserializerOutput<'de, super::WildcardType>,
13519 fallback: &mut Option<OpenContentDeserializerState>,
13520 ) -> Result<ElementHandlerOutput<'de>, Error> {
13521 use OpenContentDeserializerState as S;
13522 let DeserializerOutput {
13523 artifact,
13524 event,
13525 allow_any,
13526 } = output;
13527 if artifact.is_none() {
13528 fallback.get_or_insert(S::Any(None));
13529 *self.state__ = S::Done__;
13530 return Ok(ElementHandlerOutput::from_event(event, allow_any));
13531 }
13532 if let Some(fallback) = fallback.take() {
13533 self.finish_state(helper, fallback)?;
13534 }
13535 match artifact {
13536 DeserializerArtifact::None => unreachable!(),
13537 DeserializerArtifact::Data(data) => {
13538 self.store_any(data)?;
13539 *self.state__ = S::Done__;
13540 Ok(ElementHandlerOutput::from_event(event, allow_any))
13541 }
13542 DeserializerArtifact::Deserializer(deserializer) => {
13543 fallback.get_or_insert(S::Any(Some(deserializer)));
13544 *self.state__ = S::Done__;
13545 Ok(ElementHandlerOutput::from_event(event, allow_any))
13546 }
13547 }
13548 }
13549 }
13550 impl<'de> Deserializer<'de, super::OpenContent> for Box<OpenContentDeserializer> {
13551 fn init(
13552 helper: &mut DeserializeHelper,
13553 event: Event<'de>,
13554 ) -> DeserializerResult<'de, super::OpenContent> {
13555 helper.init_deserializer_from_start_event(
13556 event,
13557 OpenContentDeserializer::from_bytes_start,
13558 )
13559 }
13560 fn next(
13561 mut self,
13562 helper: &mut DeserializeHelper,
13563 event: Event<'de>,
13564 ) -> DeserializerResult<'de, super::OpenContent> {
13565 use OpenContentDeserializerState as S;
13566 let mut event = event;
13567 let mut fallback = None;
13568 let mut allow_any_element = false;
13569 let (event, allow_any) = loop {
13570 let state = replace(&mut *self.state__, S::Unknown__);
13571 event = match (state, event) {
13572 (S::Unknown__, _) => unreachable!(),
13573 (S::Annotation(Some(deserializer)), event) => {
13574 let output = deserializer.next(helper, event)?;
13575 match self.handle_annotation(helper, output, &mut fallback)? {
13576 ElementHandlerOutput::Continue { event, allow_any } => {
13577 allow_any_element = allow_any_element || allow_any;
13578 event
13579 }
13580 ElementHandlerOutput::Break { event, allow_any } => {
13581 break (event, allow_any)
13582 }
13583 }
13584 }
13585 (S::Any(Some(deserializer)), event) => {
13586 let output = deserializer.next(helper, event)?;
13587 match self.handle_any(helper, output, &mut fallback)? {
13588 ElementHandlerOutput::Continue { event, allow_any } => {
13589 allow_any_element = allow_any_element || allow_any;
13590 event
13591 }
13592 ElementHandlerOutput::Break { event, allow_any } => {
13593 break (event, allow_any)
13594 }
13595 }
13596 }
13597 (_, Event::End(_)) => {
13598 if let Some(fallback) = fallback.take() {
13599 self.finish_state(helper, fallback)?;
13600 }
13601 return Ok(DeserializerOutput {
13602 artifact: DeserializerArtifact::Data(self.finish(helper)?),
13603 event: DeserializerEvent::None,
13604 allow_any: false,
13605 });
13606 }
13607 (S::Init__, event) => {
13608 fallback.get_or_insert(S::Init__);
13609 *self.state__ = S::Annotation(None);
13610 event
13611 }
13612 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
13613 let output = helper.init_start_tag_deserializer(
13614 event,
13615 Some(&super::NS_XS),
13616 b"annotation",
13617 false,
13618 )?;
13619 match self.handle_annotation(helper, output, &mut fallback)? {
13620 ElementHandlerOutput::Continue { event, allow_any } => {
13621 allow_any_element = allow_any_element || allow_any;
13622 event
13623 }
13624 ElementHandlerOutput::Break { event, allow_any } => {
13625 break (event, allow_any)
13626 }
13627 }
13628 }
13629 (S::Any(None), event @ (Event::Start(_) | Event::Empty(_))) => {
13630 let output = helper.init_start_tag_deserializer(
13631 event,
13632 Some(&super::NS_XS),
13633 b"any",
13634 false,
13635 )?;
13636 match self.handle_any(helper, output, &mut fallback)? {
13637 ElementHandlerOutput::Continue { event, allow_any } => {
13638 allow_any_element = allow_any_element || allow_any;
13639 event
13640 }
13641 ElementHandlerOutput::Break { event, allow_any } => {
13642 break (event, allow_any)
13643 }
13644 }
13645 }
13646 (S::Done__, event) => {
13647 *self.state__ = S::Done__;
13648 break (DeserializerEvent::Continue(event), allow_any_element);
13649 }
13650 (state, event) => {
13651 *self.state__ = state;
13652 break (DeserializerEvent::Break(event), false);
13653 }
13654 }
13655 };
13656 if let Some(fallback) = fallback {
13657 *self.state__ = fallback;
13658 }
13659 Ok(DeserializerOutput {
13660 artifact: DeserializerArtifact::Deserializer(self),
13661 event,
13662 allow_any,
13663 })
13664 }
13665 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::OpenContent, Error> {
13666 let state = replace(&mut *self.state__, OpenContentDeserializerState::Unknown__);
13667 self.finish_state(helper, state)?;
13668 Ok(super::OpenContent {
13669 id: self.id,
13670 mode: self.mode,
13671 annotation: self.annotation,
13672 any: self.any,
13673 })
13674 }
13675 }
13676 #[derive(Debug)]
13677 pub struct AnyAttributeDeserializer {
13678 id: Option<String>,
13679 namespace: Option<super::NamespaceListType>,
13680 not_namespace: Option<super::NotNamespaceType>,
13681 process_contents: super::ProcessContentsType,
13682 not_q_name: Option<super::QnameListAType>,
13683 annotation: Option<super::Annotation>,
13684 state__: Box<AnyAttributeDeserializerState>,
13685 }
13686 #[derive(Debug)]
13687 enum AnyAttributeDeserializerState {
13688 Init__,
13689 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
13690 Done__,
13691 Unknown__,
13692 }
13693 impl AnyAttributeDeserializer {
13694 fn from_bytes_start(
13695 helper: &mut DeserializeHelper,
13696 bytes_start: &BytesStart<'_>,
13697 ) -> Result<Box<Self>, Error> {
13698 let mut id: Option<String> = None;
13699 let mut namespace: Option<super::NamespaceListType> = None;
13700 let mut not_namespace: Option<super::NotNamespaceType> = None;
13701 let mut process_contents: Option<super::ProcessContentsType> = None;
13702 let mut not_q_name: Option<super::QnameListAType> = None;
13703 for attrib in helper.filter_xmlns_attributes(bytes_start) {
13704 let attrib = attrib?;
13705 if matches!(
13706 helper.resolve_local_name(attrib.key, &super::NS_XS),
13707 Some(b"id")
13708 ) {
13709 helper.read_attrib(&mut id, b"id", &attrib.value)?;
13710 } else if matches!(
13711 helper.resolve_local_name(attrib.key, &super::NS_XS),
13712 Some(b"namespace")
13713 ) {
13714 helper.read_attrib(&mut namespace, b"namespace", &attrib.value)?;
13715 } else if matches!(
13716 helper.resolve_local_name(attrib.key, &super::NS_XS),
13717 Some(b"notNamespace")
13718 ) {
13719 helper.read_attrib(&mut not_namespace, b"notNamespace", &attrib.value)?;
13720 } else if matches!(
13721 helper.resolve_local_name(attrib.key, &super::NS_XS),
13722 Some(b"processContents")
13723 ) {
13724 helper.read_attrib(&mut process_contents, b"processContents", &attrib.value)?;
13725 } else if matches!(
13726 helper.resolve_local_name(attrib.key, &super::NS_XS),
13727 Some(b"notQName")
13728 ) {
13729 helper.read_attrib(&mut not_q_name, b"notQName", &attrib.value)?;
13730 }
13731 }
13732 Ok(Box::new(Self {
13733 id: id,
13734 namespace: namespace,
13735 not_namespace: not_namespace,
13736 process_contents: process_contents
13737 .unwrap_or_else(super::AnyAttribute::default_process_contents),
13738 not_q_name: not_q_name,
13739 annotation: None,
13740 state__: Box::new(AnyAttributeDeserializerState::Init__),
13741 }))
13742 }
13743 fn finish_state(
13744 &mut self,
13745 helper: &mut DeserializeHelper,
13746 state: AnyAttributeDeserializerState,
13747 ) -> Result<(), Error> {
13748 use AnyAttributeDeserializerState as S;
13749 match state {
13750 S::Annotation(Some(deserializer)) => {
13751 self.store_annotation(deserializer.finish(helper)?)?
13752 }
13753 _ => (),
13754 }
13755 Ok(())
13756 }
13757 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
13758 if self.annotation.is_some() {
13759 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
13760 b"annotation",
13761 )))?;
13762 }
13763 self.annotation = Some(value);
13764 Ok(())
13765 }
13766 fn handle_annotation<'de>(
13767 &mut self,
13768 helper: &mut DeserializeHelper,
13769 output: DeserializerOutput<'de, super::Annotation>,
13770 fallback: &mut Option<AnyAttributeDeserializerState>,
13771 ) -> Result<ElementHandlerOutput<'de>, Error> {
13772 use AnyAttributeDeserializerState as S;
13773 let DeserializerOutput {
13774 artifact,
13775 event,
13776 allow_any,
13777 } = output;
13778 if artifact.is_none() {
13779 fallback.get_or_insert(S::Annotation(None));
13780 *self.state__ = S::Done__;
13781 return Ok(ElementHandlerOutput::from_event(event, allow_any));
13782 }
13783 if let Some(fallback) = fallback.take() {
13784 self.finish_state(helper, fallback)?;
13785 }
13786 match artifact {
13787 DeserializerArtifact::None => unreachable!(),
13788 DeserializerArtifact::Data(data) => {
13789 self.store_annotation(data)?;
13790 *self.state__ = S::Done__;
13791 Ok(ElementHandlerOutput::from_event(event, allow_any))
13792 }
13793 DeserializerArtifact::Deserializer(deserializer) => {
13794 fallback.get_or_insert(S::Annotation(Some(deserializer)));
13795 *self.state__ = S::Done__;
13796 Ok(ElementHandlerOutput::from_event(event, allow_any))
13797 }
13798 }
13799 }
13800 }
13801 impl<'de> Deserializer<'de, super::AnyAttribute> for Box<AnyAttributeDeserializer> {
13802 fn init(
13803 helper: &mut DeserializeHelper,
13804 event: Event<'de>,
13805 ) -> DeserializerResult<'de, super::AnyAttribute> {
13806 helper.init_deserializer_from_start_event(
13807 event,
13808 AnyAttributeDeserializer::from_bytes_start,
13809 )
13810 }
13811 fn next(
13812 mut self,
13813 helper: &mut DeserializeHelper,
13814 event: Event<'de>,
13815 ) -> DeserializerResult<'de, super::AnyAttribute> {
13816 use AnyAttributeDeserializerState as S;
13817 let mut event = event;
13818 let mut fallback = None;
13819 let mut allow_any_element = false;
13820 let (event, allow_any) = loop {
13821 let state = replace(&mut *self.state__, S::Unknown__);
13822 event = match (state, event) {
13823 (S::Unknown__, _) => unreachable!(),
13824 (S::Annotation(Some(deserializer)), event) => {
13825 let output = deserializer.next(helper, event)?;
13826 match self.handle_annotation(helper, output, &mut fallback)? {
13827 ElementHandlerOutput::Continue { event, allow_any } => {
13828 allow_any_element = allow_any_element || allow_any;
13829 event
13830 }
13831 ElementHandlerOutput::Break { event, allow_any } => {
13832 break (event, allow_any)
13833 }
13834 }
13835 }
13836 (_, Event::End(_)) => {
13837 if let Some(fallback) = fallback.take() {
13838 self.finish_state(helper, fallback)?;
13839 }
13840 return Ok(DeserializerOutput {
13841 artifact: DeserializerArtifact::Data(self.finish(helper)?),
13842 event: DeserializerEvent::None,
13843 allow_any: false,
13844 });
13845 }
13846 (S::Init__, event) => {
13847 fallback.get_or_insert(S::Init__);
13848 *self.state__ = S::Annotation(None);
13849 event
13850 }
13851 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
13852 let output = helper.init_start_tag_deserializer(
13853 event,
13854 Some(&super::NS_XS),
13855 b"annotation",
13856 false,
13857 )?;
13858 match self.handle_annotation(helper, output, &mut fallback)? {
13859 ElementHandlerOutput::Continue { event, allow_any } => {
13860 allow_any_element = allow_any_element || allow_any;
13861 event
13862 }
13863 ElementHandlerOutput::Break { event, allow_any } => {
13864 break (event, allow_any)
13865 }
13866 }
13867 }
13868 (S::Done__, event) => {
13869 *self.state__ = S::Done__;
13870 break (DeserializerEvent::Continue(event), allow_any_element);
13871 }
13872 (state, event) => {
13873 *self.state__ = state;
13874 break (DeserializerEvent::Break(event), false);
13875 }
13876 }
13877 };
13878 if let Some(fallback) = fallback {
13879 *self.state__ = fallback;
13880 }
13881 Ok(DeserializerOutput {
13882 artifact: DeserializerArtifact::Deserializer(self),
13883 event,
13884 allow_any,
13885 })
13886 }
13887 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::AnyAttribute, Error> {
13888 let state = replace(&mut *self.state__, AnyAttributeDeserializerState::Unknown__);
13889 self.finish_state(helper, state)?;
13890 Ok(super::AnyAttribute {
13891 id: self.id,
13892 namespace: self.namespace,
13893 not_namespace: self.not_namespace,
13894 process_contents: self.process_contents,
13895 not_q_name: self.not_q_name,
13896 annotation: self.annotation,
13897 })
13898 }
13899 }
13900 #[derive(Debug)]
13901 pub struct AssertionTypeDeserializer {
13902 id: Option<String>,
13903 test: Option<String>,
13904 xpath_default_namespace: Option<super::XpathDefaultNamespaceType>,
13905 annotation: Option<super::Annotation>,
13906 state__: Box<AssertionTypeDeserializerState>,
13907 }
13908 #[derive(Debug)]
13909 enum AssertionTypeDeserializerState {
13910 Init__,
13911 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
13912 Done__,
13913 Unknown__,
13914 }
13915 impl AssertionTypeDeserializer {
13916 fn from_bytes_start(
13917 helper: &mut DeserializeHelper,
13918 bytes_start: &BytesStart<'_>,
13919 ) -> Result<Box<Self>, Error> {
13920 let mut id: Option<String> = None;
13921 let mut test: Option<String> = None;
13922 let mut xpath_default_namespace: Option<super::XpathDefaultNamespaceType> = None;
13923 for attrib in helper.filter_xmlns_attributes(bytes_start) {
13924 let attrib = attrib?;
13925 if matches!(
13926 helper.resolve_local_name(attrib.key, &super::NS_XS),
13927 Some(b"id")
13928 ) {
13929 helper.read_attrib(&mut id, b"id", &attrib.value)?;
13930 } else if matches!(
13931 helper.resolve_local_name(attrib.key, &super::NS_XS),
13932 Some(b"test")
13933 ) {
13934 helper.read_attrib(&mut test, b"test", &attrib.value)?;
13935 } else if matches!(
13936 helper.resolve_local_name(attrib.key, &super::NS_XS),
13937 Some(b"xpathDefaultNamespace")
13938 ) {
13939 helper.read_attrib(
13940 &mut xpath_default_namespace,
13941 b"xpathDefaultNamespace",
13942 &attrib.value,
13943 )?;
13944 }
13945 }
13946 Ok(Box::new(Self {
13947 id: id,
13948 test: test,
13949 xpath_default_namespace: xpath_default_namespace,
13950 annotation: None,
13951 state__: Box::new(AssertionTypeDeserializerState::Init__),
13952 }))
13953 }
13954 fn finish_state(
13955 &mut self,
13956 helper: &mut DeserializeHelper,
13957 state: AssertionTypeDeserializerState,
13958 ) -> Result<(), Error> {
13959 use AssertionTypeDeserializerState as S;
13960 match state {
13961 S::Annotation(Some(deserializer)) => {
13962 self.store_annotation(deserializer.finish(helper)?)?
13963 }
13964 _ => (),
13965 }
13966 Ok(())
13967 }
13968 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
13969 if self.annotation.is_some() {
13970 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
13971 b"annotation",
13972 )))?;
13973 }
13974 self.annotation = Some(value);
13975 Ok(())
13976 }
13977 fn handle_annotation<'de>(
13978 &mut self,
13979 helper: &mut DeserializeHelper,
13980 output: DeserializerOutput<'de, super::Annotation>,
13981 fallback: &mut Option<AssertionTypeDeserializerState>,
13982 ) -> Result<ElementHandlerOutput<'de>, Error> {
13983 use AssertionTypeDeserializerState as S;
13984 let DeserializerOutput {
13985 artifact,
13986 event,
13987 allow_any,
13988 } = output;
13989 if artifact.is_none() {
13990 fallback.get_or_insert(S::Annotation(None));
13991 *self.state__ = S::Done__;
13992 return Ok(ElementHandlerOutput::from_event(event, allow_any));
13993 }
13994 if let Some(fallback) = fallback.take() {
13995 self.finish_state(helper, fallback)?;
13996 }
13997 match artifact {
13998 DeserializerArtifact::None => unreachable!(),
13999 DeserializerArtifact::Data(data) => {
14000 self.store_annotation(data)?;
14001 *self.state__ = S::Done__;
14002 Ok(ElementHandlerOutput::from_event(event, allow_any))
14003 }
14004 DeserializerArtifact::Deserializer(deserializer) => {
14005 fallback.get_or_insert(S::Annotation(Some(deserializer)));
14006 *self.state__ = S::Done__;
14007 Ok(ElementHandlerOutput::from_event(event, allow_any))
14008 }
14009 }
14010 }
14011 }
14012 impl<'de> Deserializer<'de, super::AssertionType> for Box<AssertionTypeDeserializer> {
14013 fn init(
14014 helper: &mut DeserializeHelper,
14015 event: Event<'de>,
14016 ) -> DeserializerResult<'de, super::AssertionType> {
14017 helper.init_deserializer_from_start_event(
14018 event,
14019 AssertionTypeDeserializer::from_bytes_start,
14020 )
14021 }
14022 fn next(
14023 mut self,
14024 helper: &mut DeserializeHelper,
14025 event: Event<'de>,
14026 ) -> DeserializerResult<'de, super::AssertionType> {
14027 use AssertionTypeDeserializerState as S;
14028 let mut event = event;
14029 let mut fallback = None;
14030 let mut allow_any_element = false;
14031 let (event, allow_any) = loop {
14032 let state = replace(&mut *self.state__, S::Unknown__);
14033 event = match (state, event) {
14034 (S::Unknown__, _) => unreachable!(),
14035 (S::Annotation(Some(deserializer)), event) => {
14036 let output = deserializer.next(helper, event)?;
14037 match self.handle_annotation(helper, output, &mut fallback)? {
14038 ElementHandlerOutput::Continue { event, allow_any } => {
14039 allow_any_element = allow_any_element || allow_any;
14040 event
14041 }
14042 ElementHandlerOutput::Break { event, allow_any } => {
14043 break (event, allow_any)
14044 }
14045 }
14046 }
14047 (_, Event::End(_)) => {
14048 if let Some(fallback) = fallback.take() {
14049 self.finish_state(helper, fallback)?;
14050 }
14051 return Ok(DeserializerOutput {
14052 artifact: DeserializerArtifact::Data(self.finish(helper)?),
14053 event: DeserializerEvent::None,
14054 allow_any: false,
14055 });
14056 }
14057 (S::Init__, event) => {
14058 fallback.get_or_insert(S::Init__);
14059 *self.state__ = S::Annotation(None);
14060 event
14061 }
14062 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
14063 let output = helper.init_start_tag_deserializer(
14064 event,
14065 Some(&super::NS_XS),
14066 b"annotation",
14067 false,
14068 )?;
14069 match self.handle_annotation(helper, output, &mut fallback)? {
14070 ElementHandlerOutput::Continue { event, allow_any } => {
14071 allow_any_element = allow_any_element || allow_any;
14072 event
14073 }
14074 ElementHandlerOutput::Break { event, allow_any } => {
14075 break (event, allow_any)
14076 }
14077 }
14078 }
14079 (S::Done__, event) => {
14080 *self.state__ = S::Done__;
14081 break (DeserializerEvent::Continue(event), allow_any_element);
14082 }
14083 (state, event) => {
14084 *self.state__ = state;
14085 break (DeserializerEvent::Break(event), false);
14086 }
14087 }
14088 };
14089 if let Some(fallback) = fallback {
14090 *self.state__ = fallback;
14091 }
14092 Ok(DeserializerOutput {
14093 artifact: DeserializerArtifact::Deserializer(self),
14094 event,
14095 allow_any,
14096 })
14097 }
14098 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::AssertionType, Error> {
14099 let state = replace(
14100 &mut *self.state__,
14101 AssertionTypeDeserializerState::Unknown__,
14102 );
14103 self.finish_state(helper, state)?;
14104 Ok(super::AssertionType {
14105 id: self.id,
14106 test: self.test,
14107 xpath_default_namespace: self.xpath_default_namespace,
14108 annotation: self.annotation,
14109 })
14110 }
14111 }
14112 #[derive(Debug)]
14113 pub struct AnyDeserializer {
14114 id: Option<String>,
14115 namespace: Option<super::NamespaceListType>,
14116 not_namespace: Option<super::NotNamespaceType>,
14117 process_contents: super::ProcessContentsType,
14118 not_q_name: Option<super::QnameListType>,
14119 min_occurs: usize,
14120 max_occurs: MaxOccurs,
14121 annotation: Option<super::Annotation>,
14122 state__: Box<AnyDeserializerState>,
14123 }
14124 #[derive(Debug)]
14125 enum AnyDeserializerState {
14126 Init__,
14127 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
14128 Done__,
14129 Unknown__,
14130 }
14131 impl AnyDeserializer {
14132 fn from_bytes_start(
14133 helper: &mut DeserializeHelper,
14134 bytes_start: &BytesStart<'_>,
14135 ) -> Result<Box<Self>, Error> {
14136 let mut id: Option<String> = None;
14137 let mut namespace: Option<super::NamespaceListType> = None;
14138 let mut not_namespace: Option<super::NotNamespaceType> = None;
14139 let mut process_contents: Option<super::ProcessContentsType> = None;
14140 let mut not_q_name: Option<super::QnameListType> = None;
14141 let mut min_occurs: Option<usize> = None;
14142 let mut max_occurs: Option<MaxOccurs> = None;
14143 for attrib in helper.filter_xmlns_attributes(bytes_start) {
14144 let attrib = attrib?;
14145 if matches!(
14146 helper.resolve_local_name(attrib.key, &super::NS_XS),
14147 Some(b"id")
14148 ) {
14149 helper.read_attrib(&mut id, b"id", &attrib.value)?;
14150 } else if matches!(
14151 helper.resolve_local_name(attrib.key, &super::NS_XS),
14152 Some(b"namespace")
14153 ) {
14154 helper.read_attrib(&mut namespace, b"namespace", &attrib.value)?;
14155 } else if matches!(
14156 helper.resolve_local_name(attrib.key, &super::NS_XS),
14157 Some(b"notNamespace")
14158 ) {
14159 helper.read_attrib(&mut not_namespace, b"notNamespace", &attrib.value)?;
14160 } else if matches!(
14161 helper.resolve_local_name(attrib.key, &super::NS_XS),
14162 Some(b"processContents")
14163 ) {
14164 helper.read_attrib(&mut process_contents, b"processContents", &attrib.value)?;
14165 } else if matches!(
14166 helper.resolve_local_name(attrib.key, &super::NS_XS),
14167 Some(b"notQName")
14168 ) {
14169 helper.read_attrib(&mut not_q_name, b"notQName", &attrib.value)?;
14170 } else if matches!(
14171 helper.resolve_local_name(attrib.key, &super::NS_XS),
14172 Some(b"minOccurs")
14173 ) {
14174 helper.read_attrib(&mut min_occurs, b"minOccurs", &attrib.value)?;
14175 } else if matches!(
14176 helper.resolve_local_name(attrib.key, &super::NS_XS),
14177 Some(b"maxOccurs")
14178 ) {
14179 helper.read_attrib(&mut max_occurs, b"maxOccurs", &attrib.value)?;
14180 }
14181 }
14182 Ok(Box::new(Self {
14183 id: id,
14184 namespace: namespace,
14185 not_namespace: not_namespace,
14186 process_contents: process_contents
14187 .unwrap_or_else(super::Any::default_process_contents),
14188 not_q_name: not_q_name,
14189 min_occurs: min_occurs.unwrap_or_else(super::Any::default_min_occurs),
14190 max_occurs: max_occurs.unwrap_or_else(super::Any::default_max_occurs),
14191 annotation: None,
14192 state__: Box::new(AnyDeserializerState::Init__),
14193 }))
14194 }
14195 fn finish_state(
14196 &mut self,
14197 helper: &mut DeserializeHelper,
14198 state: AnyDeserializerState,
14199 ) -> Result<(), Error> {
14200 use AnyDeserializerState as S;
14201 match state {
14202 S::Annotation(Some(deserializer)) => {
14203 self.store_annotation(deserializer.finish(helper)?)?
14204 }
14205 _ => (),
14206 }
14207 Ok(())
14208 }
14209 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
14210 if self.annotation.is_some() {
14211 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
14212 b"annotation",
14213 )))?;
14214 }
14215 self.annotation = Some(value);
14216 Ok(())
14217 }
14218 fn handle_annotation<'de>(
14219 &mut self,
14220 helper: &mut DeserializeHelper,
14221 output: DeserializerOutput<'de, super::Annotation>,
14222 fallback: &mut Option<AnyDeserializerState>,
14223 ) -> Result<ElementHandlerOutput<'de>, Error> {
14224 use AnyDeserializerState as S;
14225 let DeserializerOutput {
14226 artifact,
14227 event,
14228 allow_any,
14229 } = output;
14230 if artifact.is_none() {
14231 fallback.get_or_insert(S::Annotation(None));
14232 *self.state__ = S::Done__;
14233 return Ok(ElementHandlerOutput::from_event(event, allow_any));
14234 }
14235 if let Some(fallback) = fallback.take() {
14236 self.finish_state(helper, fallback)?;
14237 }
14238 match artifact {
14239 DeserializerArtifact::None => unreachable!(),
14240 DeserializerArtifact::Data(data) => {
14241 self.store_annotation(data)?;
14242 *self.state__ = S::Done__;
14243 Ok(ElementHandlerOutput::from_event(event, allow_any))
14244 }
14245 DeserializerArtifact::Deserializer(deserializer) => {
14246 fallback.get_or_insert(S::Annotation(Some(deserializer)));
14247 *self.state__ = S::Done__;
14248 Ok(ElementHandlerOutput::from_event(event, allow_any))
14249 }
14250 }
14251 }
14252 }
14253 impl<'de> Deserializer<'de, super::Any> for Box<AnyDeserializer> {
14254 fn init(
14255 helper: &mut DeserializeHelper,
14256 event: Event<'de>,
14257 ) -> DeserializerResult<'de, super::Any> {
14258 helper.init_deserializer_from_start_event(event, AnyDeserializer::from_bytes_start)
14259 }
14260 fn next(
14261 mut self,
14262 helper: &mut DeserializeHelper,
14263 event: Event<'de>,
14264 ) -> DeserializerResult<'de, super::Any> {
14265 use AnyDeserializerState as S;
14266 let mut event = event;
14267 let mut fallback = None;
14268 let mut allow_any_element = false;
14269 let (event, allow_any) = loop {
14270 let state = replace(&mut *self.state__, S::Unknown__);
14271 event = match (state, event) {
14272 (S::Unknown__, _) => unreachable!(),
14273 (S::Annotation(Some(deserializer)), event) => {
14274 let output = deserializer.next(helper, event)?;
14275 match self.handle_annotation(helper, output, &mut fallback)? {
14276 ElementHandlerOutput::Continue { event, allow_any } => {
14277 allow_any_element = allow_any_element || allow_any;
14278 event
14279 }
14280 ElementHandlerOutput::Break { event, allow_any } => {
14281 break (event, allow_any)
14282 }
14283 }
14284 }
14285 (_, Event::End(_)) => {
14286 if let Some(fallback) = fallback.take() {
14287 self.finish_state(helper, fallback)?;
14288 }
14289 return Ok(DeserializerOutput {
14290 artifact: DeserializerArtifact::Data(self.finish(helper)?),
14291 event: DeserializerEvent::None,
14292 allow_any: false,
14293 });
14294 }
14295 (S::Init__, event) => {
14296 fallback.get_or_insert(S::Init__);
14297 *self.state__ = S::Annotation(None);
14298 event
14299 }
14300 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
14301 let output = helper.init_start_tag_deserializer(
14302 event,
14303 Some(&super::NS_XS),
14304 b"annotation",
14305 false,
14306 )?;
14307 match self.handle_annotation(helper, output, &mut fallback)? {
14308 ElementHandlerOutput::Continue { event, allow_any } => {
14309 allow_any_element = allow_any_element || allow_any;
14310 event
14311 }
14312 ElementHandlerOutput::Break { event, allow_any } => {
14313 break (event, allow_any)
14314 }
14315 }
14316 }
14317 (S::Done__, event) => {
14318 *self.state__ = S::Done__;
14319 break (DeserializerEvent::Continue(event), allow_any_element);
14320 }
14321 (state, event) => {
14322 *self.state__ = state;
14323 break (DeserializerEvent::Break(event), false);
14324 }
14325 }
14326 };
14327 if let Some(fallback) = fallback {
14328 *self.state__ = fallback;
14329 }
14330 Ok(DeserializerOutput {
14331 artifact: DeserializerArtifact::Deserializer(self),
14332 event,
14333 allow_any,
14334 })
14335 }
14336 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Any, Error> {
14337 let state = replace(&mut *self.state__, AnyDeserializerState::Unknown__);
14338 self.finish_state(helper, state)?;
14339 Ok(super::Any {
14340 id: self.id,
14341 namespace: self.namespace,
14342 not_namespace: self.not_namespace,
14343 process_contents: self.process_contents,
14344 not_q_name: self.not_q_name,
14345 min_occurs: self.min_occurs,
14346 max_occurs: self.max_occurs,
14347 annotation: self.annotation,
14348 })
14349 }
14350 }
14351 #[derive(Debug)]
14352 pub struct AltTypeDeserializer {
14353 id: Option<String>,
14354 test: Option<String>,
14355 type_: Option<QName>,
14356 xpath_default_namespace: Option<super::XpathDefaultNamespaceType>,
14357 content: Vec<super::AltTypeContent>,
14358 state__: Box<AltTypeDeserializerState>,
14359 }
14360 #[derive(Debug)]
14361 enum AltTypeDeserializerState {
14362 Init__,
14363 Next__,
14364 Content__(<super::AltTypeContent as WithDeserializer>::Deserializer),
14365 Unknown__,
14366 }
14367 impl AltTypeDeserializer {
14368 fn from_bytes_start(
14369 helper: &mut DeserializeHelper,
14370 bytes_start: &BytesStart<'_>,
14371 ) -> Result<Box<Self>, Error> {
14372 let mut id: Option<String> = None;
14373 let mut test: Option<String> = None;
14374 let mut type_: Option<QName> = None;
14375 let mut xpath_default_namespace: Option<super::XpathDefaultNamespaceType> = None;
14376 for attrib in helper.filter_xmlns_attributes(bytes_start) {
14377 let attrib = attrib?;
14378 if matches!(
14379 helper.resolve_local_name(attrib.key, &super::NS_XS),
14380 Some(b"id")
14381 ) {
14382 helper.read_attrib(&mut id, b"id", &attrib.value)?;
14383 } else if matches!(
14384 helper.resolve_local_name(attrib.key, &super::NS_XS),
14385 Some(b"test")
14386 ) {
14387 helper.read_attrib(&mut test, b"test", &attrib.value)?;
14388 } else if matches!(
14389 helper.resolve_local_name(attrib.key, &super::NS_XS),
14390 Some(b"type")
14391 ) {
14392 helper.read_attrib(&mut type_, b"type", &attrib.value)?;
14393 } else if matches!(
14394 helper.resolve_local_name(attrib.key, &super::NS_XS),
14395 Some(b"xpathDefaultNamespace")
14396 ) {
14397 helper.read_attrib(
14398 &mut xpath_default_namespace,
14399 b"xpathDefaultNamespace",
14400 &attrib.value,
14401 )?;
14402 }
14403 }
14404 Ok(Box::new(Self {
14405 id: id,
14406 test: test,
14407 type_: type_,
14408 xpath_default_namespace: xpath_default_namespace,
14409 content: Vec::new(),
14410 state__: Box::new(AltTypeDeserializerState::Init__),
14411 }))
14412 }
14413 fn finish_state(
14414 &mut self,
14415 helper: &mut DeserializeHelper,
14416 state: AltTypeDeserializerState,
14417 ) -> Result<(), Error> {
14418 if let AltTypeDeserializerState::Content__(deserializer) = state {
14419 self.store_content(deserializer.finish(helper)?)?;
14420 }
14421 Ok(())
14422 }
14423 fn store_content(&mut self, value: super::AltTypeContent) -> Result<(), Error> {
14424 self.content.push(value);
14425 Ok(())
14426 }
14427 fn handle_content<'de>(
14428 &mut self,
14429 helper: &mut DeserializeHelper,
14430 output: DeserializerOutput<'de, super::AltTypeContent>,
14431 fallback: &mut Option<AltTypeDeserializerState>,
14432 ) -> Result<ElementHandlerOutput<'de>, Error> {
14433 use AltTypeDeserializerState as S;
14434 let DeserializerOutput {
14435 artifact,
14436 event,
14437 allow_any,
14438 } = output;
14439 if artifact.is_none() {
14440 *self.state__ = fallback.take().unwrap_or(S::Next__);
14441 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
14442 }
14443 if let Some(fallback) = fallback.take() {
14444 self.finish_state(helper, fallback)?;
14445 }
14446 match artifact {
14447 DeserializerArtifact::None => unreachable!(),
14448 DeserializerArtifact::Data(data) => {
14449 self.store_content(data)?;
14450 *self.state__ = S::Next__;
14451 Ok(ElementHandlerOutput::from_event(event, allow_any))
14452 }
14453 DeserializerArtifact::Deserializer(deserializer) => {
14454 if self.content.len() < 1usize {
14455 *fallback = Some(S::Content__(deserializer));
14456 *self.state__ = S::Next__;
14457 Ok(ElementHandlerOutput::from_event(event, allow_any))
14458 } else {
14459 *self.state__ = S::Content__(deserializer);
14460 Ok(ElementHandlerOutput::from_event_end(event, allow_any))
14461 }
14462 }
14463 }
14464 }
14465 }
14466 impl<'de> Deserializer<'de, super::AltType> for Box<AltTypeDeserializer> {
14467 fn init(
14468 helper: &mut DeserializeHelper,
14469 event: Event<'de>,
14470 ) -> DeserializerResult<'de, super::AltType> {
14471 helper.init_deserializer_from_start_event(event, AltTypeDeserializer::from_bytes_start)
14472 }
14473 fn next(
14474 mut self,
14475 helper: &mut DeserializeHelper,
14476 event: Event<'de>,
14477 ) -> DeserializerResult<'de, super::AltType> {
14478 use AltTypeDeserializerState as S;
14479 let mut event = event;
14480 let mut fallback = None;
14481 let (event, allow_any) = loop {
14482 let state = replace(&mut *self.state__, S::Unknown__);
14483 event = match (state, event) {
14484 (S::Unknown__, _) => unreachable!(),
14485 (S::Content__(deserializer), event) => {
14486 let output = deserializer.next(helper, event)?;
14487 match self.handle_content(helper, output, &mut fallback)? {
14488 ElementHandlerOutput::Break { event, allow_any } => {
14489 break (event, allow_any)
14490 }
14491 ElementHandlerOutput::Continue { event, .. } => event,
14492 }
14493 }
14494 (_, Event::End(_)) => {
14495 return Ok(DeserializerOutput {
14496 artifact: DeserializerArtifact::Data(self.finish(helper)?),
14497 event: DeserializerEvent::None,
14498 allow_any: false,
14499 });
14500 }
14501 (state @ (S::Init__ | S::Next__), event) => {
14502 fallback.get_or_insert(state);
14503 let output =
14504 <super::AltTypeContent as WithDeserializer>::init(helper, event)?;
14505 match self.handle_content(helper, output, &mut fallback)? {
14506 ElementHandlerOutput::Break { event, allow_any } => {
14507 break (event, allow_any)
14508 }
14509 ElementHandlerOutput::Continue { event, .. } => event,
14510 }
14511 }
14512 }
14513 };
14514 if let Some(fallback) = fallback {
14515 *self.state__ = fallback;
14516 }
14517 let artifact = DeserializerArtifact::Deserializer(self);
14518 Ok(DeserializerOutput {
14519 artifact,
14520 event,
14521 allow_any,
14522 })
14523 }
14524 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::AltType, Error> {
14525 let state = replace(&mut *self.state__, AltTypeDeserializerState::Unknown__);
14526 self.finish_state(helper, state)?;
14527 Ok(super::AltType {
14528 id: self.id,
14529 test: self.test,
14530 type_: self.type_,
14531 xpath_default_namespace: self.xpath_default_namespace,
14532 content: helper.finish_vec(0usize, Some(2usize), self.content)?,
14533 })
14534 }
14535 }
14536 #[derive(Debug)]
14537 pub struct AltTypeContentDeserializer {
14538 state__: Box<AltTypeContentDeserializerState>,
14539 }
14540 #[derive(Debug)]
14541 pub enum AltTypeContentDeserializerState {
14542 Init__,
14543 Annotation(
14544 Option<super::Annotation>,
14545 Option<<super::Annotation as WithDeserializer>::Deserializer>,
14546 Option<<super::Annotation as WithDeserializer>::Deserializer>,
14547 ),
14548 SimpleType(
14549 Option<super::SimpleBaseType>,
14550 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
14551 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
14552 ),
14553 ComplexType(
14554 Option<super::ComplexBaseType>,
14555 Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
14556 Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
14557 ),
14558 Done__(super::AltTypeContent),
14559 Unknown__,
14560 }
14561 impl AltTypeContentDeserializer {
14562 fn find_suitable<'de>(
14563 &mut self,
14564 helper: &mut DeserializeHelper,
14565 event: Event<'de>,
14566 ) -> Result<ElementHandlerOutput<'de>, Error> {
14567 if let Event::Start(x) | Event::Empty(x) = &event {
14568 if matches!(
14569 helper.resolve_local_name(x.name(), &super::NS_XS),
14570 Some(b"annotation")
14571 ) {
14572 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
14573 return self.handle_annotation(helper, Default::default(), None, output);
14574 }
14575 if matches!(
14576 helper.resolve_local_name(x.name(), &super::NS_XS),
14577 Some(b"simpleType")
14578 ) {
14579 let output = <super::SimpleBaseType as WithDeserializer>::init(helper, event)?;
14580 return self.handle_simple_type(helper, Default::default(), None, output);
14581 }
14582 if matches!(
14583 helper.resolve_local_name(x.name(), &super::NS_XS),
14584 Some(b"complexType")
14585 ) {
14586 let output = <super::ComplexBaseType as WithDeserializer>::init(helper, event)?;
14587 return self.handle_complex_type(helper, Default::default(), None, output);
14588 }
14589 }
14590 *self.state__ = AltTypeContentDeserializerState::Init__;
14591 Ok(ElementHandlerOutput::return_to_parent(event, false))
14592 }
14593 fn finish_state(
14594 helper: &mut DeserializeHelper,
14595 state: AltTypeContentDeserializerState,
14596 ) -> Result<super::AltTypeContent, Error> {
14597 use AltTypeContentDeserializerState as S;
14598 match state {
14599 S::Init__ => Err(ErrorKind::MissingContent.into()),
14600 S::Annotation(mut values, None, deserializer) => {
14601 if let Some(deserializer) = deserializer {
14602 let value = deserializer.finish(helper)?;
14603 AltTypeContentDeserializer::store_annotation(&mut values, value)?;
14604 }
14605 Ok(super::AltTypeContent::Annotation(
14606 helper.finish_element("annotation", values)?,
14607 ))
14608 }
14609 S::SimpleType(mut values, None, deserializer) => {
14610 if let Some(deserializer) = deserializer {
14611 let value = deserializer.finish(helper)?;
14612 AltTypeContentDeserializer::store_simple_type(&mut values, value)?;
14613 }
14614 Ok(super::AltTypeContent::SimpleType(
14615 helper.finish_element("simpleType", values)?,
14616 ))
14617 }
14618 S::ComplexType(mut values, None, deserializer) => {
14619 if let Some(deserializer) = deserializer {
14620 let value = deserializer.finish(helper)?;
14621 AltTypeContentDeserializer::store_complex_type(&mut values, value)?;
14622 }
14623 Ok(super::AltTypeContent::ComplexType(
14624 helper.finish_element("complexType", values)?,
14625 ))
14626 }
14627 S::Done__(data) => Ok(data),
14628 _ => unreachable!(),
14629 }
14630 }
14631 fn store_annotation(
14632 values: &mut Option<super::Annotation>,
14633 value: super::Annotation,
14634 ) -> Result<(), Error> {
14635 if values.is_some() {
14636 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
14637 b"annotation",
14638 )))?;
14639 }
14640 *values = Some(value);
14641 Ok(())
14642 }
14643 fn store_simple_type(
14644 values: &mut Option<super::SimpleBaseType>,
14645 value: super::SimpleBaseType,
14646 ) -> Result<(), Error> {
14647 if values.is_some() {
14648 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
14649 b"simpleType",
14650 )))?;
14651 }
14652 *values = Some(value);
14653 Ok(())
14654 }
14655 fn store_complex_type(
14656 values: &mut Option<super::ComplexBaseType>,
14657 value: super::ComplexBaseType,
14658 ) -> Result<(), Error> {
14659 if values.is_some() {
14660 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
14661 b"complexType",
14662 )))?;
14663 }
14664 *values = Some(value);
14665 Ok(())
14666 }
14667 fn handle_annotation<'de>(
14668 &mut self,
14669 helper: &mut DeserializeHelper,
14670 mut values: Option<super::Annotation>,
14671 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
14672 output: DeserializerOutput<'de, super::Annotation>,
14673 ) -> Result<ElementHandlerOutput<'de>, Error> {
14674 use AltTypeContentDeserializerState as S;
14675 let DeserializerOutput {
14676 artifact,
14677 event,
14678 allow_any,
14679 } = output;
14680 if artifact.is_none() {
14681 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
14682 }
14683 if let Some(deserializer) = fallback {
14684 let data = deserializer.finish(helper)?;
14685 AltTypeContentDeserializer::store_annotation(&mut values, data)?;
14686 }
14687 match artifact {
14688 DeserializerArtifact::None => unreachable!(),
14689 DeserializerArtifact::Data(data) => {
14690 AltTypeContentDeserializer::store_annotation(&mut values, data)?;
14691 let data = AltTypeContentDeserializer::finish_state(
14692 helper,
14693 S::Annotation(values, None, None),
14694 )?;
14695 *self.state__ = S::Done__(data);
14696 Ok(ElementHandlerOutput::break_(event, allow_any))
14697 }
14698 DeserializerArtifact::Deserializer(deserializer) => {
14699 *self.state__ = S::Annotation(values, None, Some(deserializer));
14700 Ok(ElementHandlerOutput::break_(event, allow_any))
14701 }
14702 }
14703 }
14704 fn handle_simple_type<'de>(
14705 &mut self,
14706 helper: &mut DeserializeHelper,
14707 mut values: Option<super::SimpleBaseType>,
14708 fallback: Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
14709 output: DeserializerOutput<'de, super::SimpleBaseType>,
14710 ) -> Result<ElementHandlerOutput<'de>, Error> {
14711 use AltTypeContentDeserializerState as S;
14712 let DeserializerOutput {
14713 artifact,
14714 event,
14715 allow_any,
14716 } = output;
14717 if artifact.is_none() {
14718 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
14719 }
14720 if let Some(deserializer) = fallback {
14721 let data = deserializer.finish(helper)?;
14722 AltTypeContentDeserializer::store_simple_type(&mut values, data)?;
14723 }
14724 match artifact {
14725 DeserializerArtifact::None => unreachable!(),
14726 DeserializerArtifact::Data(data) => {
14727 AltTypeContentDeserializer::store_simple_type(&mut values, data)?;
14728 let data = AltTypeContentDeserializer::finish_state(
14729 helper,
14730 S::SimpleType(values, None, None),
14731 )?;
14732 *self.state__ = S::Done__(data);
14733 Ok(ElementHandlerOutput::break_(event, allow_any))
14734 }
14735 DeserializerArtifact::Deserializer(deserializer) => {
14736 *self.state__ = S::SimpleType(values, None, Some(deserializer));
14737 Ok(ElementHandlerOutput::break_(event, allow_any))
14738 }
14739 }
14740 }
14741 fn handle_complex_type<'de>(
14742 &mut self,
14743 helper: &mut DeserializeHelper,
14744 mut values: Option<super::ComplexBaseType>,
14745 fallback: Option<<super::ComplexBaseType as WithDeserializer>::Deserializer>,
14746 output: DeserializerOutput<'de, super::ComplexBaseType>,
14747 ) -> Result<ElementHandlerOutput<'de>, Error> {
14748 use AltTypeContentDeserializerState as S;
14749 let DeserializerOutput {
14750 artifact,
14751 event,
14752 allow_any,
14753 } = output;
14754 if artifact.is_none() {
14755 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
14756 }
14757 if let Some(deserializer) = fallback {
14758 let data = deserializer.finish(helper)?;
14759 AltTypeContentDeserializer::store_complex_type(&mut values, data)?;
14760 }
14761 match artifact {
14762 DeserializerArtifact::None => unreachable!(),
14763 DeserializerArtifact::Data(data) => {
14764 AltTypeContentDeserializer::store_complex_type(&mut values, data)?;
14765 let data = AltTypeContentDeserializer::finish_state(
14766 helper,
14767 S::ComplexType(values, None, None),
14768 )?;
14769 *self.state__ = S::Done__(data);
14770 Ok(ElementHandlerOutput::break_(event, allow_any))
14771 }
14772 DeserializerArtifact::Deserializer(deserializer) => {
14773 *self.state__ = S::ComplexType(values, None, Some(deserializer));
14774 Ok(ElementHandlerOutput::break_(event, allow_any))
14775 }
14776 }
14777 }
14778 }
14779 impl<'de> Deserializer<'de, super::AltTypeContent> for Box<AltTypeContentDeserializer> {
14780 fn init(
14781 helper: &mut DeserializeHelper,
14782 event: Event<'de>,
14783 ) -> DeserializerResult<'de, super::AltTypeContent> {
14784 let deserializer = Box::new(AltTypeContentDeserializer {
14785 state__: Box::new(AltTypeContentDeserializerState::Init__),
14786 });
14787 let mut output = deserializer.next(helper, event)?;
14788 output.artifact = match output.artifact {
14789 DeserializerArtifact::Deserializer(x)
14790 if matches!(&*x.state__, AltTypeContentDeserializerState::Init__) =>
14791 {
14792 DeserializerArtifact::None
14793 }
14794 artifact => artifact,
14795 };
14796 Ok(output)
14797 }
14798 fn next(
14799 mut self,
14800 helper: &mut DeserializeHelper,
14801 event: Event<'de>,
14802 ) -> DeserializerResult<'de, super::AltTypeContent> {
14803 use AltTypeContentDeserializerState as S;
14804 let mut event = event;
14805 let (event, allow_any) = loop {
14806 let state = replace(&mut *self.state__, S::Unknown__);
14807 event = match (state, event) {
14808 (S::Unknown__, _) => unreachable!(),
14809 (S::Annotation(values, fallback, Some(deserializer)), event) => {
14810 let output = deserializer.next(helper, event)?;
14811 match self.handle_annotation(helper, values, fallback, output)? {
14812 ElementHandlerOutput::Break { event, allow_any } => {
14813 break (event, allow_any)
14814 }
14815 ElementHandlerOutput::Continue { event, .. } => event,
14816 }
14817 }
14818 (S::SimpleType(values, fallback, Some(deserializer)), event) => {
14819 let output = deserializer.next(helper, event)?;
14820 match self.handle_simple_type(helper, values, fallback, output)? {
14821 ElementHandlerOutput::Break { event, allow_any } => {
14822 break (event, allow_any)
14823 }
14824 ElementHandlerOutput::Continue { event, .. } => event,
14825 }
14826 }
14827 (S::ComplexType(values, fallback, Some(deserializer)), event) => {
14828 let output = deserializer.next(helper, event)?;
14829 match self.handle_complex_type(helper, values, fallback, output)? {
14830 ElementHandlerOutput::Break { event, allow_any } => {
14831 break (event, allow_any)
14832 }
14833 ElementHandlerOutput::Continue { event, .. } => event,
14834 }
14835 }
14836 (state, event @ Event::End(_)) => {
14837 return Ok(DeserializerOutput {
14838 artifact: DeserializerArtifact::Data(
14839 AltTypeContentDeserializer::finish_state(helper, state)?,
14840 ),
14841 event: DeserializerEvent::Continue(event),
14842 allow_any: false,
14843 });
14844 }
14845 (S::Init__, event) => match self.find_suitable(helper, event)? {
14846 ElementHandlerOutput::Break { event, allow_any } => {
14847 break (event, allow_any)
14848 }
14849 ElementHandlerOutput::Continue { event, .. } => event,
14850 },
14851 (
14852 S::Annotation(values, fallback, None),
14853 event @ (Event::Start(_) | Event::Empty(_)),
14854 ) => {
14855 let output = helper.init_start_tag_deserializer(
14856 event,
14857 Some(&super::NS_XS),
14858 b"annotation",
14859 false,
14860 )?;
14861 match self.handle_annotation(helper, values, fallback, output)? {
14862 ElementHandlerOutput::Break { event, allow_any } => {
14863 break (event, allow_any)
14864 }
14865 ElementHandlerOutput::Continue { event, .. } => event,
14866 }
14867 }
14868 (
14869 S::SimpleType(values, fallback, None),
14870 event @ (Event::Start(_) | Event::Empty(_)),
14871 ) => {
14872 let output = helper.init_start_tag_deserializer(
14873 event,
14874 Some(&super::NS_XS),
14875 b"simpleType",
14876 true,
14877 )?;
14878 match self.handle_simple_type(helper, values, fallback, output)? {
14879 ElementHandlerOutput::Break { event, allow_any } => {
14880 break (event, allow_any)
14881 }
14882 ElementHandlerOutput::Continue { event, .. } => event,
14883 }
14884 }
14885 (
14886 S::ComplexType(values, fallback, None),
14887 event @ (Event::Start(_) | Event::Empty(_)),
14888 ) => {
14889 let output = helper.init_start_tag_deserializer(
14890 event,
14891 Some(&super::NS_XS),
14892 b"complexType",
14893 true,
14894 )?;
14895 match self.handle_complex_type(helper, values, fallback, output)? {
14896 ElementHandlerOutput::Break { event, allow_any } => {
14897 break (event, allow_any)
14898 }
14899 ElementHandlerOutput::Continue { event, .. } => event,
14900 }
14901 }
14902 (state @ S::Done__(_), event) => {
14903 *self.state__ = state;
14904 break (DeserializerEvent::Continue(event), false);
14905 }
14906 (state, event) => {
14907 *self.state__ = state;
14908 break (DeserializerEvent::Continue(event), false);
14909 }
14910 }
14911 };
14912 let artifact = if matches!(&*self.state__, S::Done__(_)) {
14913 DeserializerArtifact::Data(self.finish(helper)?)
14914 } else {
14915 DeserializerArtifact::Deserializer(self)
14916 };
14917 Ok(DeserializerOutput {
14918 artifact,
14919 event,
14920 allow_any,
14921 })
14922 }
14923 fn finish(self, helper: &mut DeserializeHelper) -> Result<super::AltTypeContent, Error> {
14924 AltTypeContentDeserializer::finish_state(helper, *self.state__)
14925 }
14926 }
14927 #[derive(Debug)]
14928 pub struct KeybaseTypeDeserializer {
14929 id: Option<String>,
14930 name: Option<String>,
14931 ref_: Option<QName>,
14932 content: Option<super::KeybaseTypeContent>,
14933 state__: Box<KeybaseTypeDeserializerState>,
14934 }
14935 #[derive(Debug)]
14936 enum KeybaseTypeDeserializerState {
14937 Init__,
14938 Next__,
14939 Content__(<super::KeybaseTypeContent as WithDeserializer>::Deserializer),
14940 Unknown__,
14941 }
14942 impl KeybaseTypeDeserializer {
14943 fn from_bytes_start(
14944 helper: &mut DeserializeHelper,
14945 bytes_start: &BytesStart<'_>,
14946 ) -> Result<Box<Self>, Error> {
14947 let mut id: Option<String> = None;
14948 let mut name: Option<String> = None;
14949 let mut ref_: Option<QName> = None;
14950 for attrib in helper.filter_xmlns_attributes(bytes_start) {
14951 let attrib = attrib?;
14952 if matches!(
14953 helper.resolve_local_name(attrib.key, &super::NS_XS),
14954 Some(b"id")
14955 ) {
14956 helper.read_attrib(&mut id, b"id", &attrib.value)?;
14957 } else if matches!(
14958 helper.resolve_local_name(attrib.key, &super::NS_XS),
14959 Some(b"name")
14960 ) {
14961 helper.read_attrib(&mut name, b"name", &attrib.value)?;
14962 } else if matches!(
14963 helper.resolve_local_name(attrib.key, &super::NS_XS),
14964 Some(b"ref")
14965 ) {
14966 helper.read_attrib(&mut ref_, b"ref", &attrib.value)?;
14967 }
14968 }
14969 Ok(Box::new(Self {
14970 id: id,
14971 name: name,
14972 ref_: ref_,
14973 content: None,
14974 state__: Box::new(KeybaseTypeDeserializerState::Init__),
14975 }))
14976 }
14977 fn finish_state(
14978 &mut self,
14979 helper: &mut DeserializeHelper,
14980 state: KeybaseTypeDeserializerState,
14981 ) -> Result<(), Error> {
14982 if let KeybaseTypeDeserializerState::Content__(deserializer) = state {
14983 self.store_content(deserializer.finish(helper)?)?;
14984 }
14985 Ok(())
14986 }
14987 fn store_content(&mut self, value: super::KeybaseTypeContent) -> Result<(), Error> {
14988 if self.content.is_some() {
14989 Err(ErrorKind::DuplicateContent)?;
14990 }
14991 self.content = Some(value);
14992 Ok(())
14993 }
14994 fn handle_content<'de>(
14995 &mut self,
14996 helper: &mut DeserializeHelper,
14997 output: DeserializerOutput<'de, super::KeybaseTypeContent>,
14998 fallback: &mut Option<KeybaseTypeDeserializerState>,
14999 ) -> Result<ElementHandlerOutput<'de>, Error> {
15000 use KeybaseTypeDeserializerState as S;
15001 let DeserializerOutput {
15002 artifact,
15003 event,
15004 allow_any,
15005 } = output;
15006 if artifact.is_none() {
15007 *self.state__ = fallback.take().unwrap_or(S::Next__);
15008 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
15009 }
15010 if let Some(fallback) = fallback.take() {
15011 self.finish_state(helper, fallback)?;
15012 }
15013 match artifact {
15014 DeserializerArtifact::None => unreachable!(),
15015 DeserializerArtifact::Data(data) => {
15016 self.store_content(data)?;
15017 *self.state__ = S::Next__;
15018 Ok(ElementHandlerOutput::from_event(event, allow_any))
15019 }
15020 DeserializerArtifact::Deserializer(deserializer) => {
15021 *self.state__ = S::Content__(deserializer);
15022 Ok(ElementHandlerOutput::from_event_end(event, allow_any))
15023 }
15024 }
15025 }
15026 }
15027 impl<'de> Deserializer<'de, super::KeybaseType> for Box<KeybaseTypeDeserializer> {
15028 fn init(
15029 helper: &mut DeserializeHelper,
15030 event: Event<'de>,
15031 ) -> DeserializerResult<'de, super::KeybaseType> {
15032 helper.init_deserializer_from_start_event(
15033 event,
15034 KeybaseTypeDeserializer::from_bytes_start,
15035 )
15036 }
15037 fn next(
15038 mut self,
15039 helper: &mut DeserializeHelper,
15040 event: Event<'de>,
15041 ) -> DeserializerResult<'de, super::KeybaseType> {
15042 use KeybaseTypeDeserializerState as S;
15043 let mut event = event;
15044 let mut fallback = None;
15045 let (event, allow_any) = loop {
15046 let state = replace(&mut *self.state__, S::Unknown__);
15047 event = match (state, event) {
15048 (S::Unknown__, _) => unreachable!(),
15049 (S::Content__(deserializer), event) => {
15050 let output = deserializer.next(helper, event)?;
15051 match self.handle_content(helper, output, &mut fallback)? {
15052 ElementHandlerOutput::Break { event, allow_any } => {
15053 break (event, allow_any)
15054 }
15055 ElementHandlerOutput::Continue { event, .. } => event,
15056 }
15057 }
15058 (_, Event::End(_)) => {
15059 return Ok(DeserializerOutput {
15060 artifact: DeserializerArtifact::Data(self.finish(helper)?),
15061 event: DeserializerEvent::None,
15062 allow_any: false,
15063 });
15064 }
15065 (state @ (S::Init__ | S::Next__), event) => {
15066 fallback.get_or_insert(state);
15067 let output =
15068 <super::KeybaseTypeContent as WithDeserializer>::init(helper, event)?;
15069 match self.handle_content(helper, output, &mut fallback)? {
15070 ElementHandlerOutput::Break { event, allow_any } => {
15071 break (event, allow_any)
15072 }
15073 ElementHandlerOutput::Continue { event, .. } => event,
15074 }
15075 }
15076 }
15077 };
15078 if let Some(fallback) = fallback {
15079 *self.state__ = fallback;
15080 }
15081 let artifact = DeserializerArtifact::Deserializer(self);
15082 Ok(DeserializerOutput {
15083 artifact,
15084 event,
15085 allow_any,
15086 })
15087 }
15088 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::KeybaseType, Error> {
15089 let state = replace(&mut *self.state__, KeybaseTypeDeserializerState::Unknown__);
15090 self.finish_state(helper, state)?;
15091 Ok(super::KeybaseType {
15092 id: self.id,
15093 name: self.name,
15094 ref_: self.ref_,
15095 content: self.content,
15096 })
15097 }
15098 }
15099 #[derive(Debug)]
15100 pub struct KeybaseTypeContentDeserializer {
15101 annotation: Option<super::Annotation>,
15102 selector: Option<super::Field>,
15103 field: Vec<super::Field>,
15104 state__: Box<KeybaseTypeContentDeserializerState>,
15105 }
15106 #[derive(Debug)]
15107 enum KeybaseTypeContentDeserializerState {
15108 Init__,
15109 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
15110 Selector(Option<<super::Field as WithDeserializer>::Deserializer>),
15111 Field(Option<<super::Field as WithDeserializer>::Deserializer>),
15112 Done__,
15113 Unknown__,
15114 }
15115 impl KeybaseTypeContentDeserializer {
15116 fn finish_state(
15117 &mut self,
15118 helper: &mut DeserializeHelper,
15119 state: KeybaseTypeContentDeserializerState,
15120 ) -> Result<(), Error> {
15121 use KeybaseTypeContentDeserializerState as S;
15122 match state {
15123 S::Annotation(Some(deserializer)) => {
15124 self.store_annotation(deserializer.finish(helper)?)?
15125 }
15126 S::Selector(Some(deserializer)) => {
15127 self.store_selector(deserializer.finish(helper)?)?
15128 }
15129 S::Field(Some(deserializer)) => self.store_field(deserializer.finish(helper)?)?,
15130 _ => (),
15131 }
15132 Ok(())
15133 }
15134 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
15135 if self.annotation.is_some() {
15136 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
15137 b"annotation",
15138 )))?;
15139 }
15140 self.annotation = Some(value);
15141 Ok(())
15142 }
15143 fn store_selector(&mut self, value: super::Field) -> Result<(), Error> {
15144 if self.selector.is_some() {
15145 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
15146 b"selector",
15147 )))?;
15148 }
15149 self.selector = Some(value);
15150 Ok(())
15151 }
15152 fn store_field(&mut self, value: super::Field) -> Result<(), Error> {
15153 self.field.push(value);
15154 Ok(())
15155 }
15156 fn handle_annotation<'de>(
15157 &mut self,
15158 helper: &mut DeserializeHelper,
15159 output: DeserializerOutput<'de, super::Annotation>,
15160 fallback: &mut Option<KeybaseTypeContentDeserializerState>,
15161 ) -> Result<ElementHandlerOutput<'de>, Error> {
15162 use KeybaseTypeContentDeserializerState as S;
15163 let DeserializerOutput {
15164 artifact,
15165 event,
15166 allow_any,
15167 } = output;
15168 if artifact.is_none() {
15169 fallback.get_or_insert(S::Annotation(None));
15170 *self.state__ = S::Selector(None);
15171 return Ok(ElementHandlerOutput::from_event(event, allow_any));
15172 }
15173 if let Some(fallback) = fallback.take() {
15174 self.finish_state(helper, fallback)?;
15175 }
15176 match artifact {
15177 DeserializerArtifact::None => unreachable!(),
15178 DeserializerArtifact::Data(data) => {
15179 self.store_annotation(data)?;
15180 *self.state__ = S::Selector(None);
15181 Ok(ElementHandlerOutput::from_event(event, allow_any))
15182 }
15183 DeserializerArtifact::Deserializer(deserializer) => {
15184 fallback.get_or_insert(S::Annotation(Some(deserializer)));
15185 *self.state__ = S::Selector(None);
15186 Ok(ElementHandlerOutput::from_event(event, allow_any))
15187 }
15188 }
15189 }
15190 fn handle_selector<'de>(
15191 &mut self,
15192 helper: &mut DeserializeHelper,
15193 output: DeserializerOutput<'de, super::Field>,
15194 fallback: &mut Option<KeybaseTypeContentDeserializerState>,
15195 ) -> Result<ElementHandlerOutput<'de>, Error> {
15196 use KeybaseTypeContentDeserializerState as S;
15197 let DeserializerOutput {
15198 artifact,
15199 event,
15200 allow_any,
15201 } = output;
15202 if artifact.is_none() {
15203 fallback.get_or_insert(S::Selector(None));
15204 if matches!(&fallback, Some(S::Init__)) {
15205 return Ok(ElementHandlerOutput::break_(event, allow_any));
15206 } else {
15207 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
15208 }
15209 }
15210 if let Some(fallback) = fallback.take() {
15211 self.finish_state(helper, fallback)?;
15212 }
15213 match artifact {
15214 DeserializerArtifact::None => unreachable!(),
15215 DeserializerArtifact::Data(data) => {
15216 self.store_selector(data)?;
15217 *self.state__ = S::Field(None);
15218 Ok(ElementHandlerOutput::from_event(event, allow_any))
15219 }
15220 DeserializerArtifact::Deserializer(deserializer) => {
15221 fallback.get_or_insert(S::Selector(Some(deserializer)));
15222 *self.state__ = S::Field(None);
15223 Ok(ElementHandlerOutput::from_event(event, allow_any))
15224 }
15225 }
15226 }
15227 fn handle_field<'de>(
15228 &mut self,
15229 helper: &mut DeserializeHelper,
15230 output: DeserializerOutput<'de, super::Field>,
15231 fallback: &mut Option<KeybaseTypeContentDeserializerState>,
15232 ) -> Result<ElementHandlerOutput<'de>, Error> {
15233 use KeybaseTypeContentDeserializerState as S;
15234 let DeserializerOutput {
15235 artifact,
15236 event,
15237 allow_any,
15238 } = output;
15239 if artifact.is_none() {
15240 if matches!(&fallback, Some(S::Init__)) {
15241 return Ok(ElementHandlerOutput::break_(event, allow_any));
15242 } else if self.field.len() < 1usize {
15243 fallback.get_or_insert(S::Field(None));
15244 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
15245 } else {
15246 fallback.get_or_insert(S::Field(None));
15247 *self.state__ = S::Done__;
15248 return Ok(ElementHandlerOutput::from_event(event, allow_any));
15249 }
15250 }
15251 if let Some(fallback) = fallback.take() {
15252 self.finish_state(helper, fallback)?;
15253 }
15254 match artifact {
15255 DeserializerArtifact::None => unreachable!(),
15256 DeserializerArtifact::Data(data) => {
15257 self.store_field(data)?;
15258 *self.state__ = S::Field(None);
15259 Ok(ElementHandlerOutput::from_event(event, allow_any))
15260 }
15261 DeserializerArtifact::Deserializer(deserializer) => {
15262 fallback.get_or_insert(S::Field(Some(deserializer)));
15263 *self.state__ = S::Field(None);
15264 Ok(ElementHandlerOutput::from_event(event, allow_any))
15265 }
15266 }
15267 }
15268 }
15269 impl<'de> Deserializer<'de, super::KeybaseTypeContent> for Box<KeybaseTypeContentDeserializer> {
15270 fn init(
15271 helper: &mut DeserializeHelper,
15272 event: Event<'de>,
15273 ) -> DeserializerResult<'de, super::KeybaseTypeContent> {
15274 let deserializer = Box::new(KeybaseTypeContentDeserializer {
15275 annotation: None,
15276 selector: None,
15277 field: Vec::new(),
15278 state__: Box::new(KeybaseTypeContentDeserializerState::Init__),
15279 });
15280 let mut output = deserializer.next(helper, event)?;
15281 output.artifact = match output.artifact {
15282 DeserializerArtifact::Deserializer(x)
15283 if matches!(&*x.state__, KeybaseTypeContentDeserializerState::Init__) =>
15284 {
15285 DeserializerArtifact::None
15286 }
15287 artifact => artifact,
15288 };
15289 Ok(output)
15290 }
15291 fn next(
15292 mut self,
15293 helper: &mut DeserializeHelper,
15294 event: Event<'de>,
15295 ) -> DeserializerResult<'de, super::KeybaseTypeContent> {
15296 use KeybaseTypeContentDeserializerState as S;
15297 let mut event = event;
15298 let mut fallback = None;
15299 let mut allow_any_element = false;
15300 let (event, allow_any) = loop {
15301 let state = replace(&mut *self.state__, S::Unknown__);
15302 event = match (state, event) {
15303 (S::Unknown__, _) => unreachable!(),
15304 (S::Annotation(Some(deserializer)), event) => {
15305 let output = deserializer.next(helper, event)?;
15306 match self.handle_annotation(helper, output, &mut fallback)? {
15307 ElementHandlerOutput::Continue { event, allow_any } => {
15308 allow_any_element = allow_any_element || allow_any;
15309 event
15310 }
15311 ElementHandlerOutput::Break { event, allow_any } => {
15312 break (event, allow_any)
15313 }
15314 }
15315 }
15316 (S::Selector(Some(deserializer)), event) => {
15317 let output = deserializer.next(helper, event)?;
15318 match self.handle_selector(helper, output, &mut fallback)? {
15319 ElementHandlerOutput::Continue { event, allow_any } => {
15320 allow_any_element = allow_any_element || allow_any;
15321 event
15322 }
15323 ElementHandlerOutput::Break { event, allow_any } => {
15324 break (event, allow_any)
15325 }
15326 }
15327 }
15328 (S::Field(Some(deserializer)), event) => {
15329 let output = deserializer.next(helper, event)?;
15330 match self.handle_field(helper, output, &mut fallback)? {
15331 ElementHandlerOutput::Continue { event, allow_any } => {
15332 allow_any_element = allow_any_element || allow_any;
15333 event
15334 }
15335 ElementHandlerOutput::Break { event, allow_any } => {
15336 break (event, allow_any)
15337 }
15338 }
15339 }
15340 (_, event @ Event::End(_)) => {
15341 if let Some(fallback) = fallback.take() {
15342 self.finish_state(helper, fallback)?;
15343 }
15344 return Ok(DeserializerOutput {
15345 artifact: DeserializerArtifact::Data(self.finish(helper)?),
15346 event: DeserializerEvent::Continue(event),
15347 allow_any: false,
15348 });
15349 }
15350 (S::Init__, event) => {
15351 fallback.get_or_insert(S::Init__);
15352 *self.state__ = S::Annotation(None);
15353 event
15354 }
15355 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
15356 let output = helper.init_start_tag_deserializer(
15357 event,
15358 Some(&super::NS_XS),
15359 b"annotation",
15360 false,
15361 )?;
15362 match self.handle_annotation(helper, output, &mut fallback)? {
15363 ElementHandlerOutput::Continue { event, allow_any } => {
15364 allow_any_element = allow_any_element || allow_any;
15365 event
15366 }
15367 ElementHandlerOutput::Break { event, allow_any } => {
15368 break (event, allow_any)
15369 }
15370 }
15371 }
15372 (S::Selector(None), event @ (Event::Start(_) | Event::Empty(_))) => {
15373 let output = helper.init_start_tag_deserializer(
15374 event,
15375 Some(&super::NS_XS),
15376 b"selector",
15377 false,
15378 )?;
15379 match self.handle_selector(helper, output, &mut fallback)? {
15380 ElementHandlerOutput::Continue { event, allow_any } => {
15381 allow_any_element = allow_any_element || allow_any;
15382 event
15383 }
15384 ElementHandlerOutput::Break { event, allow_any } => {
15385 break (event, allow_any)
15386 }
15387 }
15388 }
15389 (S::Field(None), event @ (Event::Start(_) | Event::Empty(_))) => {
15390 let output = helper.init_start_tag_deserializer(
15391 event,
15392 Some(&super::NS_XS),
15393 b"field",
15394 false,
15395 )?;
15396 match self.handle_field(helper, output, &mut fallback)? {
15397 ElementHandlerOutput::Continue { event, allow_any } => {
15398 allow_any_element = allow_any_element || allow_any;
15399 event
15400 }
15401 ElementHandlerOutput::Break { event, allow_any } => {
15402 break (event, allow_any)
15403 }
15404 }
15405 }
15406 (S::Done__, event) => {
15407 *self.state__ = S::Done__;
15408 break (DeserializerEvent::Continue(event), allow_any_element);
15409 }
15410 (state, event) => {
15411 *self.state__ = state;
15412 break (DeserializerEvent::Break(event), false);
15413 }
15414 }
15415 };
15416 if let Some(fallback) = fallback {
15417 *self.state__ = fallback;
15418 }
15419 Ok(DeserializerOutput {
15420 artifact: DeserializerArtifact::Deserializer(self),
15421 event,
15422 allow_any,
15423 })
15424 }
15425 fn finish(
15426 mut self,
15427 helper: &mut DeserializeHelper,
15428 ) -> Result<super::KeybaseTypeContent, Error> {
15429 let state = replace(
15430 &mut *self.state__,
15431 KeybaseTypeContentDeserializerState::Unknown__,
15432 );
15433 self.finish_state(helper, state)?;
15434 Ok(super::KeybaseTypeContent {
15435 annotation: self.annotation,
15436 selector: helper.finish_element("selector", self.selector)?,
15437 field: helper.finish_vec(1usize, None, self.field)?,
15438 })
15439 }
15440 }
15441 #[derive(Debug)]
15442 pub struct KeyrefDeserializer {
15443 id: Option<String>,
15444 name: Option<String>,
15445 ref_: Option<QName>,
15446 refer: Option<QName>,
15447 content: Option<super::KeyrefContent>,
15448 state__: Box<KeyrefDeserializerState>,
15449 }
15450 #[derive(Debug)]
15451 enum KeyrefDeserializerState {
15452 Init__,
15453 Next__,
15454 Content__(<super::KeyrefContent as WithDeserializer>::Deserializer),
15455 Unknown__,
15456 }
15457 impl KeyrefDeserializer {
15458 fn from_bytes_start(
15459 helper: &mut DeserializeHelper,
15460 bytes_start: &BytesStart<'_>,
15461 ) -> Result<Box<Self>, Error> {
15462 let mut id: Option<String> = None;
15463 let mut name: Option<String> = None;
15464 let mut ref_: Option<QName> = None;
15465 let mut refer: Option<QName> = None;
15466 for attrib in helper.filter_xmlns_attributes(bytes_start) {
15467 let attrib = attrib?;
15468 if matches!(
15469 helper.resolve_local_name(attrib.key, &super::NS_XS),
15470 Some(b"id")
15471 ) {
15472 helper.read_attrib(&mut id, b"id", &attrib.value)?;
15473 } else if matches!(
15474 helper.resolve_local_name(attrib.key, &super::NS_XS),
15475 Some(b"name")
15476 ) {
15477 helper.read_attrib(&mut name, b"name", &attrib.value)?;
15478 } else if matches!(
15479 helper.resolve_local_name(attrib.key, &super::NS_XS),
15480 Some(b"ref")
15481 ) {
15482 helper.read_attrib(&mut ref_, b"ref", &attrib.value)?;
15483 } else if matches!(
15484 helper.resolve_local_name(attrib.key, &super::NS_XS),
15485 Some(b"refer")
15486 ) {
15487 helper.read_attrib(&mut refer, b"refer", &attrib.value)?;
15488 }
15489 }
15490 Ok(Box::new(Self {
15491 id: id,
15492 name: name,
15493 ref_: ref_,
15494 refer: refer,
15495 content: None,
15496 state__: Box::new(KeyrefDeserializerState::Init__),
15497 }))
15498 }
15499 fn finish_state(
15500 &mut self,
15501 helper: &mut DeserializeHelper,
15502 state: KeyrefDeserializerState,
15503 ) -> Result<(), Error> {
15504 if let KeyrefDeserializerState::Content__(deserializer) = state {
15505 self.store_content(deserializer.finish(helper)?)?;
15506 }
15507 Ok(())
15508 }
15509 fn store_content(&mut self, value: super::KeyrefContent) -> Result<(), Error> {
15510 if self.content.is_some() {
15511 Err(ErrorKind::DuplicateContent)?;
15512 }
15513 self.content = Some(value);
15514 Ok(())
15515 }
15516 fn handle_content<'de>(
15517 &mut self,
15518 helper: &mut DeserializeHelper,
15519 output: DeserializerOutput<'de, super::KeyrefContent>,
15520 fallback: &mut Option<KeyrefDeserializerState>,
15521 ) -> Result<ElementHandlerOutput<'de>, Error> {
15522 use KeyrefDeserializerState as S;
15523 let DeserializerOutput {
15524 artifact,
15525 event,
15526 allow_any,
15527 } = output;
15528 if artifact.is_none() {
15529 *self.state__ = fallback.take().unwrap_or(S::Next__);
15530 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
15531 }
15532 if let Some(fallback) = fallback.take() {
15533 self.finish_state(helper, fallback)?;
15534 }
15535 match artifact {
15536 DeserializerArtifact::None => unreachable!(),
15537 DeserializerArtifact::Data(data) => {
15538 self.store_content(data)?;
15539 *self.state__ = S::Next__;
15540 Ok(ElementHandlerOutput::from_event(event, allow_any))
15541 }
15542 DeserializerArtifact::Deserializer(deserializer) => {
15543 *self.state__ = S::Content__(deserializer);
15544 Ok(ElementHandlerOutput::from_event_end(event, allow_any))
15545 }
15546 }
15547 }
15548 }
15549 impl<'de> Deserializer<'de, super::Keyref> for Box<KeyrefDeserializer> {
15550 fn init(
15551 helper: &mut DeserializeHelper,
15552 event: Event<'de>,
15553 ) -> DeserializerResult<'de, super::Keyref> {
15554 helper.init_deserializer_from_start_event(event, KeyrefDeserializer::from_bytes_start)
15555 }
15556 fn next(
15557 mut self,
15558 helper: &mut DeserializeHelper,
15559 event: Event<'de>,
15560 ) -> DeserializerResult<'de, super::Keyref> {
15561 use KeyrefDeserializerState as S;
15562 let mut event = event;
15563 let mut fallback = None;
15564 let (event, allow_any) = loop {
15565 let state = replace(&mut *self.state__, S::Unknown__);
15566 event = match (state, event) {
15567 (S::Unknown__, _) => unreachable!(),
15568 (S::Content__(deserializer), event) => {
15569 let output = deserializer.next(helper, event)?;
15570 match self.handle_content(helper, output, &mut fallback)? {
15571 ElementHandlerOutput::Break { event, allow_any } => {
15572 break (event, allow_any)
15573 }
15574 ElementHandlerOutput::Continue { event, .. } => event,
15575 }
15576 }
15577 (_, Event::End(_)) => {
15578 return Ok(DeserializerOutput {
15579 artifact: DeserializerArtifact::Data(self.finish(helper)?),
15580 event: DeserializerEvent::None,
15581 allow_any: false,
15582 });
15583 }
15584 (state @ (S::Init__ | S::Next__), event) => {
15585 fallback.get_or_insert(state);
15586 let output =
15587 <super::KeyrefContent as WithDeserializer>::init(helper, event)?;
15588 match self.handle_content(helper, output, &mut fallback)? {
15589 ElementHandlerOutput::Break { event, allow_any } => {
15590 break (event, allow_any)
15591 }
15592 ElementHandlerOutput::Continue { event, .. } => event,
15593 }
15594 }
15595 }
15596 };
15597 if let Some(fallback) = fallback {
15598 *self.state__ = fallback;
15599 }
15600 let artifact = DeserializerArtifact::Deserializer(self);
15601 Ok(DeserializerOutput {
15602 artifact,
15603 event,
15604 allow_any,
15605 })
15606 }
15607 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Keyref, Error> {
15608 let state = replace(&mut *self.state__, KeyrefDeserializerState::Unknown__);
15609 self.finish_state(helper, state)?;
15610 Ok(super::Keyref {
15611 id: self.id,
15612 name: self.name,
15613 ref_: self.ref_,
15614 refer: self.refer,
15615 content: self.content,
15616 })
15617 }
15618 }
15619 #[derive(Debug)]
15620 pub struct KeyrefContentDeserializer {
15621 annotation: Option<super::Annotation>,
15622 selector: Option<super::Field>,
15623 field: Vec<super::Field>,
15624 state__: Box<KeyrefContentDeserializerState>,
15625 }
15626 #[derive(Debug)]
15627 enum KeyrefContentDeserializerState {
15628 Init__,
15629 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
15630 Selector(Option<<super::Field as WithDeserializer>::Deserializer>),
15631 Field(Option<<super::Field as WithDeserializer>::Deserializer>),
15632 Done__,
15633 Unknown__,
15634 }
15635 impl KeyrefContentDeserializer {
15636 fn finish_state(
15637 &mut self,
15638 helper: &mut DeserializeHelper,
15639 state: KeyrefContentDeserializerState,
15640 ) -> Result<(), Error> {
15641 use KeyrefContentDeserializerState as S;
15642 match state {
15643 S::Annotation(Some(deserializer)) => {
15644 self.store_annotation(deserializer.finish(helper)?)?
15645 }
15646 S::Selector(Some(deserializer)) => {
15647 self.store_selector(deserializer.finish(helper)?)?
15648 }
15649 S::Field(Some(deserializer)) => self.store_field(deserializer.finish(helper)?)?,
15650 _ => (),
15651 }
15652 Ok(())
15653 }
15654 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
15655 if self.annotation.is_some() {
15656 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
15657 b"annotation",
15658 )))?;
15659 }
15660 self.annotation = Some(value);
15661 Ok(())
15662 }
15663 fn store_selector(&mut self, value: super::Field) -> Result<(), Error> {
15664 if self.selector.is_some() {
15665 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
15666 b"selector",
15667 )))?;
15668 }
15669 self.selector = Some(value);
15670 Ok(())
15671 }
15672 fn store_field(&mut self, value: super::Field) -> Result<(), Error> {
15673 self.field.push(value);
15674 Ok(())
15675 }
15676 fn handle_annotation<'de>(
15677 &mut self,
15678 helper: &mut DeserializeHelper,
15679 output: DeserializerOutput<'de, super::Annotation>,
15680 fallback: &mut Option<KeyrefContentDeserializerState>,
15681 ) -> Result<ElementHandlerOutput<'de>, Error> {
15682 use KeyrefContentDeserializerState as S;
15683 let DeserializerOutput {
15684 artifact,
15685 event,
15686 allow_any,
15687 } = output;
15688 if artifact.is_none() {
15689 fallback.get_or_insert(S::Annotation(None));
15690 *self.state__ = S::Selector(None);
15691 return Ok(ElementHandlerOutput::from_event(event, allow_any));
15692 }
15693 if let Some(fallback) = fallback.take() {
15694 self.finish_state(helper, fallback)?;
15695 }
15696 match artifact {
15697 DeserializerArtifact::None => unreachable!(),
15698 DeserializerArtifact::Data(data) => {
15699 self.store_annotation(data)?;
15700 *self.state__ = S::Selector(None);
15701 Ok(ElementHandlerOutput::from_event(event, allow_any))
15702 }
15703 DeserializerArtifact::Deserializer(deserializer) => {
15704 fallback.get_or_insert(S::Annotation(Some(deserializer)));
15705 *self.state__ = S::Selector(None);
15706 Ok(ElementHandlerOutput::from_event(event, allow_any))
15707 }
15708 }
15709 }
15710 fn handle_selector<'de>(
15711 &mut self,
15712 helper: &mut DeserializeHelper,
15713 output: DeserializerOutput<'de, super::Field>,
15714 fallback: &mut Option<KeyrefContentDeserializerState>,
15715 ) -> Result<ElementHandlerOutput<'de>, Error> {
15716 use KeyrefContentDeserializerState as S;
15717 let DeserializerOutput {
15718 artifact,
15719 event,
15720 allow_any,
15721 } = output;
15722 if artifact.is_none() {
15723 fallback.get_or_insert(S::Selector(None));
15724 if matches!(&fallback, Some(S::Init__)) {
15725 return Ok(ElementHandlerOutput::break_(event, allow_any));
15726 } else {
15727 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
15728 }
15729 }
15730 if let Some(fallback) = fallback.take() {
15731 self.finish_state(helper, fallback)?;
15732 }
15733 match artifact {
15734 DeserializerArtifact::None => unreachable!(),
15735 DeserializerArtifact::Data(data) => {
15736 self.store_selector(data)?;
15737 *self.state__ = S::Field(None);
15738 Ok(ElementHandlerOutput::from_event(event, allow_any))
15739 }
15740 DeserializerArtifact::Deserializer(deserializer) => {
15741 fallback.get_or_insert(S::Selector(Some(deserializer)));
15742 *self.state__ = S::Field(None);
15743 Ok(ElementHandlerOutput::from_event(event, allow_any))
15744 }
15745 }
15746 }
15747 fn handle_field<'de>(
15748 &mut self,
15749 helper: &mut DeserializeHelper,
15750 output: DeserializerOutput<'de, super::Field>,
15751 fallback: &mut Option<KeyrefContentDeserializerState>,
15752 ) -> Result<ElementHandlerOutput<'de>, Error> {
15753 use KeyrefContentDeserializerState as S;
15754 let DeserializerOutput {
15755 artifact,
15756 event,
15757 allow_any,
15758 } = output;
15759 if artifact.is_none() {
15760 if matches!(&fallback, Some(S::Init__)) {
15761 return Ok(ElementHandlerOutput::break_(event, allow_any));
15762 } else if self.field.len() < 1usize {
15763 fallback.get_or_insert(S::Field(None));
15764 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
15765 } else {
15766 fallback.get_or_insert(S::Field(None));
15767 *self.state__ = S::Done__;
15768 return Ok(ElementHandlerOutput::from_event(event, allow_any));
15769 }
15770 }
15771 if let Some(fallback) = fallback.take() {
15772 self.finish_state(helper, fallback)?;
15773 }
15774 match artifact {
15775 DeserializerArtifact::None => unreachable!(),
15776 DeserializerArtifact::Data(data) => {
15777 self.store_field(data)?;
15778 *self.state__ = S::Field(None);
15779 Ok(ElementHandlerOutput::from_event(event, allow_any))
15780 }
15781 DeserializerArtifact::Deserializer(deserializer) => {
15782 fallback.get_or_insert(S::Field(Some(deserializer)));
15783 *self.state__ = S::Field(None);
15784 Ok(ElementHandlerOutput::from_event(event, allow_any))
15785 }
15786 }
15787 }
15788 }
15789 impl<'de> Deserializer<'de, super::KeyrefContent> for Box<KeyrefContentDeserializer> {
15790 fn init(
15791 helper: &mut DeserializeHelper,
15792 event: Event<'de>,
15793 ) -> DeserializerResult<'de, super::KeyrefContent> {
15794 let deserializer = Box::new(KeyrefContentDeserializer {
15795 annotation: None,
15796 selector: None,
15797 field: Vec::new(),
15798 state__: Box::new(KeyrefContentDeserializerState::Init__),
15799 });
15800 let mut output = deserializer.next(helper, event)?;
15801 output.artifact = match output.artifact {
15802 DeserializerArtifact::Deserializer(x)
15803 if matches!(&*x.state__, KeyrefContentDeserializerState::Init__) =>
15804 {
15805 DeserializerArtifact::None
15806 }
15807 artifact => artifact,
15808 };
15809 Ok(output)
15810 }
15811 fn next(
15812 mut self,
15813 helper: &mut DeserializeHelper,
15814 event: Event<'de>,
15815 ) -> DeserializerResult<'de, super::KeyrefContent> {
15816 use KeyrefContentDeserializerState as S;
15817 let mut event = event;
15818 let mut fallback = None;
15819 let mut allow_any_element = false;
15820 let (event, allow_any) = loop {
15821 let state = replace(&mut *self.state__, S::Unknown__);
15822 event = match (state, event) {
15823 (S::Unknown__, _) => unreachable!(),
15824 (S::Annotation(Some(deserializer)), event) => {
15825 let output = deserializer.next(helper, event)?;
15826 match self.handle_annotation(helper, output, &mut fallback)? {
15827 ElementHandlerOutput::Continue { event, allow_any } => {
15828 allow_any_element = allow_any_element || allow_any;
15829 event
15830 }
15831 ElementHandlerOutput::Break { event, allow_any } => {
15832 break (event, allow_any)
15833 }
15834 }
15835 }
15836 (S::Selector(Some(deserializer)), event) => {
15837 let output = deserializer.next(helper, event)?;
15838 match self.handle_selector(helper, output, &mut fallback)? {
15839 ElementHandlerOutput::Continue { event, allow_any } => {
15840 allow_any_element = allow_any_element || allow_any;
15841 event
15842 }
15843 ElementHandlerOutput::Break { event, allow_any } => {
15844 break (event, allow_any)
15845 }
15846 }
15847 }
15848 (S::Field(Some(deserializer)), event) => {
15849 let output = deserializer.next(helper, event)?;
15850 match self.handle_field(helper, output, &mut fallback)? {
15851 ElementHandlerOutput::Continue { event, allow_any } => {
15852 allow_any_element = allow_any_element || allow_any;
15853 event
15854 }
15855 ElementHandlerOutput::Break { event, allow_any } => {
15856 break (event, allow_any)
15857 }
15858 }
15859 }
15860 (_, event @ Event::End(_)) => {
15861 if let Some(fallback) = fallback.take() {
15862 self.finish_state(helper, fallback)?;
15863 }
15864 return Ok(DeserializerOutput {
15865 artifact: DeserializerArtifact::Data(self.finish(helper)?),
15866 event: DeserializerEvent::Continue(event),
15867 allow_any: false,
15868 });
15869 }
15870 (S::Init__, event) => {
15871 fallback.get_or_insert(S::Init__);
15872 *self.state__ = S::Annotation(None);
15873 event
15874 }
15875 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
15876 let output = helper.init_start_tag_deserializer(
15877 event,
15878 Some(&super::NS_XS),
15879 b"annotation",
15880 false,
15881 )?;
15882 match self.handle_annotation(helper, output, &mut fallback)? {
15883 ElementHandlerOutput::Continue { event, allow_any } => {
15884 allow_any_element = allow_any_element || allow_any;
15885 event
15886 }
15887 ElementHandlerOutput::Break { event, allow_any } => {
15888 break (event, allow_any)
15889 }
15890 }
15891 }
15892 (S::Selector(None), event @ (Event::Start(_) | Event::Empty(_))) => {
15893 let output = helper.init_start_tag_deserializer(
15894 event,
15895 Some(&super::NS_XS),
15896 b"selector",
15897 false,
15898 )?;
15899 match self.handle_selector(helper, output, &mut fallback)? {
15900 ElementHandlerOutput::Continue { event, allow_any } => {
15901 allow_any_element = allow_any_element || allow_any;
15902 event
15903 }
15904 ElementHandlerOutput::Break { event, allow_any } => {
15905 break (event, allow_any)
15906 }
15907 }
15908 }
15909 (S::Field(None), event @ (Event::Start(_) | Event::Empty(_))) => {
15910 let output = helper.init_start_tag_deserializer(
15911 event,
15912 Some(&super::NS_XS),
15913 b"field",
15914 false,
15915 )?;
15916 match self.handle_field(helper, output, &mut fallback)? {
15917 ElementHandlerOutput::Continue { event, allow_any } => {
15918 allow_any_element = allow_any_element || allow_any;
15919 event
15920 }
15921 ElementHandlerOutput::Break { event, allow_any } => {
15922 break (event, allow_any)
15923 }
15924 }
15925 }
15926 (S::Done__, event) => {
15927 *self.state__ = S::Done__;
15928 break (DeserializerEvent::Continue(event), allow_any_element);
15929 }
15930 (state, event) => {
15931 *self.state__ = state;
15932 break (DeserializerEvent::Break(event), false);
15933 }
15934 }
15935 };
15936 if let Some(fallback) = fallback {
15937 *self.state__ = fallback;
15938 }
15939 Ok(DeserializerOutput {
15940 artifact: DeserializerArtifact::Deserializer(self),
15941 event,
15942 allow_any,
15943 })
15944 }
15945 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::KeyrefContent, Error> {
15946 let state = replace(
15947 &mut *self.state__,
15948 KeyrefContentDeserializerState::Unknown__,
15949 );
15950 self.finish_state(helper, state)?;
15951 Ok(super::KeyrefContent {
15952 annotation: self.annotation,
15953 selector: helper.finish_element("selector", self.selector)?,
15954 field: helper.finish_vec(1usize, None, self.field)?,
15955 })
15956 }
15957 }
15958 #[derive(Debug)]
15959 pub struct FacetDeserializer {
15960 state__: Box<FacetDeserializerState>,
15961 }
15962 #[derive(Debug)]
15963 pub enum FacetDeserializerState {
15964 Init__,
15965 MinExclusive(
15966 Option<super::FacetType>,
15967 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15968 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15969 ),
15970 MinInclusive(
15971 Option<super::FacetType>,
15972 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15973 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15974 ),
15975 MaxExclusive(
15976 Option<super::FacetType>,
15977 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15978 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15979 ),
15980 MaxInclusive(
15981 Option<super::FacetType>,
15982 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15983 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15984 ),
15985 TotalDigits(
15986 Option<super::FacetType>,
15987 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15988 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15989 ),
15990 FractionDigits(
15991 Option<super::FacetType>,
15992 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15993 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15994 ),
15995 Length(
15996 Option<super::FacetType>,
15997 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15998 Option<<super::FacetType as WithDeserializer>::Deserializer>,
15999 ),
16000 MinLength(
16001 Option<super::FacetType>,
16002 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16003 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16004 ),
16005 MaxLength(
16006 Option<super::FacetType>,
16007 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16008 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16009 ),
16010 Enumeration(
16011 Option<super::FacetType>,
16012 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16013 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16014 ),
16015 WhiteSpace(
16016 Option<super::FacetType>,
16017 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16018 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16019 ),
16020 Pattern(
16021 Option<super::FacetType>,
16022 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16023 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16024 ),
16025 Assertion(
16026 Option<super::AssertionType>,
16027 Option<<super::AssertionType as WithDeserializer>::Deserializer>,
16028 Option<<super::AssertionType as WithDeserializer>::Deserializer>,
16029 ),
16030 ExplicitTimezone(
16031 Option<super::FacetType>,
16032 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16033 Option<<super::FacetType as WithDeserializer>::Deserializer>,
16034 ),
16035 Done__(super::Facet),
16036 Unknown__,
16037 }
16038 impl FacetDeserializer {
16039 fn find_suitable<'de>(
16040 &mut self,
16041 helper: &mut DeserializeHelper,
16042 event: Event<'de>,
16043 ) -> Result<ElementHandlerOutput<'de>, Error> {
16044 if let Event::Start(x) | Event::Empty(x) = &event {
16045 if matches!(
16046 helper.resolve_local_name(x.name(), &super::NS_XS),
16047 Some(b"minExclusive")
16048 ) {
16049 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16050 return self.handle_min_exclusive(helper, Default::default(), None, output);
16051 }
16052 if matches!(
16053 helper.resolve_local_name(x.name(), &super::NS_XS),
16054 Some(b"minInclusive")
16055 ) {
16056 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16057 return self.handle_min_inclusive(helper, Default::default(), None, output);
16058 }
16059 if matches!(
16060 helper.resolve_local_name(x.name(), &super::NS_XS),
16061 Some(b"maxExclusive")
16062 ) {
16063 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16064 return self.handle_max_exclusive(helper, Default::default(), None, output);
16065 }
16066 if matches!(
16067 helper.resolve_local_name(x.name(), &super::NS_XS),
16068 Some(b"maxInclusive")
16069 ) {
16070 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16071 return self.handle_max_inclusive(helper, Default::default(), None, output);
16072 }
16073 if matches!(
16074 helper.resolve_local_name(x.name(), &super::NS_XS),
16075 Some(b"totalDigits")
16076 ) {
16077 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16078 return self.handle_total_digits(helper, Default::default(), None, output);
16079 }
16080 if matches!(
16081 helper.resolve_local_name(x.name(), &super::NS_XS),
16082 Some(b"fractionDigits")
16083 ) {
16084 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16085 return self.handle_fraction_digits(helper, Default::default(), None, output);
16086 }
16087 if matches!(
16088 helper.resolve_local_name(x.name(), &super::NS_XS),
16089 Some(b"length")
16090 ) {
16091 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16092 return self.handle_length(helper, Default::default(), None, output);
16093 }
16094 if matches!(
16095 helper.resolve_local_name(x.name(), &super::NS_XS),
16096 Some(b"minLength")
16097 ) {
16098 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16099 return self.handle_min_length(helper, Default::default(), None, output);
16100 }
16101 if matches!(
16102 helper.resolve_local_name(x.name(), &super::NS_XS),
16103 Some(b"maxLength")
16104 ) {
16105 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16106 return self.handle_max_length(helper, Default::default(), None, output);
16107 }
16108 if matches!(
16109 helper.resolve_local_name(x.name(), &super::NS_XS),
16110 Some(b"enumeration")
16111 ) {
16112 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16113 return self.handle_enumeration(helper, Default::default(), None, output);
16114 }
16115 if matches!(
16116 helper.resolve_local_name(x.name(), &super::NS_XS),
16117 Some(b"whiteSpace")
16118 ) {
16119 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16120 return self.handle_white_space(helper, Default::default(), None, output);
16121 }
16122 if matches!(
16123 helper.resolve_local_name(x.name(), &super::NS_XS),
16124 Some(b"pattern")
16125 ) {
16126 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16127 return self.handle_pattern(helper, Default::default(), None, output);
16128 }
16129 if matches!(
16130 helper.resolve_local_name(x.name(), &super::NS_XS),
16131 Some(b"assertion")
16132 ) {
16133 let output = <super::AssertionType as WithDeserializer>::init(helper, event)?;
16134 return self.handle_assertion(helper, Default::default(), None, output);
16135 }
16136 if matches!(
16137 helper.resolve_local_name(x.name(), &super::NS_XS),
16138 Some(b"explicitTimezone")
16139 ) {
16140 let output = <super::FacetType as WithDeserializer>::init(helper, event)?;
16141 return self.handle_explicit_timezone(helper, Default::default(), None, output);
16142 }
16143 }
16144 *self.state__ = FacetDeserializerState::Init__;
16145 Ok(ElementHandlerOutput::return_to_parent(event, false))
16146 }
16147 fn finish_state(
16148 helper: &mut DeserializeHelper,
16149 state: FacetDeserializerState,
16150 ) -> Result<super::Facet, Error> {
16151 use FacetDeserializerState as S;
16152 match state {
16153 S::Init__ => Err(ErrorKind::MissingContent.into()),
16154 S::MinExclusive(mut values, None, deserializer) => {
16155 if let Some(deserializer) = deserializer {
16156 let value = deserializer.finish(helper)?;
16157 FacetDeserializer::store_min_exclusive(&mut values, value)?;
16158 }
16159 Ok(super::Facet::MinExclusive(
16160 helper.finish_element("minExclusive", values)?,
16161 ))
16162 }
16163 S::MinInclusive(mut values, None, deserializer) => {
16164 if let Some(deserializer) = deserializer {
16165 let value = deserializer.finish(helper)?;
16166 FacetDeserializer::store_min_inclusive(&mut values, value)?;
16167 }
16168 Ok(super::Facet::MinInclusive(
16169 helper.finish_element("minInclusive", values)?,
16170 ))
16171 }
16172 S::MaxExclusive(mut values, None, deserializer) => {
16173 if let Some(deserializer) = deserializer {
16174 let value = deserializer.finish(helper)?;
16175 FacetDeserializer::store_max_exclusive(&mut values, value)?;
16176 }
16177 Ok(super::Facet::MaxExclusive(
16178 helper.finish_element("maxExclusive", values)?,
16179 ))
16180 }
16181 S::MaxInclusive(mut values, None, deserializer) => {
16182 if let Some(deserializer) = deserializer {
16183 let value = deserializer.finish(helper)?;
16184 FacetDeserializer::store_max_inclusive(&mut values, value)?;
16185 }
16186 Ok(super::Facet::MaxInclusive(
16187 helper.finish_element("maxInclusive", values)?,
16188 ))
16189 }
16190 S::TotalDigits(mut values, None, deserializer) => {
16191 if let Some(deserializer) = deserializer {
16192 let value = deserializer.finish(helper)?;
16193 FacetDeserializer::store_total_digits(&mut values, value)?;
16194 }
16195 Ok(super::Facet::TotalDigits(
16196 helper.finish_element("totalDigits", values)?,
16197 ))
16198 }
16199 S::FractionDigits(mut values, None, deserializer) => {
16200 if let Some(deserializer) = deserializer {
16201 let value = deserializer.finish(helper)?;
16202 FacetDeserializer::store_fraction_digits(&mut values, value)?;
16203 }
16204 Ok(super::Facet::FractionDigits(
16205 helper.finish_element("fractionDigits", values)?,
16206 ))
16207 }
16208 S::Length(mut values, None, deserializer) => {
16209 if let Some(deserializer) = deserializer {
16210 let value = deserializer.finish(helper)?;
16211 FacetDeserializer::store_length(&mut values, value)?;
16212 }
16213 Ok(super::Facet::Length(
16214 helper.finish_element("length", values)?,
16215 ))
16216 }
16217 S::MinLength(mut values, None, deserializer) => {
16218 if let Some(deserializer) = deserializer {
16219 let value = deserializer.finish(helper)?;
16220 FacetDeserializer::store_min_length(&mut values, value)?;
16221 }
16222 Ok(super::Facet::MinLength(
16223 helper.finish_element("minLength", values)?,
16224 ))
16225 }
16226 S::MaxLength(mut values, None, deserializer) => {
16227 if let Some(deserializer) = deserializer {
16228 let value = deserializer.finish(helper)?;
16229 FacetDeserializer::store_max_length(&mut values, value)?;
16230 }
16231 Ok(super::Facet::MaxLength(
16232 helper.finish_element("maxLength", values)?,
16233 ))
16234 }
16235 S::Enumeration(mut values, None, deserializer) => {
16236 if let Some(deserializer) = deserializer {
16237 let value = deserializer.finish(helper)?;
16238 FacetDeserializer::store_enumeration(&mut values, value)?;
16239 }
16240 Ok(super::Facet::Enumeration(
16241 helper.finish_element("enumeration", values)?,
16242 ))
16243 }
16244 S::WhiteSpace(mut values, None, deserializer) => {
16245 if let Some(deserializer) = deserializer {
16246 let value = deserializer.finish(helper)?;
16247 FacetDeserializer::store_white_space(&mut values, value)?;
16248 }
16249 Ok(super::Facet::WhiteSpace(
16250 helper.finish_element("whiteSpace", values)?,
16251 ))
16252 }
16253 S::Pattern(mut values, None, deserializer) => {
16254 if let Some(deserializer) = deserializer {
16255 let value = deserializer.finish(helper)?;
16256 FacetDeserializer::store_pattern(&mut values, value)?;
16257 }
16258 Ok(super::Facet::Pattern(
16259 helper.finish_element("pattern", values)?,
16260 ))
16261 }
16262 S::Assertion(mut values, None, deserializer) => {
16263 if let Some(deserializer) = deserializer {
16264 let value = deserializer.finish(helper)?;
16265 FacetDeserializer::store_assertion(&mut values, value)?;
16266 }
16267 Ok(super::Facet::Assertion(
16268 helper.finish_element("assertion", values)?,
16269 ))
16270 }
16271 S::ExplicitTimezone(mut values, None, deserializer) => {
16272 if let Some(deserializer) = deserializer {
16273 let value = deserializer.finish(helper)?;
16274 FacetDeserializer::store_explicit_timezone(&mut values, value)?;
16275 }
16276 Ok(super::Facet::ExplicitTimezone(
16277 helper.finish_element("explicitTimezone", values)?,
16278 ))
16279 }
16280 S::Done__(data) => Ok(data),
16281 _ => unreachable!(),
16282 }
16283 }
16284 fn store_min_exclusive(
16285 values: &mut Option<super::FacetType>,
16286 value: super::FacetType,
16287 ) -> Result<(), Error> {
16288 if values.is_some() {
16289 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16290 b"minExclusive",
16291 )))?;
16292 }
16293 *values = Some(value);
16294 Ok(())
16295 }
16296 fn store_min_inclusive(
16297 values: &mut Option<super::FacetType>,
16298 value: super::FacetType,
16299 ) -> Result<(), Error> {
16300 if values.is_some() {
16301 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16302 b"minInclusive",
16303 )))?;
16304 }
16305 *values = Some(value);
16306 Ok(())
16307 }
16308 fn store_max_exclusive(
16309 values: &mut Option<super::FacetType>,
16310 value: super::FacetType,
16311 ) -> Result<(), Error> {
16312 if values.is_some() {
16313 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16314 b"maxExclusive",
16315 )))?;
16316 }
16317 *values = Some(value);
16318 Ok(())
16319 }
16320 fn store_max_inclusive(
16321 values: &mut Option<super::FacetType>,
16322 value: super::FacetType,
16323 ) -> Result<(), Error> {
16324 if values.is_some() {
16325 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16326 b"maxInclusive",
16327 )))?;
16328 }
16329 *values = Some(value);
16330 Ok(())
16331 }
16332 fn store_total_digits(
16333 values: &mut Option<super::FacetType>,
16334 value: super::FacetType,
16335 ) -> Result<(), Error> {
16336 if values.is_some() {
16337 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16338 b"totalDigits",
16339 )))?;
16340 }
16341 *values = Some(value);
16342 Ok(())
16343 }
16344 fn store_fraction_digits(
16345 values: &mut Option<super::FacetType>,
16346 value: super::FacetType,
16347 ) -> Result<(), Error> {
16348 if values.is_some() {
16349 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16350 b"fractionDigits",
16351 )))?;
16352 }
16353 *values = Some(value);
16354 Ok(())
16355 }
16356 fn store_length(
16357 values: &mut Option<super::FacetType>,
16358 value: super::FacetType,
16359 ) -> Result<(), Error> {
16360 if values.is_some() {
16361 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16362 b"length",
16363 )))?;
16364 }
16365 *values = Some(value);
16366 Ok(())
16367 }
16368 fn store_min_length(
16369 values: &mut Option<super::FacetType>,
16370 value: super::FacetType,
16371 ) -> Result<(), Error> {
16372 if values.is_some() {
16373 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16374 b"minLength",
16375 )))?;
16376 }
16377 *values = Some(value);
16378 Ok(())
16379 }
16380 fn store_max_length(
16381 values: &mut Option<super::FacetType>,
16382 value: super::FacetType,
16383 ) -> Result<(), Error> {
16384 if values.is_some() {
16385 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16386 b"maxLength",
16387 )))?;
16388 }
16389 *values = Some(value);
16390 Ok(())
16391 }
16392 fn store_enumeration(
16393 values: &mut Option<super::FacetType>,
16394 value: super::FacetType,
16395 ) -> Result<(), Error> {
16396 if values.is_some() {
16397 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16398 b"enumeration",
16399 )))?;
16400 }
16401 *values = Some(value);
16402 Ok(())
16403 }
16404 fn store_white_space(
16405 values: &mut Option<super::FacetType>,
16406 value: super::FacetType,
16407 ) -> Result<(), Error> {
16408 if values.is_some() {
16409 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16410 b"whiteSpace",
16411 )))?;
16412 }
16413 *values = Some(value);
16414 Ok(())
16415 }
16416 fn store_pattern(
16417 values: &mut Option<super::FacetType>,
16418 value: super::FacetType,
16419 ) -> Result<(), Error> {
16420 if values.is_some() {
16421 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16422 b"pattern",
16423 )))?;
16424 }
16425 *values = Some(value);
16426 Ok(())
16427 }
16428 fn store_assertion(
16429 values: &mut Option<super::AssertionType>,
16430 value: super::AssertionType,
16431 ) -> Result<(), Error> {
16432 if values.is_some() {
16433 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16434 b"assertion",
16435 )))?;
16436 }
16437 *values = Some(value);
16438 Ok(())
16439 }
16440 fn store_explicit_timezone(
16441 values: &mut Option<super::FacetType>,
16442 value: super::FacetType,
16443 ) -> Result<(), Error> {
16444 if values.is_some() {
16445 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
16446 b"explicitTimezone",
16447 )))?;
16448 }
16449 *values = Some(value);
16450 Ok(())
16451 }
16452 fn handle_min_exclusive<'de>(
16453 &mut self,
16454 helper: &mut DeserializeHelper,
16455 mut values: Option<super::FacetType>,
16456 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16457 output: DeserializerOutput<'de, super::FacetType>,
16458 ) -> Result<ElementHandlerOutput<'de>, Error> {
16459 use FacetDeserializerState as S;
16460 let DeserializerOutput {
16461 artifact,
16462 event,
16463 allow_any,
16464 } = output;
16465 if artifact.is_none() {
16466 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16467 }
16468 if let Some(deserializer) = fallback {
16469 let data = deserializer.finish(helper)?;
16470 FacetDeserializer::store_min_exclusive(&mut values, data)?;
16471 }
16472 match artifact {
16473 DeserializerArtifact::None => unreachable!(),
16474 DeserializerArtifact::Data(data) => {
16475 FacetDeserializer::store_min_exclusive(&mut values, data)?;
16476 let data = FacetDeserializer::finish_state(
16477 helper,
16478 S::MinExclusive(values, None, None),
16479 )?;
16480 *self.state__ = S::Done__(data);
16481 Ok(ElementHandlerOutput::break_(event, allow_any))
16482 }
16483 DeserializerArtifact::Deserializer(deserializer) => {
16484 *self.state__ = S::MinExclusive(values, None, Some(deserializer));
16485 Ok(ElementHandlerOutput::break_(event, allow_any))
16486 }
16487 }
16488 }
16489 fn handle_min_inclusive<'de>(
16490 &mut self,
16491 helper: &mut DeserializeHelper,
16492 mut values: Option<super::FacetType>,
16493 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16494 output: DeserializerOutput<'de, super::FacetType>,
16495 ) -> Result<ElementHandlerOutput<'de>, Error> {
16496 use FacetDeserializerState as S;
16497 let DeserializerOutput {
16498 artifact,
16499 event,
16500 allow_any,
16501 } = output;
16502 if artifact.is_none() {
16503 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16504 }
16505 if let Some(deserializer) = fallback {
16506 let data = deserializer.finish(helper)?;
16507 FacetDeserializer::store_min_inclusive(&mut values, data)?;
16508 }
16509 match artifact {
16510 DeserializerArtifact::None => unreachable!(),
16511 DeserializerArtifact::Data(data) => {
16512 FacetDeserializer::store_min_inclusive(&mut values, data)?;
16513 let data = FacetDeserializer::finish_state(
16514 helper,
16515 S::MinInclusive(values, None, None),
16516 )?;
16517 *self.state__ = S::Done__(data);
16518 Ok(ElementHandlerOutput::break_(event, allow_any))
16519 }
16520 DeserializerArtifact::Deserializer(deserializer) => {
16521 *self.state__ = S::MinInclusive(values, None, Some(deserializer));
16522 Ok(ElementHandlerOutput::break_(event, allow_any))
16523 }
16524 }
16525 }
16526 fn handle_max_exclusive<'de>(
16527 &mut self,
16528 helper: &mut DeserializeHelper,
16529 mut values: Option<super::FacetType>,
16530 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16531 output: DeserializerOutput<'de, super::FacetType>,
16532 ) -> Result<ElementHandlerOutput<'de>, Error> {
16533 use FacetDeserializerState as S;
16534 let DeserializerOutput {
16535 artifact,
16536 event,
16537 allow_any,
16538 } = output;
16539 if artifact.is_none() {
16540 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16541 }
16542 if let Some(deserializer) = fallback {
16543 let data = deserializer.finish(helper)?;
16544 FacetDeserializer::store_max_exclusive(&mut values, data)?;
16545 }
16546 match artifact {
16547 DeserializerArtifact::None => unreachable!(),
16548 DeserializerArtifact::Data(data) => {
16549 FacetDeserializer::store_max_exclusive(&mut values, data)?;
16550 let data = FacetDeserializer::finish_state(
16551 helper,
16552 S::MaxExclusive(values, None, None),
16553 )?;
16554 *self.state__ = S::Done__(data);
16555 Ok(ElementHandlerOutput::break_(event, allow_any))
16556 }
16557 DeserializerArtifact::Deserializer(deserializer) => {
16558 *self.state__ = S::MaxExclusive(values, None, Some(deserializer));
16559 Ok(ElementHandlerOutput::break_(event, allow_any))
16560 }
16561 }
16562 }
16563 fn handle_max_inclusive<'de>(
16564 &mut self,
16565 helper: &mut DeserializeHelper,
16566 mut values: Option<super::FacetType>,
16567 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16568 output: DeserializerOutput<'de, super::FacetType>,
16569 ) -> Result<ElementHandlerOutput<'de>, Error> {
16570 use FacetDeserializerState as S;
16571 let DeserializerOutput {
16572 artifact,
16573 event,
16574 allow_any,
16575 } = output;
16576 if artifact.is_none() {
16577 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16578 }
16579 if let Some(deserializer) = fallback {
16580 let data = deserializer.finish(helper)?;
16581 FacetDeserializer::store_max_inclusive(&mut values, data)?;
16582 }
16583 match artifact {
16584 DeserializerArtifact::None => unreachable!(),
16585 DeserializerArtifact::Data(data) => {
16586 FacetDeserializer::store_max_inclusive(&mut values, data)?;
16587 let data = FacetDeserializer::finish_state(
16588 helper,
16589 S::MaxInclusive(values, None, None),
16590 )?;
16591 *self.state__ = S::Done__(data);
16592 Ok(ElementHandlerOutput::break_(event, allow_any))
16593 }
16594 DeserializerArtifact::Deserializer(deserializer) => {
16595 *self.state__ = S::MaxInclusive(values, None, Some(deserializer));
16596 Ok(ElementHandlerOutput::break_(event, allow_any))
16597 }
16598 }
16599 }
16600 fn handle_total_digits<'de>(
16601 &mut self,
16602 helper: &mut DeserializeHelper,
16603 mut values: Option<super::FacetType>,
16604 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16605 output: DeserializerOutput<'de, super::FacetType>,
16606 ) -> Result<ElementHandlerOutput<'de>, Error> {
16607 use FacetDeserializerState as S;
16608 let DeserializerOutput {
16609 artifact,
16610 event,
16611 allow_any,
16612 } = output;
16613 if artifact.is_none() {
16614 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16615 }
16616 if let Some(deserializer) = fallback {
16617 let data = deserializer.finish(helper)?;
16618 FacetDeserializer::store_total_digits(&mut values, data)?;
16619 }
16620 match artifact {
16621 DeserializerArtifact::None => unreachable!(),
16622 DeserializerArtifact::Data(data) => {
16623 FacetDeserializer::store_total_digits(&mut values, data)?;
16624 let data = FacetDeserializer::finish_state(
16625 helper,
16626 S::TotalDigits(values, None, None),
16627 )?;
16628 *self.state__ = S::Done__(data);
16629 Ok(ElementHandlerOutput::break_(event, allow_any))
16630 }
16631 DeserializerArtifact::Deserializer(deserializer) => {
16632 *self.state__ = S::TotalDigits(values, None, Some(deserializer));
16633 Ok(ElementHandlerOutput::break_(event, allow_any))
16634 }
16635 }
16636 }
16637 fn handle_fraction_digits<'de>(
16638 &mut self,
16639 helper: &mut DeserializeHelper,
16640 mut values: Option<super::FacetType>,
16641 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16642 output: DeserializerOutput<'de, super::FacetType>,
16643 ) -> Result<ElementHandlerOutput<'de>, Error> {
16644 use FacetDeserializerState as S;
16645 let DeserializerOutput {
16646 artifact,
16647 event,
16648 allow_any,
16649 } = output;
16650 if artifact.is_none() {
16651 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16652 }
16653 if let Some(deserializer) = fallback {
16654 let data = deserializer.finish(helper)?;
16655 FacetDeserializer::store_fraction_digits(&mut values, data)?;
16656 }
16657 match artifact {
16658 DeserializerArtifact::None => unreachable!(),
16659 DeserializerArtifact::Data(data) => {
16660 FacetDeserializer::store_fraction_digits(&mut values, data)?;
16661 let data = FacetDeserializer::finish_state(
16662 helper,
16663 S::FractionDigits(values, None, None),
16664 )?;
16665 *self.state__ = S::Done__(data);
16666 Ok(ElementHandlerOutput::break_(event, allow_any))
16667 }
16668 DeserializerArtifact::Deserializer(deserializer) => {
16669 *self.state__ = S::FractionDigits(values, None, Some(deserializer));
16670 Ok(ElementHandlerOutput::break_(event, allow_any))
16671 }
16672 }
16673 }
16674 fn handle_length<'de>(
16675 &mut self,
16676 helper: &mut DeserializeHelper,
16677 mut values: Option<super::FacetType>,
16678 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16679 output: DeserializerOutput<'de, super::FacetType>,
16680 ) -> Result<ElementHandlerOutput<'de>, Error> {
16681 use FacetDeserializerState as S;
16682 let DeserializerOutput {
16683 artifact,
16684 event,
16685 allow_any,
16686 } = output;
16687 if artifact.is_none() {
16688 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16689 }
16690 if let Some(deserializer) = fallback {
16691 let data = deserializer.finish(helper)?;
16692 FacetDeserializer::store_length(&mut values, data)?;
16693 }
16694 match artifact {
16695 DeserializerArtifact::None => unreachable!(),
16696 DeserializerArtifact::Data(data) => {
16697 FacetDeserializer::store_length(&mut values, data)?;
16698 let data =
16699 FacetDeserializer::finish_state(helper, S::Length(values, None, None))?;
16700 *self.state__ = S::Done__(data);
16701 Ok(ElementHandlerOutput::break_(event, allow_any))
16702 }
16703 DeserializerArtifact::Deserializer(deserializer) => {
16704 *self.state__ = S::Length(values, None, Some(deserializer));
16705 Ok(ElementHandlerOutput::break_(event, allow_any))
16706 }
16707 }
16708 }
16709 fn handle_min_length<'de>(
16710 &mut self,
16711 helper: &mut DeserializeHelper,
16712 mut values: Option<super::FacetType>,
16713 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16714 output: DeserializerOutput<'de, super::FacetType>,
16715 ) -> Result<ElementHandlerOutput<'de>, Error> {
16716 use FacetDeserializerState as S;
16717 let DeserializerOutput {
16718 artifact,
16719 event,
16720 allow_any,
16721 } = output;
16722 if artifact.is_none() {
16723 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16724 }
16725 if let Some(deserializer) = fallback {
16726 let data = deserializer.finish(helper)?;
16727 FacetDeserializer::store_min_length(&mut values, data)?;
16728 }
16729 match artifact {
16730 DeserializerArtifact::None => unreachable!(),
16731 DeserializerArtifact::Data(data) => {
16732 FacetDeserializer::store_min_length(&mut values, data)?;
16733 let data =
16734 FacetDeserializer::finish_state(helper, S::MinLength(values, None, None))?;
16735 *self.state__ = S::Done__(data);
16736 Ok(ElementHandlerOutput::break_(event, allow_any))
16737 }
16738 DeserializerArtifact::Deserializer(deserializer) => {
16739 *self.state__ = S::MinLength(values, None, Some(deserializer));
16740 Ok(ElementHandlerOutput::break_(event, allow_any))
16741 }
16742 }
16743 }
16744 fn handle_max_length<'de>(
16745 &mut self,
16746 helper: &mut DeserializeHelper,
16747 mut values: Option<super::FacetType>,
16748 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16749 output: DeserializerOutput<'de, super::FacetType>,
16750 ) -> Result<ElementHandlerOutput<'de>, Error> {
16751 use FacetDeserializerState as S;
16752 let DeserializerOutput {
16753 artifact,
16754 event,
16755 allow_any,
16756 } = output;
16757 if artifact.is_none() {
16758 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16759 }
16760 if let Some(deserializer) = fallback {
16761 let data = deserializer.finish(helper)?;
16762 FacetDeserializer::store_max_length(&mut values, data)?;
16763 }
16764 match artifact {
16765 DeserializerArtifact::None => unreachable!(),
16766 DeserializerArtifact::Data(data) => {
16767 FacetDeserializer::store_max_length(&mut values, data)?;
16768 let data =
16769 FacetDeserializer::finish_state(helper, S::MaxLength(values, None, None))?;
16770 *self.state__ = S::Done__(data);
16771 Ok(ElementHandlerOutput::break_(event, allow_any))
16772 }
16773 DeserializerArtifact::Deserializer(deserializer) => {
16774 *self.state__ = S::MaxLength(values, None, Some(deserializer));
16775 Ok(ElementHandlerOutput::break_(event, allow_any))
16776 }
16777 }
16778 }
16779 fn handle_enumeration<'de>(
16780 &mut self,
16781 helper: &mut DeserializeHelper,
16782 mut values: Option<super::FacetType>,
16783 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16784 output: DeserializerOutput<'de, super::FacetType>,
16785 ) -> Result<ElementHandlerOutput<'de>, Error> {
16786 use FacetDeserializerState as S;
16787 let DeserializerOutput {
16788 artifact,
16789 event,
16790 allow_any,
16791 } = output;
16792 if artifact.is_none() {
16793 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16794 }
16795 if let Some(deserializer) = fallback {
16796 let data = deserializer.finish(helper)?;
16797 FacetDeserializer::store_enumeration(&mut values, data)?;
16798 }
16799 match artifact {
16800 DeserializerArtifact::None => unreachable!(),
16801 DeserializerArtifact::Data(data) => {
16802 FacetDeserializer::store_enumeration(&mut values, data)?;
16803 let data = FacetDeserializer::finish_state(
16804 helper,
16805 S::Enumeration(values, None, None),
16806 )?;
16807 *self.state__ = S::Done__(data);
16808 Ok(ElementHandlerOutput::break_(event, allow_any))
16809 }
16810 DeserializerArtifact::Deserializer(deserializer) => {
16811 *self.state__ = S::Enumeration(values, None, Some(deserializer));
16812 Ok(ElementHandlerOutput::break_(event, allow_any))
16813 }
16814 }
16815 }
16816 fn handle_white_space<'de>(
16817 &mut self,
16818 helper: &mut DeserializeHelper,
16819 mut values: Option<super::FacetType>,
16820 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16821 output: DeserializerOutput<'de, super::FacetType>,
16822 ) -> Result<ElementHandlerOutput<'de>, Error> {
16823 use FacetDeserializerState as S;
16824 let DeserializerOutput {
16825 artifact,
16826 event,
16827 allow_any,
16828 } = output;
16829 if artifact.is_none() {
16830 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16831 }
16832 if let Some(deserializer) = fallback {
16833 let data = deserializer.finish(helper)?;
16834 FacetDeserializer::store_white_space(&mut values, data)?;
16835 }
16836 match artifact {
16837 DeserializerArtifact::None => unreachable!(),
16838 DeserializerArtifact::Data(data) => {
16839 FacetDeserializer::store_white_space(&mut values, data)?;
16840 let data =
16841 FacetDeserializer::finish_state(helper, S::WhiteSpace(values, None, None))?;
16842 *self.state__ = S::Done__(data);
16843 Ok(ElementHandlerOutput::break_(event, allow_any))
16844 }
16845 DeserializerArtifact::Deserializer(deserializer) => {
16846 *self.state__ = S::WhiteSpace(values, None, Some(deserializer));
16847 Ok(ElementHandlerOutput::break_(event, allow_any))
16848 }
16849 }
16850 }
16851 fn handle_pattern<'de>(
16852 &mut self,
16853 helper: &mut DeserializeHelper,
16854 mut values: Option<super::FacetType>,
16855 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16856 output: DeserializerOutput<'de, super::FacetType>,
16857 ) -> Result<ElementHandlerOutput<'de>, Error> {
16858 use FacetDeserializerState as S;
16859 let DeserializerOutput {
16860 artifact,
16861 event,
16862 allow_any,
16863 } = output;
16864 if artifact.is_none() {
16865 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16866 }
16867 if let Some(deserializer) = fallback {
16868 let data = deserializer.finish(helper)?;
16869 FacetDeserializer::store_pattern(&mut values, data)?;
16870 }
16871 match artifact {
16872 DeserializerArtifact::None => unreachable!(),
16873 DeserializerArtifact::Data(data) => {
16874 FacetDeserializer::store_pattern(&mut values, data)?;
16875 let data =
16876 FacetDeserializer::finish_state(helper, S::Pattern(values, None, None))?;
16877 *self.state__ = S::Done__(data);
16878 Ok(ElementHandlerOutput::break_(event, allow_any))
16879 }
16880 DeserializerArtifact::Deserializer(deserializer) => {
16881 *self.state__ = S::Pattern(values, None, Some(deserializer));
16882 Ok(ElementHandlerOutput::break_(event, allow_any))
16883 }
16884 }
16885 }
16886 fn handle_assertion<'de>(
16887 &mut self,
16888 helper: &mut DeserializeHelper,
16889 mut values: Option<super::AssertionType>,
16890 fallback: Option<<super::AssertionType as WithDeserializer>::Deserializer>,
16891 output: DeserializerOutput<'de, super::AssertionType>,
16892 ) -> Result<ElementHandlerOutput<'de>, Error> {
16893 use FacetDeserializerState as S;
16894 let DeserializerOutput {
16895 artifact,
16896 event,
16897 allow_any,
16898 } = output;
16899 if artifact.is_none() {
16900 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16901 }
16902 if let Some(deserializer) = fallback {
16903 let data = deserializer.finish(helper)?;
16904 FacetDeserializer::store_assertion(&mut values, data)?;
16905 }
16906 match artifact {
16907 DeserializerArtifact::None => unreachable!(),
16908 DeserializerArtifact::Data(data) => {
16909 FacetDeserializer::store_assertion(&mut values, data)?;
16910 let data =
16911 FacetDeserializer::finish_state(helper, S::Assertion(values, None, None))?;
16912 *self.state__ = S::Done__(data);
16913 Ok(ElementHandlerOutput::break_(event, allow_any))
16914 }
16915 DeserializerArtifact::Deserializer(deserializer) => {
16916 *self.state__ = S::Assertion(values, None, Some(deserializer));
16917 Ok(ElementHandlerOutput::break_(event, allow_any))
16918 }
16919 }
16920 }
16921 fn handle_explicit_timezone<'de>(
16922 &mut self,
16923 helper: &mut DeserializeHelper,
16924 mut values: Option<super::FacetType>,
16925 fallback: Option<<super::FacetType as WithDeserializer>::Deserializer>,
16926 output: DeserializerOutput<'de, super::FacetType>,
16927 ) -> Result<ElementHandlerOutput<'de>, Error> {
16928 use FacetDeserializerState as S;
16929 let DeserializerOutput {
16930 artifact,
16931 event,
16932 allow_any,
16933 } = output;
16934 if artifact.is_none() {
16935 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
16936 }
16937 if let Some(deserializer) = fallback {
16938 let data = deserializer.finish(helper)?;
16939 FacetDeserializer::store_explicit_timezone(&mut values, data)?;
16940 }
16941 match artifact {
16942 DeserializerArtifact::None => unreachable!(),
16943 DeserializerArtifact::Data(data) => {
16944 FacetDeserializer::store_explicit_timezone(&mut values, data)?;
16945 let data = FacetDeserializer::finish_state(
16946 helper,
16947 S::ExplicitTimezone(values, None, None),
16948 )?;
16949 *self.state__ = S::Done__(data);
16950 Ok(ElementHandlerOutput::break_(event, allow_any))
16951 }
16952 DeserializerArtifact::Deserializer(deserializer) => {
16953 *self.state__ = S::ExplicitTimezone(values, None, Some(deserializer));
16954 Ok(ElementHandlerOutput::break_(event, allow_any))
16955 }
16956 }
16957 }
16958 }
16959 impl<'de> Deserializer<'de, super::Facet> for Box<FacetDeserializer> {
16960 fn init(
16961 helper: &mut DeserializeHelper,
16962 event: Event<'de>,
16963 ) -> DeserializerResult<'de, super::Facet> {
16964 let deserializer = Box::new(FacetDeserializer {
16965 state__: Box::new(FacetDeserializerState::Init__),
16966 });
16967 let mut output = deserializer.next(helper, event)?;
16968 output.artifact = match output.artifact {
16969 DeserializerArtifact::Deserializer(x)
16970 if matches!(&*x.state__, FacetDeserializerState::Init__) =>
16971 {
16972 DeserializerArtifact::None
16973 }
16974 artifact => artifact,
16975 };
16976 Ok(output)
16977 }
16978 fn next(
16979 mut self,
16980 helper: &mut DeserializeHelper,
16981 event: Event<'de>,
16982 ) -> DeserializerResult<'de, super::Facet> {
16983 use FacetDeserializerState as S;
16984 let mut event = event;
16985 let (event, allow_any) = loop {
16986 let state = replace(&mut *self.state__, S::Unknown__);
16987 event = match (state, event) {
16988 (S::Unknown__, _) => unreachable!(),
16989 (S::MinExclusive(values, fallback, Some(deserializer)), event) => {
16990 let output = deserializer.next(helper, event)?;
16991 match self.handle_min_exclusive(helper, values, fallback, output)? {
16992 ElementHandlerOutput::Break { event, allow_any } => {
16993 break (event, allow_any)
16994 }
16995 ElementHandlerOutput::Continue { event, .. } => event,
16996 }
16997 }
16998 (S::MinInclusive(values, fallback, Some(deserializer)), event) => {
16999 let output = deserializer.next(helper, event)?;
17000 match self.handle_min_inclusive(helper, values, fallback, output)? {
17001 ElementHandlerOutput::Break { event, allow_any } => {
17002 break (event, allow_any)
17003 }
17004 ElementHandlerOutput::Continue { event, .. } => event,
17005 }
17006 }
17007 (S::MaxExclusive(values, fallback, Some(deserializer)), event) => {
17008 let output = deserializer.next(helper, event)?;
17009 match self.handle_max_exclusive(helper, values, fallback, output)? {
17010 ElementHandlerOutput::Break { event, allow_any } => {
17011 break (event, allow_any)
17012 }
17013 ElementHandlerOutput::Continue { event, .. } => event,
17014 }
17015 }
17016 (S::MaxInclusive(values, fallback, Some(deserializer)), event) => {
17017 let output = deserializer.next(helper, event)?;
17018 match self.handle_max_inclusive(helper, values, fallback, output)? {
17019 ElementHandlerOutput::Break { event, allow_any } => {
17020 break (event, allow_any)
17021 }
17022 ElementHandlerOutput::Continue { event, .. } => event,
17023 }
17024 }
17025 (S::TotalDigits(values, fallback, Some(deserializer)), event) => {
17026 let output = deserializer.next(helper, event)?;
17027 match self.handle_total_digits(helper, values, fallback, output)? {
17028 ElementHandlerOutput::Break { event, allow_any } => {
17029 break (event, allow_any)
17030 }
17031 ElementHandlerOutput::Continue { event, .. } => event,
17032 }
17033 }
17034 (S::FractionDigits(values, fallback, Some(deserializer)), event) => {
17035 let output = deserializer.next(helper, event)?;
17036 match self.handle_fraction_digits(helper, values, fallback, output)? {
17037 ElementHandlerOutput::Break { event, allow_any } => {
17038 break (event, allow_any)
17039 }
17040 ElementHandlerOutput::Continue { event, .. } => event,
17041 }
17042 }
17043 (S::Length(values, fallback, Some(deserializer)), event) => {
17044 let output = deserializer.next(helper, event)?;
17045 match self.handle_length(helper, values, fallback, output)? {
17046 ElementHandlerOutput::Break { event, allow_any } => {
17047 break (event, allow_any)
17048 }
17049 ElementHandlerOutput::Continue { event, .. } => event,
17050 }
17051 }
17052 (S::MinLength(values, fallback, Some(deserializer)), event) => {
17053 let output = deserializer.next(helper, event)?;
17054 match self.handle_min_length(helper, values, fallback, output)? {
17055 ElementHandlerOutput::Break { event, allow_any } => {
17056 break (event, allow_any)
17057 }
17058 ElementHandlerOutput::Continue { event, .. } => event,
17059 }
17060 }
17061 (S::MaxLength(values, fallback, Some(deserializer)), event) => {
17062 let output = deserializer.next(helper, event)?;
17063 match self.handle_max_length(helper, values, fallback, output)? {
17064 ElementHandlerOutput::Break { event, allow_any } => {
17065 break (event, allow_any)
17066 }
17067 ElementHandlerOutput::Continue { event, .. } => event,
17068 }
17069 }
17070 (S::Enumeration(values, fallback, Some(deserializer)), event) => {
17071 let output = deserializer.next(helper, event)?;
17072 match self.handle_enumeration(helper, values, fallback, output)? {
17073 ElementHandlerOutput::Break { event, allow_any } => {
17074 break (event, allow_any)
17075 }
17076 ElementHandlerOutput::Continue { event, .. } => event,
17077 }
17078 }
17079 (S::WhiteSpace(values, fallback, Some(deserializer)), event) => {
17080 let output = deserializer.next(helper, event)?;
17081 match self.handle_white_space(helper, values, fallback, output)? {
17082 ElementHandlerOutput::Break { event, allow_any } => {
17083 break (event, allow_any)
17084 }
17085 ElementHandlerOutput::Continue { event, .. } => event,
17086 }
17087 }
17088 (S::Pattern(values, fallback, Some(deserializer)), event) => {
17089 let output = deserializer.next(helper, event)?;
17090 match self.handle_pattern(helper, values, fallback, output)? {
17091 ElementHandlerOutput::Break { event, allow_any } => {
17092 break (event, allow_any)
17093 }
17094 ElementHandlerOutput::Continue { event, .. } => event,
17095 }
17096 }
17097 (S::Assertion(values, fallback, Some(deserializer)), event) => {
17098 let output = deserializer.next(helper, event)?;
17099 match self.handle_assertion(helper, values, fallback, output)? {
17100 ElementHandlerOutput::Break { event, allow_any } => {
17101 break (event, allow_any)
17102 }
17103 ElementHandlerOutput::Continue { event, .. } => event,
17104 }
17105 }
17106 (S::ExplicitTimezone(values, fallback, Some(deserializer)), event) => {
17107 let output = deserializer.next(helper, event)?;
17108 match self.handle_explicit_timezone(helper, values, fallback, output)? {
17109 ElementHandlerOutput::Break { event, allow_any } => {
17110 break (event, allow_any)
17111 }
17112 ElementHandlerOutput::Continue { event, .. } => event,
17113 }
17114 }
17115 (state, event @ Event::End(_)) => {
17116 return Ok(DeserializerOutput {
17117 artifact: DeserializerArtifact::Data(FacetDeserializer::finish_state(
17118 helper, state,
17119 )?),
17120 event: DeserializerEvent::Continue(event),
17121 allow_any: false,
17122 });
17123 }
17124 (S::Init__, event) => match self.find_suitable(helper, event)? {
17125 ElementHandlerOutput::Break { event, allow_any } => {
17126 break (event, allow_any)
17127 }
17128 ElementHandlerOutput::Continue { event, .. } => event,
17129 },
17130 (
17131 S::MinExclusive(values, fallback, None),
17132 event @ (Event::Start(_) | Event::Empty(_)),
17133 ) => {
17134 let output = helper.init_start_tag_deserializer(
17135 event,
17136 Some(&super::NS_XS),
17137 b"minExclusive",
17138 false,
17139 )?;
17140 match self.handle_min_exclusive(helper, values, fallback, output)? {
17141 ElementHandlerOutput::Break { event, allow_any } => {
17142 break (event, allow_any)
17143 }
17144 ElementHandlerOutput::Continue { event, .. } => event,
17145 }
17146 }
17147 (
17148 S::MinInclusive(values, fallback, None),
17149 event @ (Event::Start(_) | Event::Empty(_)),
17150 ) => {
17151 let output = helper.init_start_tag_deserializer(
17152 event,
17153 Some(&super::NS_XS),
17154 b"minInclusive",
17155 false,
17156 )?;
17157 match self.handle_min_inclusive(helper, values, fallback, output)? {
17158 ElementHandlerOutput::Break { event, allow_any } => {
17159 break (event, allow_any)
17160 }
17161 ElementHandlerOutput::Continue { event, .. } => event,
17162 }
17163 }
17164 (
17165 S::MaxExclusive(values, fallback, None),
17166 event @ (Event::Start(_) | Event::Empty(_)),
17167 ) => {
17168 let output = helper.init_start_tag_deserializer(
17169 event,
17170 Some(&super::NS_XS),
17171 b"maxExclusive",
17172 false,
17173 )?;
17174 match self.handle_max_exclusive(helper, values, fallback, output)? {
17175 ElementHandlerOutput::Break { event, allow_any } => {
17176 break (event, allow_any)
17177 }
17178 ElementHandlerOutput::Continue { event, .. } => event,
17179 }
17180 }
17181 (
17182 S::MaxInclusive(values, fallback, None),
17183 event @ (Event::Start(_) | Event::Empty(_)),
17184 ) => {
17185 let output = helper.init_start_tag_deserializer(
17186 event,
17187 Some(&super::NS_XS),
17188 b"maxInclusive",
17189 false,
17190 )?;
17191 match self.handle_max_inclusive(helper, values, fallback, output)? {
17192 ElementHandlerOutput::Break { event, allow_any } => {
17193 break (event, allow_any)
17194 }
17195 ElementHandlerOutput::Continue { event, .. } => event,
17196 }
17197 }
17198 (
17199 S::TotalDigits(values, fallback, None),
17200 event @ (Event::Start(_) | Event::Empty(_)),
17201 ) => {
17202 let output = helper.init_start_tag_deserializer(
17203 event,
17204 Some(&super::NS_XS),
17205 b"totalDigits",
17206 false,
17207 )?;
17208 match self.handle_total_digits(helper, values, fallback, output)? {
17209 ElementHandlerOutput::Break { event, allow_any } => {
17210 break (event, allow_any)
17211 }
17212 ElementHandlerOutput::Continue { event, .. } => event,
17213 }
17214 }
17215 (
17216 S::FractionDigits(values, fallback, None),
17217 event @ (Event::Start(_) | Event::Empty(_)),
17218 ) => {
17219 let output = helper.init_start_tag_deserializer(
17220 event,
17221 Some(&super::NS_XS),
17222 b"fractionDigits",
17223 false,
17224 )?;
17225 match self.handle_fraction_digits(helper, values, fallback, output)? {
17226 ElementHandlerOutput::Break { event, allow_any } => {
17227 break (event, allow_any)
17228 }
17229 ElementHandlerOutput::Continue { event, .. } => event,
17230 }
17231 }
17232 (
17233 S::Length(values, fallback, None),
17234 event @ (Event::Start(_) | Event::Empty(_)),
17235 ) => {
17236 let output = helper.init_start_tag_deserializer(
17237 event,
17238 Some(&super::NS_XS),
17239 b"length",
17240 false,
17241 )?;
17242 match self.handle_length(helper, values, fallback, output)? {
17243 ElementHandlerOutput::Break { event, allow_any } => {
17244 break (event, allow_any)
17245 }
17246 ElementHandlerOutput::Continue { event, .. } => event,
17247 }
17248 }
17249 (
17250 S::MinLength(values, fallback, None),
17251 event @ (Event::Start(_) | Event::Empty(_)),
17252 ) => {
17253 let output = helper.init_start_tag_deserializer(
17254 event,
17255 Some(&super::NS_XS),
17256 b"minLength",
17257 false,
17258 )?;
17259 match self.handle_min_length(helper, values, fallback, output)? {
17260 ElementHandlerOutput::Break { event, allow_any } => {
17261 break (event, allow_any)
17262 }
17263 ElementHandlerOutput::Continue { event, .. } => event,
17264 }
17265 }
17266 (
17267 S::MaxLength(values, fallback, None),
17268 event @ (Event::Start(_) | Event::Empty(_)),
17269 ) => {
17270 let output = helper.init_start_tag_deserializer(
17271 event,
17272 Some(&super::NS_XS),
17273 b"maxLength",
17274 false,
17275 )?;
17276 match self.handle_max_length(helper, values, fallback, output)? {
17277 ElementHandlerOutput::Break { event, allow_any } => {
17278 break (event, allow_any)
17279 }
17280 ElementHandlerOutput::Continue { event, .. } => event,
17281 }
17282 }
17283 (
17284 S::Enumeration(values, fallback, None),
17285 event @ (Event::Start(_) | Event::Empty(_)),
17286 ) => {
17287 let output = helper.init_start_tag_deserializer(
17288 event,
17289 Some(&super::NS_XS),
17290 b"enumeration",
17291 false,
17292 )?;
17293 match self.handle_enumeration(helper, values, fallback, output)? {
17294 ElementHandlerOutput::Break { event, allow_any } => {
17295 break (event, allow_any)
17296 }
17297 ElementHandlerOutput::Continue { event, .. } => event,
17298 }
17299 }
17300 (
17301 S::WhiteSpace(values, fallback, None),
17302 event @ (Event::Start(_) | Event::Empty(_)),
17303 ) => {
17304 let output = helper.init_start_tag_deserializer(
17305 event,
17306 Some(&super::NS_XS),
17307 b"whiteSpace",
17308 false,
17309 )?;
17310 match self.handle_white_space(helper, values, fallback, output)? {
17311 ElementHandlerOutput::Break { event, allow_any } => {
17312 break (event, allow_any)
17313 }
17314 ElementHandlerOutput::Continue { event, .. } => event,
17315 }
17316 }
17317 (
17318 S::Pattern(values, fallback, None),
17319 event @ (Event::Start(_) | Event::Empty(_)),
17320 ) => {
17321 let output = helper.init_start_tag_deserializer(
17322 event,
17323 Some(&super::NS_XS),
17324 b"pattern",
17325 false,
17326 )?;
17327 match self.handle_pattern(helper, values, fallback, output)? {
17328 ElementHandlerOutput::Break { event, allow_any } => {
17329 break (event, allow_any)
17330 }
17331 ElementHandlerOutput::Continue { event, .. } => event,
17332 }
17333 }
17334 (
17335 S::Assertion(values, fallback, None),
17336 event @ (Event::Start(_) | Event::Empty(_)),
17337 ) => {
17338 let output = helper.init_start_tag_deserializer(
17339 event,
17340 Some(&super::NS_XS),
17341 b"assertion",
17342 false,
17343 )?;
17344 match self.handle_assertion(helper, values, fallback, output)? {
17345 ElementHandlerOutput::Break { event, allow_any } => {
17346 break (event, allow_any)
17347 }
17348 ElementHandlerOutput::Continue { event, .. } => event,
17349 }
17350 }
17351 (
17352 S::ExplicitTimezone(values, fallback, None),
17353 event @ (Event::Start(_) | Event::Empty(_)),
17354 ) => {
17355 let output = helper.init_start_tag_deserializer(
17356 event,
17357 Some(&super::NS_XS),
17358 b"explicitTimezone",
17359 false,
17360 )?;
17361 match self.handle_explicit_timezone(helper, values, fallback, output)? {
17362 ElementHandlerOutput::Break { event, allow_any } => {
17363 break (event, allow_any)
17364 }
17365 ElementHandlerOutput::Continue { event, .. } => event,
17366 }
17367 }
17368 (state @ S::Done__(_), event) => {
17369 *self.state__ = state;
17370 break (DeserializerEvent::Continue(event), false);
17371 }
17372 (state, event) => {
17373 *self.state__ = state;
17374 break (DeserializerEvent::Continue(event), false);
17375 }
17376 }
17377 };
17378 let artifact = if matches!(&*self.state__, S::Done__(_)) {
17379 DeserializerArtifact::Data(self.finish(helper)?)
17380 } else {
17381 DeserializerArtifact::Deserializer(self)
17382 };
17383 Ok(DeserializerOutput {
17384 artifact,
17385 event,
17386 allow_any,
17387 })
17388 }
17389 fn finish(self, helper: &mut DeserializeHelper) -> Result<super::Facet, Error> {
17390 FacetDeserializer::finish_state(helper, *self.state__)
17391 }
17392 }
17393 #[derive(Debug)]
17394 pub struct RestrictionTypeDeserializer {
17395 id: Option<String>,
17396 base: QName,
17397 content: Vec<super::RestrictionTypeContent>,
17398 state__: Box<RestrictionTypeDeserializerState>,
17399 }
17400 #[derive(Debug)]
17401 enum RestrictionTypeDeserializerState {
17402 Init__,
17403 Next__,
17404 Content__(<super::RestrictionTypeContent as WithDeserializer>::Deserializer),
17405 Unknown__,
17406 }
17407 impl RestrictionTypeDeserializer {
17408 fn from_bytes_start(
17409 helper: &mut DeserializeHelper,
17410 bytes_start: &BytesStart<'_>,
17411 ) -> Result<Box<Self>, Error> {
17412 let mut id: Option<String> = None;
17413 let mut base: Option<QName> = None;
17414 for attrib in helper.filter_xmlns_attributes(bytes_start) {
17415 let attrib = attrib?;
17416 if matches!(
17417 helper.resolve_local_name(attrib.key, &super::NS_XS),
17418 Some(b"id")
17419 ) {
17420 helper.read_attrib(&mut id, b"id", &attrib.value)?;
17421 } else if matches!(
17422 helper.resolve_local_name(attrib.key, &super::NS_XS),
17423 Some(b"base")
17424 ) {
17425 helper.read_attrib(&mut base, b"base", &attrib.value)?;
17426 }
17427 }
17428 Ok(Box::new(Self {
17429 id: id,
17430 base: base.ok_or_else(|| ErrorKind::MissingAttribute("base".into()))?,
17431 content: Vec::new(),
17432 state__: Box::new(RestrictionTypeDeserializerState::Init__),
17433 }))
17434 }
17435 fn finish_state(
17436 &mut self,
17437 helper: &mut DeserializeHelper,
17438 state: RestrictionTypeDeserializerState,
17439 ) -> Result<(), Error> {
17440 if let RestrictionTypeDeserializerState::Content__(deserializer) = state {
17441 self.store_content(deserializer.finish(helper)?)?;
17442 }
17443 Ok(())
17444 }
17445 fn store_content(&mut self, value: super::RestrictionTypeContent) -> Result<(), Error> {
17446 self.content.push(value);
17447 Ok(())
17448 }
17449 fn handle_content<'de>(
17450 &mut self,
17451 helper: &mut DeserializeHelper,
17452 output: DeserializerOutput<'de, super::RestrictionTypeContent>,
17453 fallback: &mut Option<RestrictionTypeDeserializerState>,
17454 ) -> Result<ElementHandlerOutput<'de>, Error> {
17455 use RestrictionTypeDeserializerState as S;
17456 let DeserializerOutput {
17457 artifact,
17458 event,
17459 allow_any,
17460 } = output;
17461 if artifact.is_none() {
17462 *self.state__ = fallback.take().unwrap_or(S::Next__);
17463 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
17464 }
17465 if let Some(fallback) = fallback.take() {
17466 self.finish_state(helper, fallback)?;
17467 }
17468 match artifact {
17469 DeserializerArtifact::None => unreachable!(),
17470 DeserializerArtifact::Data(data) => {
17471 self.store_content(data)?;
17472 *self.state__ = S::Next__;
17473 Ok(ElementHandlerOutput::from_event(event, allow_any))
17474 }
17475 DeserializerArtifact::Deserializer(deserializer) => {
17476 *fallback = Some(S::Content__(deserializer));
17477 *self.state__ = S::Next__;
17478 Ok(ElementHandlerOutput::from_event(event, allow_any))
17479 }
17480 }
17481 }
17482 }
17483 impl<'de> Deserializer<'de, super::RestrictionType> for Box<RestrictionTypeDeserializer> {
17484 fn init(
17485 helper: &mut DeserializeHelper,
17486 event: Event<'de>,
17487 ) -> DeserializerResult<'de, super::RestrictionType> {
17488 helper.init_deserializer_from_start_event(
17489 event,
17490 RestrictionTypeDeserializer::from_bytes_start,
17491 )
17492 }
17493 fn next(
17494 mut self,
17495 helper: &mut DeserializeHelper,
17496 event: Event<'de>,
17497 ) -> DeserializerResult<'de, super::RestrictionType> {
17498 use RestrictionTypeDeserializerState as S;
17499 let mut event = event;
17500 let mut fallback = None;
17501 let (event, allow_any) = loop {
17502 let state = replace(&mut *self.state__, S::Unknown__);
17503 event = match (state, event) {
17504 (S::Unknown__, _) => unreachable!(),
17505 (S::Content__(deserializer), event) => {
17506 let output = deserializer.next(helper, event)?;
17507 match self.handle_content(helper, output, &mut fallback)? {
17508 ElementHandlerOutput::Break { event, allow_any } => {
17509 break (event, allow_any)
17510 }
17511 ElementHandlerOutput::Continue { event, .. } => event,
17512 }
17513 }
17514 (_, Event::End(_)) => {
17515 return Ok(DeserializerOutput {
17516 artifact: DeserializerArtifact::Data(self.finish(helper)?),
17517 event: DeserializerEvent::None,
17518 allow_any: false,
17519 });
17520 }
17521 (state @ (S::Init__ | S::Next__), event) => {
17522 fallback.get_or_insert(state);
17523 let output = <super::RestrictionTypeContent as WithDeserializer>::init(
17524 helper, event,
17525 )?;
17526 match self.handle_content(helper, output, &mut fallback)? {
17527 ElementHandlerOutput::Break { event, allow_any } => {
17528 break (event, allow_any)
17529 }
17530 ElementHandlerOutput::Continue { event, .. } => event,
17531 }
17532 }
17533 }
17534 };
17535 if let Some(fallback) = fallback {
17536 *self.state__ = fallback;
17537 }
17538 let artifact = DeserializerArtifact::Deserializer(self);
17539 Ok(DeserializerOutput {
17540 artifact,
17541 event,
17542 allow_any,
17543 })
17544 }
17545 fn finish(
17546 mut self,
17547 helper: &mut DeserializeHelper,
17548 ) -> Result<super::RestrictionType, Error> {
17549 let state = replace(
17550 &mut *self.state__,
17551 RestrictionTypeDeserializerState::Unknown__,
17552 );
17553 self.finish_state(helper, state)?;
17554 Ok(super::RestrictionType {
17555 id: self.id,
17556 base: self.base,
17557 content: helper.finish_vec(0usize, None, self.content)?,
17558 })
17559 }
17560 }
17561 #[derive(Debug)]
17562 pub struct RestrictionTypeContentDeserializer {
17563 state__: Box<RestrictionTypeContentDeserializerState>,
17564 }
17565 #[derive(Debug)]
17566 pub enum RestrictionTypeContentDeserializerState {
17567 Init__,
17568 Annotation(
17569 Option<super::Annotation>,
17570 Option<<super::Annotation as WithDeserializer>::Deserializer>,
17571 Option<<super::Annotation as WithDeserializer>::Deserializer>,
17572 ),
17573 OpenContent(
17574 Option<super::OpenContent>,
17575 Option<<super::OpenContent as WithDeserializer>::Deserializer>,
17576 Option<<super::OpenContent as WithDeserializer>::Deserializer>,
17577 ),
17578 Group(
17579 Option<super::GroupType>,
17580 Option<<super::GroupType as WithDeserializer>::Deserializer>,
17581 Option<<super::GroupType as WithDeserializer>::Deserializer>,
17582 ),
17583 All(
17584 Option<super::GroupType>,
17585 Option<<super::GroupType as WithDeserializer>::Deserializer>,
17586 Option<<super::GroupType as WithDeserializer>::Deserializer>,
17587 ),
17588 Choice(
17589 Option<super::GroupType>,
17590 Option<<super::GroupType as WithDeserializer>::Deserializer>,
17591 Option<<super::GroupType as WithDeserializer>::Deserializer>,
17592 ),
17593 Sequence(
17594 Option<super::GroupType>,
17595 Option<<super::GroupType as WithDeserializer>::Deserializer>,
17596 Option<<super::GroupType as WithDeserializer>::Deserializer>,
17597 ),
17598 SimpleType(
17599 Option<super::SimpleBaseType>,
17600 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
17601 Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
17602 ),
17603 Facet(
17604 Option<super::Facet>,
17605 Option<<super::Facet as WithDeserializer>::Deserializer>,
17606 Option<<super::Facet as WithDeserializer>::Deserializer>,
17607 ),
17608 Attribute(
17609 Option<super::AttributeType>,
17610 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
17611 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
17612 ),
17613 AttributeGroup(
17614 Option<super::AttributeGroupType>,
17615 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
17616 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
17617 ),
17618 AnyAttribute(
17619 Option<super::AnyAttribute>,
17620 Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
17621 Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
17622 ),
17623 Assert(
17624 Option<super::AssertionType>,
17625 Option<<super::AssertionType as WithDeserializer>::Deserializer>,
17626 Option<<super::AssertionType as WithDeserializer>::Deserializer>,
17627 ),
17628 Done__(super::RestrictionTypeContent),
17629 Unknown__,
17630 }
17631 impl RestrictionTypeContentDeserializer {
17632 fn find_suitable<'de>(
17633 &mut self,
17634 helper: &mut DeserializeHelper,
17635 event: Event<'de>,
17636 ) -> Result<ElementHandlerOutput<'de>, Error> {
17637 let mut event = event;
17638 if let Event::Start(x) | Event::Empty(x) = &event {
17639 if matches!(
17640 helper.resolve_local_name(x.name(), &super::NS_XS),
17641 Some(b"annotation")
17642 ) {
17643 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
17644 return self.handle_annotation(helper, Default::default(), None, output);
17645 }
17646 if matches!(
17647 helper.resolve_local_name(x.name(), &super::NS_XS),
17648 Some(b"openContent")
17649 ) {
17650 let output = <super::OpenContent as WithDeserializer>::init(helper, event)?;
17651 return self.handle_open_content(helper, Default::default(), None, output);
17652 }
17653 if matches!(
17654 helper.resolve_local_name(x.name(), &super::NS_XS),
17655 Some(b"group")
17656 ) {
17657 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
17658 return self.handle_group(helper, Default::default(), None, output);
17659 }
17660 if matches!(
17661 helper.resolve_local_name(x.name(), &super::NS_XS),
17662 Some(b"all")
17663 ) {
17664 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
17665 return self.handle_all(helper, Default::default(), None, output);
17666 }
17667 if matches!(
17668 helper.resolve_local_name(x.name(), &super::NS_XS),
17669 Some(b"choice")
17670 ) {
17671 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
17672 return self.handle_choice(helper, Default::default(), None, output);
17673 }
17674 if matches!(
17675 helper.resolve_local_name(x.name(), &super::NS_XS),
17676 Some(b"sequence")
17677 ) {
17678 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
17679 return self.handle_sequence(helper, Default::default(), None, output);
17680 }
17681 if matches!(
17682 helper.resolve_local_name(x.name(), &super::NS_XS),
17683 Some(b"simpleType")
17684 ) {
17685 let output = <super::SimpleBaseType as WithDeserializer>::init(helper, event)?;
17686 return self.handle_simple_type(helper, Default::default(), None, output);
17687 }
17688 if matches!(
17689 helper.resolve_local_name(x.name(), &super::NS_XS),
17690 Some(b"attribute")
17691 ) {
17692 let output = <super::AttributeType as WithDeserializer>::init(helper, event)?;
17693 return self.handle_attribute(helper, Default::default(), None, output);
17694 }
17695 if matches!(
17696 helper.resolve_local_name(x.name(), &super::NS_XS),
17697 Some(b"attributeGroup")
17698 ) {
17699 let output =
17700 <super::AttributeGroupType as WithDeserializer>::init(helper, event)?;
17701 return self.handle_attribute_group(helper, Default::default(), None, output);
17702 }
17703 if matches!(
17704 helper.resolve_local_name(x.name(), &super::NS_XS),
17705 Some(b"anyAttribute")
17706 ) {
17707 let output = <super::AnyAttribute as WithDeserializer>::init(helper, event)?;
17708 return self.handle_any_attribute(helper, Default::default(), None, output);
17709 }
17710 if matches!(
17711 helper.resolve_local_name(x.name(), &super::NS_XS),
17712 Some(b"assert")
17713 ) {
17714 let output = <super::AssertionType as WithDeserializer>::init(helper, event)?;
17715 return self.handle_assert(helper, Default::default(), None, output);
17716 }
17717 event = {
17718 let output = <super::Facet as WithDeserializer>::init(helper, event)?;
17719 match self.handle_facet(helper, Default::default(), None, output)? {
17720 ElementHandlerOutput::Continue { event, .. } => event,
17721 output => {
17722 return Ok(output);
17723 }
17724 }
17725 };
17726 }
17727 *self.state__ = RestrictionTypeContentDeserializerState::Init__;
17728 Ok(ElementHandlerOutput::return_to_parent(event, true))
17729 }
17730 fn finish_state(
17731 helper: &mut DeserializeHelper,
17732 state: RestrictionTypeContentDeserializerState,
17733 ) -> Result<super::RestrictionTypeContent, Error> {
17734 use RestrictionTypeContentDeserializerState as S;
17735 match state {
17736 S::Init__ => Err(ErrorKind::MissingContent.into()),
17737 S::Annotation(mut values, None, deserializer) => {
17738 if let Some(deserializer) = deserializer {
17739 let value = deserializer.finish(helper)?;
17740 RestrictionTypeContentDeserializer::store_annotation(&mut values, value)?;
17741 }
17742 Ok(super::RestrictionTypeContent::Annotation(
17743 helper.finish_element("annotation", values)?,
17744 ))
17745 }
17746 S::OpenContent(mut values, None, deserializer) => {
17747 if let Some(deserializer) = deserializer {
17748 let value = deserializer.finish(helper)?;
17749 RestrictionTypeContentDeserializer::store_open_content(&mut values, value)?;
17750 }
17751 Ok(super::RestrictionTypeContent::OpenContent(
17752 helper.finish_element("openContent", values)?,
17753 ))
17754 }
17755 S::Group(mut values, None, deserializer) => {
17756 if let Some(deserializer) = deserializer {
17757 let value = deserializer.finish(helper)?;
17758 RestrictionTypeContentDeserializer::store_group(&mut values, value)?;
17759 }
17760 Ok(super::RestrictionTypeContent::Group(
17761 helper.finish_element("group", values)?,
17762 ))
17763 }
17764 S::All(mut values, None, deserializer) => {
17765 if let Some(deserializer) = deserializer {
17766 let value = deserializer.finish(helper)?;
17767 RestrictionTypeContentDeserializer::store_all(&mut values, value)?;
17768 }
17769 Ok(super::RestrictionTypeContent::All(
17770 helper.finish_element("all", values)?,
17771 ))
17772 }
17773 S::Choice(mut values, None, deserializer) => {
17774 if let Some(deserializer) = deserializer {
17775 let value = deserializer.finish(helper)?;
17776 RestrictionTypeContentDeserializer::store_choice(&mut values, value)?;
17777 }
17778 Ok(super::RestrictionTypeContent::Choice(
17779 helper.finish_element("choice", values)?,
17780 ))
17781 }
17782 S::Sequence(mut values, None, deserializer) => {
17783 if let Some(deserializer) = deserializer {
17784 let value = deserializer.finish(helper)?;
17785 RestrictionTypeContentDeserializer::store_sequence(&mut values, value)?;
17786 }
17787 Ok(super::RestrictionTypeContent::Sequence(
17788 helper.finish_element("sequence", values)?,
17789 ))
17790 }
17791 S::SimpleType(mut values, None, deserializer) => {
17792 if let Some(deserializer) = deserializer {
17793 let value = deserializer.finish(helper)?;
17794 RestrictionTypeContentDeserializer::store_simple_type(&mut values, value)?;
17795 }
17796 Ok(super::RestrictionTypeContent::SimpleType(
17797 helper.finish_element("simpleType", values)?,
17798 ))
17799 }
17800 S::Facet(mut values, None, deserializer) => {
17801 if let Some(deserializer) = deserializer {
17802 let value = deserializer.finish(helper)?;
17803 RestrictionTypeContentDeserializer::store_facet(&mut values, value)?;
17804 }
17805 Ok(super::RestrictionTypeContent::Facet(
17806 helper.finish_element("facet", values)?,
17807 ))
17808 }
17809 S::Attribute(mut values, None, deserializer) => {
17810 if let Some(deserializer) = deserializer {
17811 let value = deserializer.finish(helper)?;
17812 RestrictionTypeContentDeserializer::store_attribute(&mut values, value)?;
17813 }
17814 Ok(super::RestrictionTypeContent::Attribute(
17815 helper.finish_element("attribute", values)?,
17816 ))
17817 }
17818 S::AttributeGroup(mut values, None, deserializer) => {
17819 if let Some(deserializer) = deserializer {
17820 let value = deserializer.finish(helper)?;
17821 RestrictionTypeContentDeserializer::store_attribute_group(
17822 &mut values,
17823 value,
17824 )?;
17825 }
17826 Ok(super::RestrictionTypeContent::AttributeGroup(
17827 helper.finish_element("attributeGroup", values)?,
17828 ))
17829 }
17830 S::AnyAttribute(mut values, None, deserializer) => {
17831 if let Some(deserializer) = deserializer {
17832 let value = deserializer.finish(helper)?;
17833 RestrictionTypeContentDeserializer::store_any_attribute(
17834 &mut values,
17835 value,
17836 )?;
17837 }
17838 Ok(super::RestrictionTypeContent::AnyAttribute(
17839 helper.finish_element("anyAttribute", values)?,
17840 ))
17841 }
17842 S::Assert(mut values, None, deserializer) => {
17843 if let Some(deserializer) = deserializer {
17844 let value = deserializer.finish(helper)?;
17845 RestrictionTypeContentDeserializer::store_assert(&mut values, value)?;
17846 }
17847 Ok(super::RestrictionTypeContent::Assert(
17848 helper.finish_element("assert", values)?,
17849 ))
17850 }
17851 S::Done__(data) => Ok(data),
17852 _ => unreachable!(),
17853 }
17854 }
17855 fn store_annotation(
17856 values: &mut Option<super::Annotation>,
17857 value: super::Annotation,
17858 ) -> Result<(), Error> {
17859 if values.is_some() {
17860 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
17861 b"annotation",
17862 )))?;
17863 }
17864 *values = Some(value);
17865 Ok(())
17866 }
17867 fn store_open_content(
17868 values: &mut Option<super::OpenContent>,
17869 value: super::OpenContent,
17870 ) -> Result<(), Error> {
17871 if values.is_some() {
17872 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
17873 b"openContent",
17874 )))?;
17875 }
17876 *values = Some(value);
17877 Ok(())
17878 }
17879 fn store_group(
17880 values: &mut Option<super::GroupType>,
17881 value: super::GroupType,
17882 ) -> Result<(), Error> {
17883 if values.is_some() {
17884 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
17885 b"group",
17886 )))?;
17887 }
17888 *values = Some(value);
17889 Ok(())
17890 }
17891 fn store_all(
17892 values: &mut Option<super::GroupType>,
17893 value: super::GroupType,
17894 ) -> Result<(), Error> {
17895 if values.is_some() {
17896 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"all")))?;
17897 }
17898 *values = Some(value);
17899 Ok(())
17900 }
17901 fn store_choice(
17902 values: &mut Option<super::GroupType>,
17903 value: super::GroupType,
17904 ) -> Result<(), Error> {
17905 if values.is_some() {
17906 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
17907 b"choice",
17908 )))?;
17909 }
17910 *values = Some(value);
17911 Ok(())
17912 }
17913 fn store_sequence(
17914 values: &mut Option<super::GroupType>,
17915 value: super::GroupType,
17916 ) -> Result<(), Error> {
17917 if values.is_some() {
17918 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
17919 b"sequence",
17920 )))?;
17921 }
17922 *values = Some(value);
17923 Ok(())
17924 }
17925 fn store_simple_type(
17926 values: &mut Option<super::SimpleBaseType>,
17927 value: super::SimpleBaseType,
17928 ) -> Result<(), Error> {
17929 if values.is_some() {
17930 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
17931 b"simpleType",
17932 )))?;
17933 }
17934 *values = Some(value);
17935 Ok(())
17936 }
17937 fn store_facet(
17938 values: &mut Option<super::Facet>,
17939 value: super::Facet,
17940 ) -> Result<(), Error> {
17941 if values.is_some() {
17942 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
17943 b"facet",
17944 )))?;
17945 }
17946 *values = Some(value);
17947 Ok(())
17948 }
17949 fn store_attribute(
17950 values: &mut Option<super::AttributeType>,
17951 value: super::AttributeType,
17952 ) -> Result<(), Error> {
17953 if values.is_some() {
17954 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
17955 b"attribute",
17956 )))?;
17957 }
17958 *values = Some(value);
17959 Ok(())
17960 }
17961 fn store_attribute_group(
17962 values: &mut Option<super::AttributeGroupType>,
17963 value: super::AttributeGroupType,
17964 ) -> Result<(), Error> {
17965 if values.is_some() {
17966 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
17967 b"attributeGroup",
17968 )))?;
17969 }
17970 *values = Some(value);
17971 Ok(())
17972 }
17973 fn store_any_attribute(
17974 values: &mut Option<super::AnyAttribute>,
17975 value: super::AnyAttribute,
17976 ) -> Result<(), Error> {
17977 if values.is_some() {
17978 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
17979 b"anyAttribute",
17980 )))?;
17981 }
17982 *values = Some(value);
17983 Ok(())
17984 }
17985 fn store_assert(
17986 values: &mut Option<super::AssertionType>,
17987 value: super::AssertionType,
17988 ) -> Result<(), Error> {
17989 if values.is_some() {
17990 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
17991 b"assert",
17992 )))?;
17993 }
17994 *values = Some(value);
17995 Ok(())
17996 }
17997 fn handle_annotation<'de>(
17998 &mut self,
17999 helper: &mut DeserializeHelper,
18000 mut values: Option<super::Annotation>,
18001 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
18002 output: DeserializerOutput<'de, super::Annotation>,
18003 ) -> Result<ElementHandlerOutput<'de>, Error> {
18004 use RestrictionTypeContentDeserializerState as S;
18005 let DeserializerOutput {
18006 artifact,
18007 event,
18008 allow_any,
18009 } = output;
18010 if artifact.is_none() {
18011 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
18012 }
18013 if let Some(deserializer) = fallback {
18014 let data = deserializer.finish(helper)?;
18015 RestrictionTypeContentDeserializer::store_annotation(&mut values, data)?;
18016 }
18017 match artifact {
18018 DeserializerArtifact::None => unreachable!(),
18019 DeserializerArtifact::Data(data) => {
18020 RestrictionTypeContentDeserializer::store_annotation(&mut values, data)?;
18021 let data = RestrictionTypeContentDeserializer::finish_state(
18022 helper,
18023 S::Annotation(values, None, None),
18024 )?;
18025 *self.state__ = S::Done__(data);
18026 Ok(ElementHandlerOutput::break_(event, allow_any))
18027 }
18028 DeserializerArtifact::Deserializer(deserializer) => {
18029 *self.state__ = S::Annotation(values, None, Some(deserializer));
18030 Ok(ElementHandlerOutput::break_(event, allow_any))
18031 }
18032 }
18033 }
18034 fn handle_open_content<'de>(
18035 &mut self,
18036 helper: &mut DeserializeHelper,
18037 mut values: Option<super::OpenContent>,
18038 fallback: Option<<super::OpenContent as WithDeserializer>::Deserializer>,
18039 output: DeserializerOutput<'de, super::OpenContent>,
18040 ) -> Result<ElementHandlerOutput<'de>, Error> {
18041 use RestrictionTypeContentDeserializerState as S;
18042 let DeserializerOutput {
18043 artifact,
18044 event,
18045 allow_any,
18046 } = output;
18047 if artifact.is_none() {
18048 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
18049 }
18050 if let Some(deserializer) = fallback {
18051 let data = deserializer.finish(helper)?;
18052 RestrictionTypeContentDeserializer::store_open_content(&mut values, data)?;
18053 }
18054 match artifact {
18055 DeserializerArtifact::None => unreachable!(),
18056 DeserializerArtifact::Data(data) => {
18057 RestrictionTypeContentDeserializer::store_open_content(&mut values, data)?;
18058 let data = RestrictionTypeContentDeserializer::finish_state(
18059 helper,
18060 S::OpenContent(values, None, None),
18061 )?;
18062 *self.state__ = S::Done__(data);
18063 Ok(ElementHandlerOutput::break_(event, allow_any))
18064 }
18065 DeserializerArtifact::Deserializer(deserializer) => {
18066 *self.state__ = S::OpenContent(values, None, Some(deserializer));
18067 Ok(ElementHandlerOutput::break_(event, allow_any))
18068 }
18069 }
18070 }
18071 fn handle_group<'de>(
18072 &mut self,
18073 helper: &mut DeserializeHelper,
18074 mut values: Option<super::GroupType>,
18075 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
18076 output: DeserializerOutput<'de, super::GroupType>,
18077 ) -> Result<ElementHandlerOutput<'de>, Error> {
18078 use RestrictionTypeContentDeserializerState as S;
18079 let DeserializerOutput {
18080 artifact,
18081 event,
18082 allow_any,
18083 } = output;
18084 if artifact.is_none() {
18085 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
18086 }
18087 if let Some(deserializer) = fallback {
18088 let data = deserializer.finish(helper)?;
18089 RestrictionTypeContentDeserializer::store_group(&mut values, data)?;
18090 }
18091 match artifact {
18092 DeserializerArtifact::None => unreachable!(),
18093 DeserializerArtifact::Data(data) => {
18094 RestrictionTypeContentDeserializer::store_group(&mut values, data)?;
18095 let data = RestrictionTypeContentDeserializer::finish_state(
18096 helper,
18097 S::Group(values, None, None),
18098 )?;
18099 *self.state__ = S::Done__(data);
18100 Ok(ElementHandlerOutput::break_(event, allow_any))
18101 }
18102 DeserializerArtifact::Deserializer(deserializer) => {
18103 *self.state__ = S::Group(values, None, Some(deserializer));
18104 Ok(ElementHandlerOutput::break_(event, allow_any))
18105 }
18106 }
18107 }
18108 fn handle_all<'de>(
18109 &mut self,
18110 helper: &mut DeserializeHelper,
18111 mut values: Option<super::GroupType>,
18112 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
18113 output: DeserializerOutput<'de, super::GroupType>,
18114 ) -> Result<ElementHandlerOutput<'de>, Error> {
18115 use RestrictionTypeContentDeserializerState as S;
18116 let DeserializerOutput {
18117 artifact,
18118 event,
18119 allow_any,
18120 } = output;
18121 if artifact.is_none() {
18122 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
18123 }
18124 if let Some(deserializer) = fallback {
18125 let data = deserializer.finish(helper)?;
18126 RestrictionTypeContentDeserializer::store_all(&mut values, data)?;
18127 }
18128 match artifact {
18129 DeserializerArtifact::None => unreachable!(),
18130 DeserializerArtifact::Data(data) => {
18131 RestrictionTypeContentDeserializer::store_all(&mut values, data)?;
18132 let data = RestrictionTypeContentDeserializer::finish_state(
18133 helper,
18134 S::All(values, None, None),
18135 )?;
18136 *self.state__ = S::Done__(data);
18137 Ok(ElementHandlerOutput::break_(event, allow_any))
18138 }
18139 DeserializerArtifact::Deserializer(deserializer) => {
18140 *self.state__ = S::All(values, None, Some(deserializer));
18141 Ok(ElementHandlerOutput::break_(event, allow_any))
18142 }
18143 }
18144 }
18145 fn handle_choice<'de>(
18146 &mut self,
18147 helper: &mut DeserializeHelper,
18148 mut values: Option<super::GroupType>,
18149 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
18150 output: DeserializerOutput<'de, super::GroupType>,
18151 ) -> Result<ElementHandlerOutput<'de>, Error> {
18152 use RestrictionTypeContentDeserializerState as S;
18153 let DeserializerOutput {
18154 artifact,
18155 event,
18156 allow_any,
18157 } = output;
18158 if artifact.is_none() {
18159 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
18160 }
18161 if let Some(deserializer) = fallback {
18162 let data = deserializer.finish(helper)?;
18163 RestrictionTypeContentDeserializer::store_choice(&mut values, data)?;
18164 }
18165 match artifact {
18166 DeserializerArtifact::None => unreachable!(),
18167 DeserializerArtifact::Data(data) => {
18168 RestrictionTypeContentDeserializer::store_choice(&mut values, data)?;
18169 let data = RestrictionTypeContentDeserializer::finish_state(
18170 helper,
18171 S::Choice(values, None, None),
18172 )?;
18173 *self.state__ = S::Done__(data);
18174 Ok(ElementHandlerOutput::break_(event, allow_any))
18175 }
18176 DeserializerArtifact::Deserializer(deserializer) => {
18177 *self.state__ = S::Choice(values, None, Some(deserializer));
18178 Ok(ElementHandlerOutput::break_(event, allow_any))
18179 }
18180 }
18181 }
18182 fn handle_sequence<'de>(
18183 &mut self,
18184 helper: &mut DeserializeHelper,
18185 mut values: Option<super::GroupType>,
18186 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
18187 output: DeserializerOutput<'de, super::GroupType>,
18188 ) -> Result<ElementHandlerOutput<'de>, Error> {
18189 use RestrictionTypeContentDeserializerState as S;
18190 let DeserializerOutput {
18191 artifact,
18192 event,
18193 allow_any,
18194 } = output;
18195 if artifact.is_none() {
18196 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
18197 }
18198 if let Some(deserializer) = fallback {
18199 let data = deserializer.finish(helper)?;
18200 RestrictionTypeContentDeserializer::store_sequence(&mut values, data)?;
18201 }
18202 match artifact {
18203 DeserializerArtifact::None => unreachable!(),
18204 DeserializerArtifact::Data(data) => {
18205 RestrictionTypeContentDeserializer::store_sequence(&mut values, data)?;
18206 let data = RestrictionTypeContentDeserializer::finish_state(
18207 helper,
18208 S::Sequence(values, None, None),
18209 )?;
18210 *self.state__ = S::Done__(data);
18211 Ok(ElementHandlerOutput::break_(event, allow_any))
18212 }
18213 DeserializerArtifact::Deserializer(deserializer) => {
18214 *self.state__ = S::Sequence(values, None, Some(deserializer));
18215 Ok(ElementHandlerOutput::break_(event, allow_any))
18216 }
18217 }
18218 }
18219 fn handle_simple_type<'de>(
18220 &mut self,
18221 helper: &mut DeserializeHelper,
18222 mut values: Option<super::SimpleBaseType>,
18223 fallback: Option<<super::SimpleBaseType as WithDeserializer>::Deserializer>,
18224 output: DeserializerOutput<'de, super::SimpleBaseType>,
18225 ) -> Result<ElementHandlerOutput<'de>, Error> {
18226 use RestrictionTypeContentDeserializerState as S;
18227 let DeserializerOutput {
18228 artifact,
18229 event,
18230 allow_any,
18231 } = output;
18232 if artifact.is_none() {
18233 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
18234 }
18235 if let Some(deserializer) = fallback {
18236 let data = deserializer.finish(helper)?;
18237 RestrictionTypeContentDeserializer::store_simple_type(&mut values, data)?;
18238 }
18239 match artifact {
18240 DeserializerArtifact::None => unreachable!(),
18241 DeserializerArtifact::Data(data) => {
18242 RestrictionTypeContentDeserializer::store_simple_type(&mut values, data)?;
18243 let data = RestrictionTypeContentDeserializer::finish_state(
18244 helper,
18245 S::SimpleType(values, None, None),
18246 )?;
18247 *self.state__ = S::Done__(data);
18248 Ok(ElementHandlerOutput::break_(event, allow_any))
18249 }
18250 DeserializerArtifact::Deserializer(deserializer) => {
18251 *self.state__ = S::SimpleType(values, None, Some(deserializer));
18252 Ok(ElementHandlerOutput::break_(event, allow_any))
18253 }
18254 }
18255 }
18256 fn handle_facet<'de>(
18257 &mut self,
18258 helper: &mut DeserializeHelper,
18259 mut values: Option<super::Facet>,
18260 fallback: Option<<super::Facet as WithDeserializer>::Deserializer>,
18261 output: DeserializerOutput<'de, super::Facet>,
18262 ) -> Result<ElementHandlerOutput<'de>, Error> {
18263 use RestrictionTypeContentDeserializerState as S;
18264 let DeserializerOutput {
18265 artifact,
18266 event,
18267 allow_any,
18268 } = output;
18269 if artifact.is_none() {
18270 return Ok(ElementHandlerOutput::from_event(event, allow_any));
18271 }
18272 if let Some(deserializer) = fallback {
18273 let data = deserializer.finish(helper)?;
18274 RestrictionTypeContentDeserializer::store_facet(&mut values, data)?;
18275 }
18276 match artifact {
18277 DeserializerArtifact::None => unreachable!(),
18278 DeserializerArtifact::Data(data) => {
18279 RestrictionTypeContentDeserializer::store_facet(&mut values, data)?;
18280 let data = RestrictionTypeContentDeserializer::finish_state(
18281 helper,
18282 S::Facet(values, None, None),
18283 )?;
18284 *self.state__ = S::Done__(data);
18285 Ok(ElementHandlerOutput::break_(event, allow_any))
18286 }
18287 DeserializerArtifact::Deserializer(deserializer) => {
18288 *self.state__ = S::Facet(values, None, Some(deserializer));
18289 Ok(ElementHandlerOutput::break_(event, allow_any))
18290 }
18291 }
18292 }
18293 fn handle_attribute<'de>(
18294 &mut self,
18295 helper: &mut DeserializeHelper,
18296 mut values: Option<super::AttributeType>,
18297 fallback: Option<<super::AttributeType as WithDeserializer>::Deserializer>,
18298 output: DeserializerOutput<'de, super::AttributeType>,
18299 ) -> Result<ElementHandlerOutput<'de>, Error> {
18300 use RestrictionTypeContentDeserializerState as S;
18301 let DeserializerOutput {
18302 artifact,
18303 event,
18304 allow_any,
18305 } = output;
18306 if artifact.is_none() {
18307 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
18308 }
18309 if let Some(deserializer) = fallback {
18310 let data = deserializer.finish(helper)?;
18311 RestrictionTypeContentDeserializer::store_attribute(&mut values, data)?;
18312 }
18313 match artifact {
18314 DeserializerArtifact::None => unreachable!(),
18315 DeserializerArtifact::Data(data) => {
18316 RestrictionTypeContentDeserializer::store_attribute(&mut values, data)?;
18317 let data = RestrictionTypeContentDeserializer::finish_state(
18318 helper,
18319 S::Attribute(values, None, None),
18320 )?;
18321 *self.state__ = S::Done__(data);
18322 Ok(ElementHandlerOutput::break_(event, allow_any))
18323 }
18324 DeserializerArtifact::Deserializer(deserializer) => {
18325 *self.state__ = S::Attribute(values, None, Some(deserializer));
18326 Ok(ElementHandlerOutput::break_(event, allow_any))
18327 }
18328 }
18329 }
18330 fn handle_attribute_group<'de>(
18331 &mut self,
18332 helper: &mut DeserializeHelper,
18333 mut values: Option<super::AttributeGroupType>,
18334 fallback: Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
18335 output: DeserializerOutput<'de, super::AttributeGroupType>,
18336 ) -> Result<ElementHandlerOutput<'de>, Error> {
18337 use RestrictionTypeContentDeserializerState as S;
18338 let DeserializerOutput {
18339 artifact,
18340 event,
18341 allow_any,
18342 } = output;
18343 if artifact.is_none() {
18344 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
18345 }
18346 if let Some(deserializer) = fallback {
18347 let data = deserializer.finish(helper)?;
18348 RestrictionTypeContentDeserializer::store_attribute_group(&mut values, data)?;
18349 }
18350 match artifact {
18351 DeserializerArtifact::None => unreachable!(),
18352 DeserializerArtifact::Data(data) => {
18353 RestrictionTypeContentDeserializer::store_attribute_group(&mut values, data)?;
18354 let data = RestrictionTypeContentDeserializer::finish_state(
18355 helper,
18356 S::AttributeGroup(values, None, None),
18357 )?;
18358 *self.state__ = S::Done__(data);
18359 Ok(ElementHandlerOutput::break_(event, allow_any))
18360 }
18361 DeserializerArtifact::Deserializer(deserializer) => {
18362 *self.state__ = S::AttributeGroup(values, None, Some(deserializer));
18363 Ok(ElementHandlerOutput::break_(event, allow_any))
18364 }
18365 }
18366 }
18367 fn handle_any_attribute<'de>(
18368 &mut self,
18369 helper: &mut DeserializeHelper,
18370 mut values: Option<super::AnyAttribute>,
18371 fallback: Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
18372 output: DeserializerOutput<'de, super::AnyAttribute>,
18373 ) -> Result<ElementHandlerOutput<'de>, Error> {
18374 use RestrictionTypeContentDeserializerState as S;
18375 let DeserializerOutput {
18376 artifact,
18377 event,
18378 allow_any,
18379 } = output;
18380 if artifact.is_none() {
18381 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
18382 }
18383 if let Some(deserializer) = fallback {
18384 let data = deserializer.finish(helper)?;
18385 RestrictionTypeContentDeserializer::store_any_attribute(&mut values, data)?;
18386 }
18387 match artifact {
18388 DeserializerArtifact::None => unreachable!(),
18389 DeserializerArtifact::Data(data) => {
18390 RestrictionTypeContentDeserializer::store_any_attribute(&mut values, data)?;
18391 let data = RestrictionTypeContentDeserializer::finish_state(
18392 helper,
18393 S::AnyAttribute(values, None, None),
18394 )?;
18395 *self.state__ = S::Done__(data);
18396 Ok(ElementHandlerOutput::break_(event, allow_any))
18397 }
18398 DeserializerArtifact::Deserializer(deserializer) => {
18399 *self.state__ = S::AnyAttribute(values, None, Some(deserializer));
18400 Ok(ElementHandlerOutput::break_(event, allow_any))
18401 }
18402 }
18403 }
18404 fn handle_assert<'de>(
18405 &mut self,
18406 helper: &mut DeserializeHelper,
18407 mut values: Option<super::AssertionType>,
18408 fallback: Option<<super::AssertionType as WithDeserializer>::Deserializer>,
18409 output: DeserializerOutput<'de, super::AssertionType>,
18410 ) -> Result<ElementHandlerOutput<'de>, Error> {
18411 use RestrictionTypeContentDeserializerState as S;
18412 let DeserializerOutput {
18413 artifact,
18414 event,
18415 allow_any,
18416 } = output;
18417 if artifact.is_none() {
18418 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
18419 }
18420 if let Some(deserializer) = fallback {
18421 let data = deserializer.finish(helper)?;
18422 RestrictionTypeContentDeserializer::store_assert(&mut values, data)?;
18423 }
18424 match artifact {
18425 DeserializerArtifact::None => unreachable!(),
18426 DeserializerArtifact::Data(data) => {
18427 RestrictionTypeContentDeserializer::store_assert(&mut values, data)?;
18428 let data = RestrictionTypeContentDeserializer::finish_state(
18429 helper,
18430 S::Assert(values, None, None),
18431 )?;
18432 *self.state__ = S::Done__(data);
18433 Ok(ElementHandlerOutput::break_(event, allow_any))
18434 }
18435 DeserializerArtifact::Deserializer(deserializer) => {
18436 *self.state__ = S::Assert(values, None, Some(deserializer));
18437 Ok(ElementHandlerOutput::break_(event, allow_any))
18438 }
18439 }
18440 }
18441 }
18442 impl<'de> Deserializer<'de, super::RestrictionTypeContent>
18443 for Box<RestrictionTypeContentDeserializer>
18444 {
18445 fn init(
18446 helper: &mut DeserializeHelper,
18447 event: Event<'de>,
18448 ) -> DeserializerResult<'de, super::RestrictionTypeContent> {
18449 let deserializer = Box::new(RestrictionTypeContentDeserializer {
18450 state__: Box::new(RestrictionTypeContentDeserializerState::Init__),
18451 });
18452 let mut output = deserializer.next(helper, event)?;
18453 output.artifact = match output.artifact {
18454 DeserializerArtifact::Deserializer(x)
18455 if matches!(&*x.state__, RestrictionTypeContentDeserializerState::Init__) =>
18456 {
18457 DeserializerArtifact::None
18458 }
18459 artifact => artifact,
18460 };
18461 Ok(output)
18462 }
18463 fn next(
18464 mut self,
18465 helper: &mut DeserializeHelper,
18466 event: Event<'de>,
18467 ) -> DeserializerResult<'de, super::RestrictionTypeContent> {
18468 use RestrictionTypeContentDeserializerState as S;
18469 let mut event = event;
18470 let (event, allow_any) = loop {
18471 let state = replace(&mut *self.state__, S::Unknown__);
18472 event = match (state, event) {
18473 (S::Unknown__, _) => unreachable!(),
18474 (S::Annotation(values, fallback, Some(deserializer)), event) => {
18475 let output = deserializer.next(helper, event)?;
18476 match self.handle_annotation(helper, values, fallback, output)? {
18477 ElementHandlerOutput::Break { event, allow_any } => {
18478 break (event, allow_any)
18479 }
18480 ElementHandlerOutput::Continue { event, .. } => event,
18481 }
18482 }
18483 (S::OpenContent(values, fallback, Some(deserializer)), event) => {
18484 let output = deserializer.next(helper, event)?;
18485 match self.handle_open_content(helper, values, fallback, output)? {
18486 ElementHandlerOutput::Break { event, allow_any } => {
18487 break (event, allow_any)
18488 }
18489 ElementHandlerOutput::Continue { event, .. } => event,
18490 }
18491 }
18492 (S::Group(values, fallback, Some(deserializer)), event) => {
18493 let output = deserializer.next(helper, event)?;
18494 match self.handle_group(helper, values, fallback, output)? {
18495 ElementHandlerOutput::Break { event, allow_any } => {
18496 break (event, allow_any)
18497 }
18498 ElementHandlerOutput::Continue { event, .. } => event,
18499 }
18500 }
18501 (S::All(values, fallback, Some(deserializer)), event) => {
18502 let output = deserializer.next(helper, event)?;
18503 match self.handle_all(helper, values, fallback, output)? {
18504 ElementHandlerOutput::Break { event, allow_any } => {
18505 break (event, allow_any)
18506 }
18507 ElementHandlerOutput::Continue { event, .. } => event,
18508 }
18509 }
18510 (S::Choice(values, fallback, Some(deserializer)), event) => {
18511 let output = deserializer.next(helper, event)?;
18512 match self.handle_choice(helper, values, fallback, output)? {
18513 ElementHandlerOutput::Break { event, allow_any } => {
18514 break (event, allow_any)
18515 }
18516 ElementHandlerOutput::Continue { event, .. } => event,
18517 }
18518 }
18519 (S::Sequence(values, fallback, Some(deserializer)), event) => {
18520 let output = deserializer.next(helper, event)?;
18521 match self.handle_sequence(helper, values, fallback, output)? {
18522 ElementHandlerOutput::Break { event, allow_any } => {
18523 break (event, allow_any)
18524 }
18525 ElementHandlerOutput::Continue { event, .. } => event,
18526 }
18527 }
18528 (S::SimpleType(values, fallback, Some(deserializer)), event) => {
18529 let output = deserializer.next(helper, event)?;
18530 match self.handle_simple_type(helper, values, fallback, output)? {
18531 ElementHandlerOutput::Break { event, allow_any } => {
18532 break (event, allow_any)
18533 }
18534 ElementHandlerOutput::Continue { event, .. } => event,
18535 }
18536 }
18537 (S::Facet(values, fallback, Some(deserializer)), event) => {
18538 let output = deserializer.next(helper, event)?;
18539 match self.handle_facet(helper, values, fallback, output)? {
18540 ElementHandlerOutput::Break { event, allow_any } => {
18541 break (event, allow_any)
18542 }
18543 ElementHandlerOutput::Continue { event, .. } => event,
18544 }
18545 }
18546 (S::Attribute(values, fallback, Some(deserializer)), event) => {
18547 let output = deserializer.next(helper, event)?;
18548 match self.handle_attribute(helper, values, fallback, output)? {
18549 ElementHandlerOutput::Break { event, allow_any } => {
18550 break (event, allow_any)
18551 }
18552 ElementHandlerOutput::Continue { event, .. } => event,
18553 }
18554 }
18555 (S::AttributeGroup(values, fallback, Some(deserializer)), event) => {
18556 let output = deserializer.next(helper, event)?;
18557 match self.handle_attribute_group(helper, values, fallback, output)? {
18558 ElementHandlerOutput::Break { event, allow_any } => {
18559 break (event, allow_any)
18560 }
18561 ElementHandlerOutput::Continue { event, .. } => event,
18562 }
18563 }
18564 (S::AnyAttribute(values, fallback, Some(deserializer)), event) => {
18565 let output = deserializer.next(helper, event)?;
18566 match self.handle_any_attribute(helper, values, fallback, output)? {
18567 ElementHandlerOutput::Break { event, allow_any } => {
18568 break (event, allow_any)
18569 }
18570 ElementHandlerOutput::Continue { event, .. } => event,
18571 }
18572 }
18573 (S::Assert(values, fallback, Some(deserializer)), event) => {
18574 let output = deserializer.next(helper, event)?;
18575 match self.handle_assert(helper, values, fallback, output)? {
18576 ElementHandlerOutput::Break { event, allow_any } => {
18577 break (event, allow_any)
18578 }
18579 ElementHandlerOutput::Continue { event, .. } => event,
18580 }
18581 }
18582 (state, event @ Event::End(_)) => {
18583 return Ok(DeserializerOutput {
18584 artifact: DeserializerArtifact::Data(
18585 RestrictionTypeContentDeserializer::finish_state(helper, state)?,
18586 ),
18587 event: DeserializerEvent::Continue(event),
18588 allow_any: false,
18589 });
18590 }
18591 (S::Init__, event) => match self.find_suitable(helper, event)? {
18592 ElementHandlerOutput::Break { event, allow_any } => {
18593 break (event, allow_any)
18594 }
18595 ElementHandlerOutput::Continue { event, .. } => event,
18596 },
18597 (
18598 S::Annotation(values, fallback, None),
18599 event @ (Event::Start(_) | Event::Empty(_)),
18600 ) => {
18601 let output = helper.init_start_tag_deserializer(
18602 event,
18603 Some(&super::NS_XS),
18604 b"annotation",
18605 false,
18606 )?;
18607 match self.handle_annotation(helper, values, fallback, output)? {
18608 ElementHandlerOutput::Break { event, allow_any } => {
18609 break (event, allow_any)
18610 }
18611 ElementHandlerOutput::Continue { event, .. } => event,
18612 }
18613 }
18614 (
18615 S::OpenContent(values, fallback, None),
18616 event @ (Event::Start(_) | Event::Empty(_)),
18617 ) => {
18618 let output = helper.init_start_tag_deserializer(
18619 event,
18620 Some(&super::NS_XS),
18621 b"openContent",
18622 false,
18623 )?;
18624 match self.handle_open_content(helper, values, fallback, output)? {
18625 ElementHandlerOutput::Break { event, allow_any } => {
18626 break (event, allow_any)
18627 }
18628 ElementHandlerOutput::Continue { event, .. } => event,
18629 }
18630 }
18631 (
18632 S::Group(values, fallback, None),
18633 event @ (Event::Start(_) | Event::Empty(_)),
18634 ) => {
18635 let output = helper.init_start_tag_deserializer(
18636 event,
18637 Some(&super::NS_XS),
18638 b"group",
18639 true,
18640 )?;
18641 match self.handle_group(helper, values, fallback, output)? {
18642 ElementHandlerOutput::Break { event, allow_any } => {
18643 break (event, allow_any)
18644 }
18645 ElementHandlerOutput::Continue { event, .. } => event,
18646 }
18647 }
18648 (
18649 S::All(values, fallback, None),
18650 event @ (Event::Start(_) | Event::Empty(_)),
18651 ) => {
18652 let output = helper.init_start_tag_deserializer(
18653 event,
18654 Some(&super::NS_XS),
18655 b"all",
18656 true,
18657 )?;
18658 match self.handle_all(helper, values, fallback, output)? {
18659 ElementHandlerOutput::Break { event, allow_any } => {
18660 break (event, allow_any)
18661 }
18662 ElementHandlerOutput::Continue { event, .. } => event,
18663 }
18664 }
18665 (
18666 S::Choice(values, fallback, None),
18667 event @ (Event::Start(_) | Event::Empty(_)),
18668 ) => {
18669 let output = helper.init_start_tag_deserializer(
18670 event,
18671 Some(&super::NS_XS),
18672 b"choice",
18673 true,
18674 )?;
18675 match self.handle_choice(helper, values, fallback, output)? {
18676 ElementHandlerOutput::Break { event, allow_any } => {
18677 break (event, allow_any)
18678 }
18679 ElementHandlerOutput::Continue { event, .. } => event,
18680 }
18681 }
18682 (
18683 S::Sequence(values, fallback, None),
18684 event @ (Event::Start(_) | Event::Empty(_)),
18685 ) => {
18686 let output = helper.init_start_tag_deserializer(
18687 event,
18688 Some(&super::NS_XS),
18689 b"sequence",
18690 true,
18691 )?;
18692 match self.handle_sequence(helper, values, fallback, output)? {
18693 ElementHandlerOutput::Break { event, allow_any } => {
18694 break (event, allow_any)
18695 }
18696 ElementHandlerOutput::Continue { event, .. } => event,
18697 }
18698 }
18699 (
18700 S::SimpleType(values, fallback, None),
18701 event @ (Event::Start(_) | Event::Empty(_)),
18702 ) => {
18703 let output = helper.init_start_tag_deserializer(
18704 event,
18705 Some(&super::NS_XS),
18706 b"simpleType",
18707 true,
18708 )?;
18709 match self.handle_simple_type(helper, values, fallback, output)? {
18710 ElementHandlerOutput::Break { event, allow_any } => {
18711 break (event, allow_any)
18712 }
18713 ElementHandlerOutput::Continue { event, .. } => event,
18714 }
18715 }
18716 (
18717 S::Facet(values, fallback, None),
18718 event @ (Event::Start(_) | Event::Empty(_)),
18719 ) => {
18720 let output = <super::Facet as WithDeserializer>::init(helper, event)?;
18721 match self.handle_facet(helper, values, fallback, output)? {
18722 ElementHandlerOutput::Break { event, allow_any } => {
18723 break (event, allow_any)
18724 }
18725 ElementHandlerOutput::Continue { event, .. } => event,
18726 }
18727 }
18728 (
18729 S::Attribute(values, fallback, None),
18730 event @ (Event::Start(_) | Event::Empty(_)),
18731 ) => {
18732 let output = helper.init_start_tag_deserializer(
18733 event,
18734 Some(&super::NS_XS),
18735 b"attribute",
18736 false,
18737 )?;
18738 match self.handle_attribute(helper, values, fallback, output)? {
18739 ElementHandlerOutput::Break { event, allow_any } => {
18740 break (event, allow_any)
18741 }
18742 ElementHandlerOutput::Continue { event, .. } => event,
18743 }
18744 }
18745 (
18746 S::AttributeGroup(values, fallback, None),
18747 event @ (Event::Start(_) | Event::Empty(_)),
18748 ) => {
18749 let output = helper.init_start_tag_deserializer(
18750 event,
18751 Some(&super::NS_XS),
18752 b"attributeGroup",
18753 false,
18754 )?;
18755 match self.handle_attribute_group(helper, values, fallback, output)? {
18756 ElementHandlerOutput::Break { event, allow_any } => {
18757 break (event, allow_any)
18758 }
18759 ElementHandlerOutput::Continue { event, .. } => event,
18760 }
18761 }
18762 (
18763 S::AnyAttribute(values, fallback, None),
18764 event @ (Event::Start(_) | Event::Empty(_)),
18765 ) => {
18766 let output = helper.init_start_tag_deserializer(
18767 event,
18768 Some(&super::NS_XS),
18769 b"anyAttribute",
18770 false,
18771 )?;
18772 match self.handle_any_attribute(helper, values, fallback, output)? {
18773 ElementHandlerOutput::Break { event, allow_any } => {
18774 break (event, allow_any)
18775 }
18776 ElementHandlerOutput::Continue { event, .. } => event,
18777 }
18778 }
18779 (
18780 S::Assert(values, fallback, None),
18781 event @ (Event::Start(_) | Event::Empty(_)),
18782 ) => {
18783 let output = helper.init_start_tag_deserializer(
18784 event,
18785 Some(&super::NS_XS),
18786 b"assert",
18787 false,
18788 )?;
18789 match self.handle_assert(helper, values, fallback, output)? {
18790 ElementHandlerOutput::Break { event, allow_any } => {
18791 break (event, allow_any)
18792 }
18793 ElementHandlerOutput::Continue { event, .. } => event,
18794 }
18795 }
18796 (state @ S::Done__(_), event) => {
18797 *self.state__ = state;
18798 break (DeserializerEvent::Continue(event), false);
18799 }
18800 (state, event) => {
18801 *self.state__ = state;
18802 break (DeserializerEvent::Continue(event), false);
18803 }
18804 }
18805 };
18806 let artifact = if matches!(&*self.state__, S::Done__(_)) {
18807 DeserializerArtifact::Data(self.finish(helper)?)
18808 } else {
18809 DeserializerArtifact::Deserializer(self)
18810 };
18811 Ok(DeserializerOutput {
18812 artifact,
18813 event,
18814 allow_any,
18815 })
18816 }
18817 fn finish(
18818 self,
18819 helper: &mut DeserializeHelper,
18820 ) -> Result<super::RestrictionTypeContent, Error> {
18821 RestrictionTypeContentDeserializer::finish_state(helper, *self.state__)
18822 }
18823 }
18824 #[derive(Debug)]
18825 pub struct ExtensionTypeDeserializer {
18826 id: Option<String>,
18827 base: QName,
18828 content: Vec<super::ExtensionTypeContent>,
18829 state__: Box<ExtensionTypeDeserializerState>,
18830 }
18831 #[derive(Debug)]
18832 enum ExtensionTypeDeserializerState {
18833 Init__,
18834 Next__,
18835 Content__(<super::ExtensionTypeContent as WithDeserializer>::Deserializer),
18836 Unknown__,
18837 }
18838 impl ExtensionTypeDeserializer {
18839 fn from_bytes_start(
18840 helper: &mut DeserializeHelper,
18841 bytes_start: &BytesStart<'_>,
18842 ) -> Result<Box<Self>, Error> {
18843 let mut id: Option<String> = None;
18844 let mut base: Option<QName> = None;
18845 for attrib in helper.filter_xmlns_attributes(bytes_start) {
18846 let attrib = attrib?;
18847 if matches!(
18848 helper.resolve_local_name(attrib.key, &super::NS_XS),
18849 Some(b"id")
18850 ) {
18851 helper.read_attrib(&mut id, b"id", &attrib.value)?;
18852 } else if matches!(
18853 helper.resolve_local_name(attrib.key, &super::NS_XS),
18854 Some(b"base")
18855 ) {
18856 helper.read_attrib(&mut base, b"base", &attrib.value)?;
18857 }
18858 }
18859 Ok(Box::new(Self {
18860 id: id,
18861 base: base.ok_or_else(|| ErrorKind::MissingAttribute("base".into()))?,
18862 content: Vec::new(),
18863 state__: Box::new(ExtensionTypeDeserializerState::Init__),
18864 }))
18865 }
18866 fn finish_state(
18867 &mut self,
18868 helper: &mut DeserializeHelper,
18869 state: ExtensionTypeDeserializerState,
18870 ) -> Result<(), Error> {
18871 if let ExtensionTypeDeserializerState::Content__(deserializer) = state {
18872 self.store_content(deserializer.finish(helper)?)?;
18873 }
18874 Ok(())
18875 }
18876 fn store_content(&mut self, value: super::ExtensionTypeContent) -> Result<(), Error> {
18877 self.content.push(value);
18878 Ok(())
18879 }
18880 fn handle_content<'de>(
18881 &mut self,
18882 helper: &mut DeserializeHelper,
18883 output: DeserializerOutput<'de, super::ExtensionTypeContent>,
18884 fallback: &mut Option<ExtensionTypeDeserializerState>,
18885 ) -> Result<ElementHandlerOutput<'de>, Error> {
18886 use ExtensionTypeDeserializerState as S;
18887 let DeserializerOutput {
18888 artifact,
18889 event,
18890 allow_any,
18891 } = output;
18892 if artifact.is_none() {
18893 *self.state__ = fallback.take().unwrap_or(S::Next__);
18894 return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
18895 }
18896 if let Some(fallback) = fallback.take() {
18897 self.finish_state(helper, fallback)?;
18898 }
18899 match artifact {
18900 DeserializerArtifact::None => unreachable!(),
18901 DeserializerArtifact::Data(data) => {
18902 self.store_content(data)?;
18903 *self.state__ = S::Next__;
18904 Ok(ElementHandlerOutput::from_event(event, allow_any))
18905 }
18906 DeserializerArtifact::Deserializer(deserializer) => {
18907 *fallback = Some(S::Content__(deserializer));
18908 *self.state__ = S::Next__;
18909 Ok(ElementHandlerOutput::from_event(event, allow_any))
18910 }
18911 }
18912 }
18913 }
18914 impl<'de> Deserializer<'de, super::ExtensionType> for Box<ExtensionTypeDeserializer> {
18915 fn init(
18916 helper: &mut DeserializeHelper,
18917 event: Event<'de>,
18918 ) -> DeserializerResult<'de, super::ExtensionType> {
18919 helper.init_deserializer_from_start_event(
18920 event,
18921 ExtensionTypeDeserializer::from_bytes_start,
18922 )
18923 }
18924 fn next(
18925 mut self,
18926 helper: &mut DeserializeHelper,
18927 event: Event<'de>,
18928 ) -> DeserializerResult<'de, super::ExtensionType> {
18929 use ExtensionTypeDeserializerState as S;
18930 let mut event = event;
18931 let mut fallback = None;
18932 let (event, allow_any) = loop {
18933 let state = replace(&mut *self.state__, S::Unknown__);
18934 event = match (state, event) {
18935 (S::Unknown__, _) => unreachable!(),
18936 (S::Content__(deserializer), event) => {
18937 let output = deserializer.next(helper, event)?;
18938 match self.handle_content(helper, output, &mut fallback)? {
18939 ElementHandlerOutput::Break { event, allow_any } => {
18940 break (event, allow_any)
18941 }
18942 ElementHandlerOutput::Continue { event, .. } => event,
18943 }
18944 }
18945 (_, Event::End(_)) => {
18946 return Ok(DeserializerOutput {
18947 artifact: DeserializerArtifact::Data(self.finish(helper)?),
18948 event: DeserializerEvent::None,
18949 allow_any: false,
18950 });
18951 }
18952 (state @ (S::Init__ | S::Next__), event) => {
18953 fallback.get_or_insert(state);
18954 let output =
18955 <super::ExtensionTypeContent as WithDeserializer>::init(helper, event)?;
18956 match self.handle_content(helper, output, &mut fallback)? {
18957 ElementHandlerOutput::Break { event, allow_any } => {
18958 break (event, allow_any)
18959 }
18960 ElementHandlerOutput::Continue { event, .. } => event,
18961 }
18962 }
18963 }
18964 };
18965 if let Some(fallback) = fallback {
18966 *self.state__ = fallback;
18967 }
18968 let artifact = DeserializerArtifact::Deserializer(self);
18969 Ok(DeserializerOutput {
18970 artifact,
18971 event,
18972 allow_any,
18973 })
18974 }
18975 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::ExtensionType, Error> {
18976 let state = replace(
18977 &mut *self.state__,
18978 ExtensionTypeDeserializerState::Unknown__,
18979 );
18980 self.finish_state(helper, state)?;
18981 Ok(super::ExtensionType {
18982 id: self.id,
18983 base: self.base,
18984 content: helper.finish_vec(0usize, None, self.content)?,
18985 })
18986 }
18987 }
18988 #[derive(Debug)]
18989 pub struct ExtensionTypeContentDeserializer {
18990 state__: Box<ExtensionTypeContentDeserializerState>,
18991 }
18992 #[derive(Debug)]
18993 pub enum ExtensionTypeContentDeserializerState {
18994 Init__,
18995 Annotation(
18996 Option<super::Annotation>,
18997 Option<<super::Annotation as WithDeserializer>::Deserializer>,
18998 Option<<super::Annotation as WithDeserializer>::Deserializer>,
18999 ),
19000 OpenContent(
19001 Option<super::OpenContent>,
19002 Option<<super::OpenContent as WithDeserializer>::Deserializer>,
19003 Option<<super::OpenContent as WithDeserializer>::Deserializer>,
19004 ),
19005 Group(
19006 Option<super::GroupType>,
19007 Option<<super::GroupType as WithDeserializer>::Deserializer>,
19008 Option<<super::GroupType as WithDeserializer>::Deserializer>,
19009 ),
19010 All(
19011 Option<super::GroupType>,
19012 Option<<super::GroupType as WithDeserializer>::Deserializer>,
19013 Option<<super::GroupType as WithDeserializer>::Deserializer>,
19014 ),
19015 Choice(
19016 Option<super::GroupType>,
19017 Option<<super::GroupType as WithDeserializer>::Deserializer>,
19018 Option<<super::GroupType as WithDeserializer>::Deserializer>,
19019 ),
19020 Sequence(
19021 Option<super::GroupType>,
19022 Option<<super::GroupType as WithDeserializer>::Deserializer>,
19023 Option<<super::GroupType as WithDeserializer>::Deserializer>,
19024 ),
19025 Attribute(
19026 Option<super::AttributeType>,
19027 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
19028 Option<<super::AttributeType as WithDeserializer>::Deserializer>,
19029 ),
19030 AttributeGroup(
19031 Option<super::AttributeGroupType>,
19032 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
19033 Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
19034 ),
19035 AnyAttribute(
19036 Option<super::AnyAttribute>,
19037 Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
19038 Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
19039 ),
19040 Assert(
19041 Option<super::AssertionType>,
19042 Option<<super::AssertionType as WithDeserializer>::Deserializer>,
19043 Option<<super::AssertionType as WithDeserializer>::Deserializer>,
19044 ),
19045 Done__(super::ExtensionTypeContent),
19046 Unknown__,
19047 }
19048 impl ExtensionTypeContentDeserializer {
19049 fn find_suitable<'de>(
19050 &mut self,
19051 helper: &mut DeserializeHelper,
19052 event: Event<'de>,
19053 ) -> Result<ElementHandlerOutput<'de>, Error> {
19054 if let Event::Start(x) | Event::Empty(x) = &event {
19055 if matches!(
19056 helper.resolve_local_name(x.name(), &super::NS_XS),
19057 Some(b"annotation")
19058 ) {
19059 let output = <super::Annotation as WithDeserializer>::init(helper, event)?;
19060 return self.handle_annotation(helper, Default::default(), None, output);
19061 }
19062 if matches!(
19063 helper.resolve_local_name(x.name(), &super::NS_XS),
19064 Some(b"openContent")
19065 ) {
19066 let output = <super::OpenContent as WithDeserializer>::init(helper, event)?;
19067 return self.handle_open_content(helper, Default::default(), None, output);
19068 }
19069 if matches!(
19070 helper.resolve_local_name(x.name(), &super::NS_XS),
19071 Some(b"group")
19072 ) {
19073 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
19074 return self.handle_group(helper, Default::default(), None, output);
19075 }
19076 if matches!(
19077 helper.resolve_local_name(x.name(), &super::NS_XS),
19078 Some(b"all")
19079 ) {
19080 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
19081 return self.handle_all(helper, Default::default(), None, output);
19082 }
19083 if matches!(
19084 helper.resolve_local_name(x.name(), &super::NS_XS),
19085 Some(b"choice")
19086 ) {
19087 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
19088 return self.handle_choice(helper, Default::default(), None, output);
19089 }
19090 if matches!(
19091 helper.resolve_local_name(x.name(), &super::NS_XS),
19092 Some(b"sequence")
19093 ) {
19094 let output = <super::GroupType as WithDeserializer>::init(helper, event)?;
19095 return self.handle_sequence(helper, Default::default(), None, output);
19096 }
19097 if matches!(
19098 helper.resolve_local_name(x.name(), &super::NS_XS),
19099 Some(b"attribute")
19100 ) {
19101 let output = <super::AttributeType as WithDeserializer>::init(helper, event)?;
19102 return self.handle_attribute(helper, Default::default(), None, output);
19103 }
19104 if matches!(
19105 helper.resolve_local_name(x.name(), &super::NS_XS),
19106 Some(b"attributeGroup")
19107 ) {
19108 let output =
19109 <super::AttributeGroupType as WithDeserializer>::init(helper, event)?;
19110 return self.handle_attribute_group(helper, Default::default(), None, output);
19111 }
19112 if matches!(
19113 helper.resolve_local_name(x.name(), &super::NS_XS),
19114 Some(b"anyAttribute")
19115 ) {
19116 let output = <super::AnyAttribute as WithDeserializer>::init(helper, event)?;
19117 return self.handle_any_attribute(helper, Default::default(), None, output);
19118 }
19119 if matches!(
19120 helper.resolve_local_name(x.name(), &super::NS_XS),
19121 Some(b"assert")
19122 ) {
19123 let output = <super::AssertionType as WithDeserializer>::init(helper, event)?;
19124 return self.handle_assert(helper, Default::default(), None, output);
19125 }
19126 }
19127 *self.state__ = ExtensionTypeContentDeserializerState::Init__;
19128 Ok(ElementHandlerOutput::return_to_parent(event, false))
19129 }
19130 fn finish_state(
19131 helper: &mut DeserializeHelper,
19132 state: ExtensionTypeContentDeserializerState,
19133 ) -> Result<super::ExtensionTypeContent, Error> {
19134 use ExtensionTypeContentDeserializerState as S;
19135 match state {
19136 S::Init__ => Err(ErrorKind::MissingContent.into()),
19137 S::Annotation(mut values, None, deserializer) => {
19138 if let Some(deserializer) = deserializer {
19139 let value = deserializer.finish(helper)?;
19140 ExtensionTypeContentDeserializer::store_annotation(&mut values, value)?;
19141 }
19142 Ok(super::ExtensionTypeContent::Annotation(
19143 helper.finish_element("annotation", values)?,
19144 ))
19145 }
19146 S::OpenContent(mut values, None, deserializer) => {
19147 if let Some(deserializer) = deserializer {
19148 let value = deserializer.finish(helper)?;
19149 ExtensionTypeContentDeserializer::store_open_content(&mut values, value)?;
19150 }
19151 Ok(super::ExtensionTypeContent::OpenContent(
19152 helper.finish_element("openContent", values)?,
19153 ))
19154 }
19155 S::Group(mut values, None, deserializer) => {
19156 if let Some(deserializer) = deserializer {
19157 let value = deserializer.finish(helper)?;
19158 ExtensionTypeContentDeserializer::store_group(&mut values, value)?;
19159 }
19160 Ok(super::ExtensionTypeContent::Group(
19161 helper.finish_element("group", values)?,
19162 ))
19163 }
19164 S::All(mut values, None, deserializer) => {
19165 if let Some(deserializer) = deserializer {
19166 let value = deserializer.finish(helper)?;
19167 ExtensionTypeContentDeserializer::store_all(&mut values, value)?;
19168 }
19169 Ok(super::ExtensionTypeContent::All(
19170 helper.finish_element("all", values)?,
19171 ))
19172 }
19173 S::Choice(mut values, None, deserializer) => {
19174 if let Some(deserializer) = deserializer {
19175 let value = deserializer.finish(helper)?;
19176 ExtensionTypeContentDeserializer::store_choice(&mut values, value)?;
19177 }
19178 Ok(super::ExtensionTypeContent::Choice(
19179 helper.finish_element("choice", values)?,
19180 ))
19181 }
19182 S::Sequence(mut values, None, deserializer) => {
19183 if let Some(deserializer) = deserializer {
19184 let value = deserializer.finish(helper)?;
19185 ExtensionTypeContentDeserializer::store_sequence(&mut values, value)?;
19186 }
19187 Ok(super::ExtensionTypeContent::Sequence(
19188 helper.finish_element("sequence", values)?,
19189 ))
19190 }
19191 S::Attribute(mut values, None, deserializer) => {
19192 if let Some(deserializer) = deserializer {
19193 let value = deserializer.finish(helper)?;
19194 ExtensionTypeContentDeserializer::store_attribute(&mut values, value)?;
19195 }
19196 Ok(super::ExtensionTypeContent::Attribute(
19197 helper.finish_element("attribute", values)?,
19198 ))
19199 }
19200 S::AttributeGroup(mut values, None, deserializer) => {
19201 if let Some(deserializer) = deserializer {
19202 let value = deserializer.finish(helper)?;
19203 ExtensionTypeContentDeserializer::store_attribute_group(
19204 &mut values,
19205 value,
19206 )?;
19207 }
19208 Ok(super::ExtensionTypeContent::AttributeGroup(
19209 helper.finish_element("attributeGroup", values)?,
19210 ))
19211 }
19212 S::AnyAttribute(mut values, None, deserializer) => {
19213 if let Some(deserializer) = deserializer {
19214 let value = deserializer.finish(helper)?;
19215 ExtensionTypeContentDeserializer::store_any_attribute(&mut values, value)?;
19216 }
19217 Ok(super::ExtensionTypeContent::AnyAttribute(
19218 helper.finish_element("anyAttribute", values)?,
19219 ))
19220 }
19221 S::Assert(mut values, None, deserializer) => {
19222 if let Some(deserializer) = deserializer {
19223 let value = deserializer.finish(helper)?;
19224 ExtensionTypeContentDeserializer::store_assert(&mut values, value)?;
19225 }
19226 Ok(super::ExtensionTypeContent::Assert(
19227 helper.finish_element("assert", values)?,
19228 ))
19229 }
19230 S::Done__(data) => Ok(data),
19231 _ => unreachable!(),
19232 }
19233 }
19234 fn store_annotation(
19235 values: &mut Option<super::Annotation>,
19236 value: super::Annotation,
19237 ) -> Result<(), Error> {
19238 if values.is_some() {
19239 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
19240 b"annotation",
19241 )))?;
19242 }
19243 *values = Some(value);
19244 Ok(())
19245 }
19246 fn store_open_content(
19247 values: &mut Option<super::OpenContent>,
19248 value: super::OpenContent,
19249 ) -> Result<(), Error> {
19250 if values.is_some() {
19251 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
19252 b"openContent",
19253 )))?;
19254 }
19255 *values = Some(value);
19256 Ok(())
19257 }
19258 fn store_group(
19259 values: &mut Option<super::GroupType>,
19260 value: super::GroupType,
19261 ) -> Result<(), Error> {
19262 if values.is_some() {
19263 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
19264 b"group",
19265 )))?;
19266 }
19267 *values = Some(value);
19268 Ok(())
19269 }
19270 fn store_all(
19271 values: &mut Option<super::GroupType>,
19272 value: super::GroupType,
19273 ) -> Result<(), Error> {
19274 if values.is_some() {
19275 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"all")))?;
19276 }
19277 *values = Some(value);
19278 Ok(())
19279 }
19280 fn store_choice(
19281 values: &mut Option<super::GroupType>,
19282 value: super::GroupType,
19283 ) -> Result<(), Error> {
19284 if values.is_some() {
19285 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
19286 b"choice",
19287 )))?;
19288 }
19289 *values = Some(value);
19290 Ok(())
19291 }
19292 fn store_sequence(
19293 values: &mut Option<super::GroupType>,
19294 value: super::GroupType,
19295 ) -> Result<(), Error> {
19296 if values.is_some() {
19297 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
19298 b"sequence",
19299 )))?;
19300 }
19301 *values = Some(value);
19302 Ok(())
19303 }
19304 fn store_attribute(
19305 values: &mut Option<super::AttributeType>,
19306 value: super::AttributeType,
19307 ) -> Result<(), Error> {
19308 if values.is_some() {
19309 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
19310 b"attribute",
19311 )))?;
19312 }
19313 *values = Some(value);
19314 Ok(())
19315 }
19316 fn store_attribute_group(
19317 values: &mut Option<super::AttributeGroupType>,
19318 value: super::AttributeGroupType,
19319 ) -> Result<(), Error> {
19320 if values.is_some() {
19321 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
19322 b"attributeGroup",
19323 )))?;
19324 }
19325 *values = Some(value);
19326 Ok(())
19327 }
19328 fn store_any_attribute(
19329 values: &mut Option<super::AnyAttribute>,
19330 value: super::AnyAttribute,
19331 ) -> Result<(), Error> {
19332 if values.is_some() {
19333 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
19334 b"anyAttribute",
19335 )))?;
19336 }
19337 *values = Some(value);
19338 Ok(())
19339 }
19340 fn store_assert(
19341 values: &mut Option<super::AssertionType>,
19342 value: super::AssertionType,
19343 ) -> Result<(), Error> {
19344 if values.is_some() {
19345 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
19346 b"assert",
19347 )))?;
19348 }
19349 *values = Some(value);
19350 Ok(())
19351 }
19352 fn handle_annotation<'de>(
19353 &mut self,
19354 helper: &mut DeserializeHelper,
19355 mut values: Option<super::Annotation>,
19356 fallback: Option<<super::Annotation as WithDeserializer>::Deserializer>,
19357 output: DeserializerOutput<'de, super::Annotation>,
19358 ) -> Result<ElementHandlerOutput<'de>, Error> {
19359 use ExtensionTypeContentDeserializerState as S;
19360 let DeserializerOutput {
19361 artifact,
19362 event,
19363 allow_any,
19364 } = output;
19365 if artifact.is_none() {
19366 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
19367 }
19368 if let Some(deserializer) = fallback {
19369 let data = deserializer.finish(helper)?;
19370 ExtensionTypeContentDeserializer::store_annotation(&mut values, data)?;
19371 }
19372 match artifact {
19373 DeserializerArtifact::None => unreachable!(),
19374 DeserializerArtifact::Data(data) => {
19375 ExtensionTypeContentDeserializer::store_annotation(&mut values, data)?;
19376 let data = ExtensionTypeContentDeserializer::finish_state(
19377 helper,
19378 S::Annotation(values, None, None),
19379 )?;
19380 *self.state__ = S::Done__(data);
19381 Ok(ElementHandlerOutput::break_(event, allow_any))
19382 }
19383 DeserializerArtifact::Deserializer(deserializer) => {
19384 *self.state__ = S::Annotation(values, None, Some(deserializer));
19385 Ok(ElementHandlerOutput::break_(event, allow_any))
19386 }
19387 }
19388 }
19389 fn handle_open_content<'de>(
19390 &mut self,
19391 helper: &mut DeserializeHelper,
19392 mut values: Option<super::OpenContent>,
19393 fallback: Option<<super::OpenContent as WithDeserializer>::Deserializer>,
19394 output: DeserializerOutput<'de, super::OpenContent>,
19395 ) -> Result<ElementHandlerOutput<'de>, Error> {
19396 use ExtensionTypeContentDeserializerState as S;
19397 let DeserializerOutput {
19398 artifact,
19399 event,
19400 allow_any,
19401 } = output;
19402 if artifact.is_none() {
19403 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
19404 }
19405 if let Some(deserializer) = fallback {
19406 let data = deserializer.finish(helper)?;
19407 ExtensionTypeContentDeserializer::store_open_content(&mut values, data)?;
19408 }
19409 match artifact {
19410 DeserializerArtifact::None => unreachable!(),
19411 DeserializerArtifact::Data(data) => {
19412 ExtensionTypeContentDeserializer::store_open_content(&mut values, data)?;
19413 let data = ExtensionTypeContentDeserializer::finish_state(
19414 helper,
19415 S::OpenContent(values, None, None),
19416 )?;
19417 *self.state__ = S::Done__(data);
19418 Ok(ElementHandlerOutput::break_(event, allow_any))
19419 }
19420 DeserializerArtifact::Deserializer(deserializer) => {
19421 *self.state__ = S::OpenContent(values, None, Some(deserializer));
19422 Ok(ElementHandlerOutput::break_(event, allow_any))
19423 }
19424 }
19425 }
19426 fn handle_group<'de>(
19427 &mut self,
19428 helper: &mut DeserializeHelper,
19429 mut values: Option<super::GroupType>,
19430 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
19431 output: DeserializerOutput<'de, super::GroupType>,
19432 ) -> Result<ElementHandlerOutput<'de>, Error> {
19433 use ExtensionTypeContentDeserializerState as S;
19434 let DeserializerOutput {
19435 artifact,
19436 event,
19437 allow_any,
19438 } = output;
19439 if artifact.is_none() {
19440 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
19441 }
19442 if let Some(deserializer) = fallback {
19443 let data = deserializer.finish(helper)?;
19444 ExtensionTypeContentDeserializer::store_group(&mut values, data)?;
19445 }
19446 match artifact {
19447 DeserializerArtifact::None => unreachable!(),
19448 DeserializerArtifact::Data(data) => {
19449 ExtensionTypeContentDeserializer::store_group(&mut values, data)?;
19450 let data = ExtensionTypeContentDeserializer::finish_state(
19451 helper,
19452 S::Group(values, None, None),
19453 )?;
19454 *self.state__ = S::Done__(data);
19455 Ok(ElementHandlerOutput::break_(event, allow_any))
19456 }
19457 DeserializerArtifact::Deserializer(deserializer) => {
19458 *self.state__ = S::Group(values, None, Some(deserializer));
19459 Ok(ElementHandlerOutput::break_(event, allow_any))
19460 }
19461 }
19462 }
19463 fn handle_all<'de>(
19464 &mut self,
19465 helper: &mut DeserializeHelper,
19466 mut values: Option<super::GroupType>,
19467 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
19468 output: DeserializerOutput<'de, super::GroupType>,
19469 ) -> Result<ElementHandlerOutput<'de>, Error> {
19470 use ExtensionTypeContentDeserializerState as S;
19471 let DeserializerOutput {
19472 artifact,
19473 event,
19474 allow_any,
19475 } = output;
19476 if artifact.is_none() {
19477 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
19478 }
19479 if let Some(deserializer) = fallback {
19480 let data = deserializer.finish(helper)?;
19481 ExtensionTypeContentDeserializer::store_all(&mut values, data)?;
19482 }
19483 match artifact {
19484 DeserializerArtifact::None => unreachable!(),
19485 DeserializerArtifact::Data(data) => {
19486 ExtensionTypeContentDeserializer::store_all(&mut values, data)?;
19487 let data = ExtensionTypeContentDeserializer::finish_state(
19488 helper,
19489 S::All(values, None, None),
19490 )?;
19491 *self.state__ = S::Done__(data);
19492 Ok(ElementHandlerOutput::break_(event, allow_any))
19493 }
19494 DeserializerArtifact::Deserializer(deserializer) => {
19495 *self.state__ = S::All(values, None, Some(deserializer));
19496 Ok(ElementHandlerOutput::break_(event, allow_any))
19497 }
19498 }
19499 }
19500 fn handle_choice<'de>(
19501 &mut self,
19502 helper: &mut DeserializeHelper,
19503 mut values: Option<super::GroupType>,
19504 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
19505 output: DeserializerOutput<'de, super::GroupType>,
19506 ) -> Result<ElementHandlerOutput<'de>, Error> {
19507 use ExtensionTypeContentDeserializerState as S;
19508 let DeserializerOutput {
19509 artifact,
19510 event,
19511 allow_any,
19512 } = output;
19513 if artifact.is_none() {
19514 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
19515 }
19516 if let Some(deserializer) = fallback {
19517 let data = deserializer.finish(helper)?;
19518 ExtensionTypeContentDeserializer::store_choice(&mut values, data)?;
19519 }
19520 match artifact {
19521 DeserializerArtifact::None => unreachable!(),
19522 DeserializerArtifact::Data(data) => {
19523 ExtensionTypeContentDeserializer::store_choice(&mut values, data)?;
19524 let data = ExtensionTypeContentDeserializer::finish_state(
19525 helper,
19526 S::Choice(values, None, None),
19527 )?;
19528 *self.state__ = S::Done__(data);
19529 Ok(ElementHandlerOutput::break_(event, allow_any))
19530 }
19531 DeserializerArtifact::Deserializer(deserializer) => {
19532 *self.state__ = S::Choice(values, None, Some(deserializer));
19533 Ok(ElementHandlerOutput::break_(event, allow_any))
19534 }
19535 }
19536 }
19537 fn handle_sequence<'de>(
19538 &mut self,
19539 helper: &mut DeserializeHelper,
19540 mut values: Option<super::GroupType>,
19541 fallback: Option<<super::GroupType as WithDeserializer>::Deserializer>,
19542 output: DeserializerOutput<'de, super::GroupType>,
19543 ) -> Result<ElementHandlerOutput<'de>, Error> {
19544 use ExtensionTypeContentDeserializerState as S;
19545 let DeserializerOutput {
19546 artifact,
19547 event,
19548 allow_any,
19549 } = output;
19550 if artifact.is_none() {
19551 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
19552 }
19553 if let Some(deserializer) = fallback {
19554 let data = deserializer.finish(helper)?;
19555 ExtensionTypeContentDeserializer::store_sequence(&mut values, data)?;
19556 }
19557 match artifact {
19558 DeserializerArtifact::None => unreachable!(),
19559 DeserializerArtifact::Data(data) => {
19560 ExtensionTypeContentDeserializer::store_sequence(&mut values, data)?;
19561 let data = ExtensionTypeContentDeserializer::finish_state(
19562 helper,
19563 S::Sequence(values, None, None),
19564 )?;
19565 *self.state__ = S::Done__(data);
19566 Ok(ElementHandlerOutput::break_(event, allow_any))
19567 }
19568 DeserializerArtifact::Deserializer(deserializer) => {
19569 *self.state__ = S::Sequence(values, None, Some(deserializer));
19570 Ok(ElementHandlerOutput::break_(event, allow_any))
19571 }
19572 }
19573 }
19574 fn handle_attribute<'de>(
19575 &mut self,
19576 helper: &mut DeserializeHelper,
19577 mut values: Option<super::AttributeType>,
19578 fallback: Option<<super::AttributeType as WithDeserializer>::Deserializer>,
19579 output: DeserializerOutput<'de, super::AttributeType>,
19580 ) -> Result<ElementHandlerOutput<'de>, Error> {
19581 use ExtensionTypeContentDeserializerState as S;
19582 let DeserializerOutput {
19583 artifact,
19584 event,
19585 allow_any,
19586 } = output;
19587 if artifact.is_none() {
19588 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
19589 }
19590 if let Some(deserializer) = fallback {
19591 let data = deserializer.finish(helper)?;
19592 ExtensionTypeContentDeserializer::store_attribute(&mut values, data)?;
19593 }
19594 match artifact {
19595 DeserializerArtifact::None => unreachable!(),
19596 DeserializerArtifact::Data(data) => {
19597 ExtensionTypeContentDeserializer::store_attribute(&mut values, data)?;
19598 let data = ExtensionTypeContentDeserializer::finish_state(
19599 helper,
19600 S::Attribute(values, None, None),
19601 )?;
19602 *self.state__ = S::Done__(data);
19603 Ok(ElementHandlerOutput::break_(event, allow_any))
19604 }
19605 DeserializerArtifact::Deserializer(deserializer) => {
19606 *self.state__ = S::Attribute(values, None, Some(deserializer));
19607 Ok(ElementHandlerOutput::break_(event, allow_any))
19608 }
19609 }
19610 }
19611 fn handle_attribute_group<'de>(
19612 &mut self,
19613 helper: &mut DeserializeHelper,
19614 mut values: Option<super::AttributeGroupType>,
19615 fallback: Option<<super::AttributeGroupType as WithDeserializer>::Deserializer>,
19616 output: DeserializerOutput<'de, super::AttributeGroupType>,
19617 ) -> Result<ElementHandlerOutput<'de>, Error> {
19618 use ExtensionTypeContentDeserializerState as S;
19619 let DeserializerOutput {
19620 artifact,
19621 event,
19622 allow_any,
19623 } = output;
19624 if artifact.is_none() {
19625 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
19626 }
19627 if let Some(deserializer) = fallback {
19628 let data = deserializer.finish(helper)?;
19629 ExtensionTypeContentDeserializer::store_attribute_group(&mut values, data)?;
19630 }
19631 match artifact {
19632 DeserializerArtifact::None => unreachable!(),
19633 DeserializerArtifact::Data(data) => {
19634 ExtensionTypeContentDeserializer::store_attribute_group(&mut values, data)?;
19635 let data = ExtensionTypeContentDeserializer::finish_state(
19636 helper,
19637 S::AttributeGroup(values, None, None),
19638 )?;
19639 *self.state__ = S::Done__(data);
19640 Ok(ElementHandlerOutput::break_(event, allow_any))
19641 }
19642 DeserializerArtifact::Deserializer(deserializer) => {
19643 *self.state__ = S::AttributeGroup(values, None, Some(deserializer));
19644 Ok(ElementHandlerOutput::break_(event, allow_any))
19645 }
19646 }
19647 }
19648 fn handle_any_attribute<'de>(
19649 &mut self,
19650 helper: &mut DeserializeHelper,
19651 mut values: Option<super::AnyAttribute>,
19652 fallback: Option<<super::AnyAttribute as WithDeserializer>::Deserializer>,
19653 output: DeserializerOutput<'de, super::AnyAttribute>,
19654 ) -> Result<ElementHandlerOutput<'de>, Error> {
19655 use ExtensionTypeContentDeserializerState as S;
19656 let DeserializerOutput {
19657 artifact,
19658 event,
19659 allow_any,
19660 } = output;
19661 if artifact.is_none() {
19662 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
19663 }
19664 if let Some(deserializer) = fallback {
19665 let data = deserializer.finish(helper)?;
19666 ExtensionTypeContentDeserializer::store_any_attribute(&mut values, data)?;
19667 }
19668 match artifact {
19669 DeserializerArtifact::None => unreachable!(),
19670 DeserializerArtifact::Data(data) => {
19671 ExtensionTypeContentDeserializer::store_any_attribute(&mut values, data)?;
19672 let data = ExtensionTypeContentDeserializer::finish_state(
19673 helper,
19674 S::AnyAttribute(values, None, None),
19675 )?;
19676 *self.state__ = S::Done__(data);
19677 Ok(ElementHandlerOutput::break_(event, allow_any))
19678 }
19679 DeserializerArtifact::Deserializer(deserializer) => {
19680 *self.state__ = S::AnyAttribute(values, None, Some(deserializer));
19681 Ok(ElementHandlerOutput::break_(event, allow_any))
19682 }
19683 }
19684 }
19685 fn handle_assert<'de>(
19686 &mut self,
19687 helper: &mut DeserializeHelper,
19688 mut values: Option<super::AssertionType>,
19689 fallback: Option<<super::AssertionType as WithDeserializer>::Deserializer>,
19690 output: DeserializerOutput<'de, super::AssertionType>,
19691 ) -> Result<ElementHandlerOutput<'de>, Error> {
19692 use ExtensionTypeContentDeserializerState as S;
19693 let DeserializerOutput {
19694 artifact,
19695 event,
19696 allow_any,
19697 } = output;
19698 if artifact.is_none() {
19699 return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
19700 }
19701 if let Some(deserializer) = fallback {
19702 let data = deserializer.finish(helper)?;
19703 ExtensionTypeContentDeserializer::store_assert(&mut values, data)?;
19704 }
19705 match artifact {
19706 DeserializerArtifact::None => unreachable!(),
19707 DeserializerArtifact::Data(data) => {
19708 ExtensionTypeContentDeserializer::store_assert(&mut values, data)?;
19709 let data = ExtensionTypeContentDeserializer::finish_state(
19710 helper,
19711 S::Assert(values, None, None),
19712 )?;
19713 *self.state__ = S::Done__(data);
19714 Ok(ElementHandlerOutput::break_(event, allow_any))
19715 }
19716 DeserializerArtifact::Deserializer(deserializer) => {
19717 *self.state__ = S::Assert(values, None, Some(deserializer));
19718 Ok(ElementHandlerOutput::break_(event, allow_any))
19719 }
19720 }
19721 }
19722 }
19723 impl<'de> Deserializer<'de, super::ExtensionTypeContent> for Box<ExtensionTypeContentDeserializer> {
19724 fn init(
19725 helper: &mut DeserializeHelper,
19726 event: Event<'de>,
19727 ) -> DeserializerResult<'de, super::ExtensionTypeContent> {
19728 let deserializer = Box::new(ExtensionTypeContentDeserializer {
19729 state__: Box::new(ExtensionTypeContentDeserializerState::Init__),
19730 });
19731 let mut output = deserializer.next(helper, event)?;
19732 output.artifact = match output.artifact {
19733 DeserializerArtifact::Deserializer(x)
19734 if matches!(&*x.state__, ExtensionTypeContentDeserializerState::Init__) =>
19735 {
19736 DeserializerArtifact::None
19737 }
19738 artifact => artifact,
19739 };
19740 Ok(output)
19741 }
19742 fn next(
19743 mut self,
19744 helper: &mut DeserializeHelper,
19745 event: Event<'de>,
19746 ) -> DeserializerResult<'de, super::ExtensionTypeContent> {
19747 use ExtensionTypeContentDeserializerState as S;
19748 let mut event = event;
19749 let (event, allow_any) = loop {
19750 let state = replace(&mut *self.state__, S::Unknown__);
19751 event = match (state, event) {
19752 (S::Unknown__, _) => unreachable!(),
19753 (S::Annotation(values, fallback, Some(deserializer)), event) => {
19754 let output = deserializer.next(helper, event)?;
19755 match self.handle_annotation(helper, values, fallback, output)? {
19756 ElementHandlerOutput::Break { event, allow_any } => {
19757 break (event, allow_any)
19758 }
19759 ElementHandlerOutput::Continue { event, .. } => event,
19760 }
19761 }
19762 (S::OpenContent(values, fallback, Some(deserializer)), event) => {
19763 let output = deserializer.next(helper, event)?;
19764 match self.handle_open_content(helper, values, fallback, output)? {
19765 ElementHandlerOutput::Break { event, allow_any } => {
19766 break (event, allow_any)
19767 }
19768 ElementHandlerOutput::Continue { event, .. } => event,
19769 }
19770 }
19771 (S::Group(values, fallback, Some(deserializer)), event) => {
19772 let output = deserializer.next(helper, event)?;
19773 match self.handle_group(helper, values, fallback, output)? {
19774 ElementHandlerOutput::Break { event, allow_any } => {
19775 break (event, allow_any)
19776 }
19777 ElementHandlerOutput::Continue { event, .. } => event,
19778 }
19779 }
19780 (S::All(values, fallback, Some(deserializer)), event) => {
19781 let output = deserializer.next(helper, event)?;
19782 match self.handle_all(helper, values, fallback, output)? {
19783 ElementHandlerOutput::Break { event, allow_any } => {
19784 break (event, allow_any)
19785 }
19786 ElementHandlerOutput::Continue { event, .. } => event,
19787 }
19788 }
19789 (S::Choice(values, fallback, Some(deserializer)), event) => {
19790 let output = deserializer.next(helper, event)?;
19791 match self.handle_choice(helper, values, fallback, output)? {
19792 ElementHandlerOutput::Break { event, allow_any } => {
19793 break (event, allow_any)
19794 }
19795 ElementHandlerOutput::Continue { event, .. } => event,
19796 }
19797 }
19798 (S::Sequence(values, fallback, Some(deserializer)), event) => {
19799 let output = deserializer.next(helper, event)?;
19800 match self.handle_sequence(helper, values, fallback, output)? {
19801 ElementHandlerOutput::Break { event, allow_any } => {
19802 break (event, allow_any)
19803 }
19804 ElementHandlerOutput::Continue { event, .. } => event,
19805 }
19806 }
19807 (S::Attribute(values, fallback, Some(deserializer)), event) => {
19808 let output = deserializer.next(helper, event)?;
19809 match self.handle_attribute(helper, values, fallback, output)? {
19810 ElementHandlerOutput::Break { event, allow_any } => {
19811 break (event, allow_any)
19812 }
19813 ElementHandlerOutput::Continue { event, .. } => event,
19814 }
19815 }
19816 (S::AttributeGroup(values, fallback, Some(deserializer)), event) => {
19817 let output = deserializer.next(helper, event)?;
19818 match self.handle_attribute_group(helper, values, fallback, output)? {
19819 ElementHandlerOutput::Break { event, allow_any } => {
19820 break (event, allow_any)
19821 }
19822 ElementHandlerOutput::Continue { event, .. } => event,
19823 }
19824 }
19825 (S::AnyAttribute(values, fallback, Some(deserializer)), event) => {
19826 let output = deserializer.next(helper, event)?;
19827 match self.handle_any_attribute(helper, values, fallback, output)? {
19828 ElementHandlerOutput::Break { event, allow_any } => {
19829 break (event, allow_any)
19830 }
19831 ElementHandlerOutput::Continue { event, .. } => event,
19832 }
19833 }
19834 (S::Assert(values, fallback, Some(deserializer)), event) => {
19835 let output = deserializer.next(helper, event)?;
19836 match self.handle_assert(helper, values, fallback, output)? {
19837 ElementHandlerOutput::Break { event, allow_any } => {
19838 break (event, allow_any)
19839 }
19840 ElementHandlerOutput::Continue { event, .. } => event,
19841 }
19842 }
19843 (state, event @ Event::End(_)) => {
19844 return Ok(DeserializerOutput {
19845 artifact: DeserializerArtifact::Data(
19846 ExtensionTypeContentDeserializer::finish_state(helper, state)?,
19847 ),
19848 event: DeserializerEvent::Continue(event),
19849 allow_any: false,
19850 });
19851 }
19852 (S::Init__, event) => match self.find_suitable(helper, event)? {
19853 ElementHandlerOutput::Break { event, allow_any } => {
19854 break (event, allow_any)
19855 }
19856 ElementHandlerOutput::Continue { event, .. } => event,
19857 },
19858 (
19859 S::Annotation(values, fallback, None),
19860 event @ (Event::Start(_) | Event::Empty(_)),
19861 ) => {
19862 let output = helper.init_start_tag_deserializer(
19863 event,
19864 Some(&super::NS_XS),
19865 b"annotation",
19866 false,
19867 )?;
19868 match self.handle_annotation(helper, values, fallback, output)? {
19869 ElementHandlerOutput::Break { event, allow_any } => {
19870 break (event, allow_any)
19871 }
19872 ElementHandlerOutput::Continue { event, .. } => event,
19873 }
19874 }
19875 (
19876 S::OpenContent(values, fallback, None),
19877 event @ (Event::Start(_) | Event::Empty(_)),
19878 ) => {
19879 let output = helper.init_start_tag_deserializer(
19880 event,
19881 Some(&super::NS_XS),
19882 b"openContent",
19883 false,
19884 )?;
19885 match self.handle_open_content(helper, values, fallback, output)? {
19886 ElementHandlerOutput::Break { event, allow_any } => {
19887 break (event, allow_any)
19888 }
19889 ElementHandlerOutput::Continue { event, .. } => event,
19890 }
19891 }
19892 (
19893 S::Group(values, fallback, None),
19894 event @ (Event::Start(_) | Event::Empty(_)),
19895 ) => {
19896 let output = helper.init_start_tag_deserializer(
19897 event,
19898 Some(&super::NS_XS),
19899 b"group",
19900 true,
19901 )?;
19902 match self.handle_group(helper, values, fallback, output)? {
19903 ElementHandlerOutput::Break { event, allow_any } => {
19904 break (event, allow_any)
19905 }
19906 ElementHandlerOutput::Continue { event, .. } => event,
19907 }
19908 }
19909 (
19910 S::All(values, fallback, None),
19911 event @ (Event::Start(_) | Event::Empty(_)),
19912 ) => {
19913 let output = helper.init_start_tag_deserializer(
19914 event,
19915 Some(&super::NS_XS),
19916 b"all",
19917 true,
19918 )?;
19919 match self.handle_all(helper, values, fallback, output)? {
19920 ElementHandlerOutput::Break { event, allow_any } => {
19921 break (event, allow_any)
19922 }
19923 ElementHandlerOutput::Continue { event, .. } => event,
19924 }
19925 }
19926 (
19927 S::Choice(values, fallback, None),
19928 event @ (Event::Start(_) | Event::Empty(_)),
19929 ) => {
19930 let output = helper.init_start_tag_deserializer(
19931 event,
19932 Some(&super::NS_XS),
19933 b"choice",
19934 true,
19935 )?;
19936 match self.handle_choice(helper, values, fallback, output)? {
19937 ElementHandlerOutput::Break { event, allow_any } => {
19938 break (event, allow_any)
19939 }
19940 ElementHandlerOutput::Continue { event, .. } => event,
19941 }
19942 }
19943 (
19944 S::Sequence(values, fallback, None),
19945 event @ (Event::Start(_) | Event::Empty(_)),
19946 ) => {
19947 let output = helper.init_start_tag_deserializer(
19948 event,
19949 Some(&super::NS_XS),
19950 b"sequence",
19951 true,
19952 )?;
19953 match self.handle_sequence(helper, values, fallback, output)? {
19954 ElementHandlerOutput::Break { event, allow_any } => {
19955 break (event, allow_any)
19956 }
19957 ElementHandlerOutput::Continue { event, .. } => event,
19958 }
19959 }
19960 (
19961 S::Attribute(values, fallback, None),
19962 event @ (Event::Start(_) | Event::Empty(_)),
19963 ) => {
19964 let output = helper.init_start_tag_deserializer(
19965 event,
19966 Some(&super::NS_XS),
19967 b"attribute",
19968 false,
19969 )?;
19970 match self.handle_attribute(helper, values, fallback, output)? {
19971 ElementHandlerOutput::Break { event, allow_any } => {
19972 break (event, allow_any)
19973 }
19974 ElementHandlerOutput::Continue { event, .. } => event,
19975 }
19976 }
19977 (
19978 S::AttributeGroup(values, fallback, None),
19979 event @ (Event::Start(_) | Event::Empty(_)),
19980 ) => {
19981 let output = helper.init_start_tag_deserializer(
19982 event,
19983 Some(&super::NS_XS),
19984 b"attributeGroup",
19985 false,
19986 )?;
19987 match self.handle_attribute_group(helper, values, fallback, output)? {
19988 ElementHandlerOutput::Break { event, allow_any } => {
19989 break (event, allow_any)
19990 }
19991 ElementHandlerOutput::Continue { event, .. } => event,
19992 }
19993 }
19994 (
19995 S::AnyAttribute(values, fallback, None),
19996 event @ (Event::Start(_) | Event::Empty(_)),
19997 ) => {
19998 let output = helper.init_start_tag_deserializer(
19999 event,
20000 Some(&super::NS_XS),
20001 b"anyAttribute",
20002 false,
20003 )?;
20004 match self.handle_any_attribute(helper, values, fallback, output)? {
20005 ElementHandlerOutput::Break { event, allow_any } => {
20006 break (event, allow_any)
20007 }
20008 ElementHandlerOutput::Continue { event, .. } => event,
20009 }
20010 }
20011 (
20012 S::Assert(values, fallback, None),
20013 event @ (Event::Start(_) | Event::Empty(_)),
20014 ) => {
20015 let output = helper.init_start_tag_deserializer(
20016 event,
20017 Some(&super::NS_XS),
20018 b"assert",
20019 false,
20020 )?;
20021 match self.handle_assert(helper, values, fallback, output)? {
20022 ElementHandlerOutput::Break { event, allow_any } => {
20023 break (event, allow_any)
20024 }
20025 ElementHandlerOutput::Continue { event, .. } => event,
20026 }
20027 }
20028 (state @ S::Done__(_), event) => {
20029 *self.state__ = state;
20030 break (DeserializerEvent::Continue(event), false);
20031 }
20032 (state, event) => {
20033 *self.state__ = state;
20034 break (DeserializerEvent::Continue(event), false);
20035 }
20036 }
20037 };
20038 let artifact = if matches!(&*self.state__, S::Done__(_)) {
20039 DeserializerArtifact::Data(self.finish(helper)?)
20040 } else {
20041 DeserializerArtifact::Deserializer(self)
20042 };
20043 Ok(DeserializerOutput {
20044 artifact,
20045 event,
20046 allow_any,
20047 })
20048 }
20049 fn finish(
20050 self,
20051 helper: &mut DeserializeHelper,
20052 ) -> Result<super::ExtensionTypeContent, Error> {
20053 ExtensionTypeContentDeserializer::finish_state(helper, *self.state__)
20054 }
20055 }
20056 #[derive(Debug)]
20057 pub struct FieldDeserializer {
20058 id: Option<String>,
20059 xpath: String,
20060 xpath_default_namespace: Option<super::XpathDefaultNamespaceType>,
20061 annotation: Option<super::Annotation>,
20062 state__: Box<FieldDeserializerState>,
20063 }
20064 #[derive(Debug)]
20065 enum FieldDeserializerState {
20066 Init__,
20067 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
20068 Done__,
20069 Unknown__,
20070 }
20071 impl FieldDeserializer {
20072 fn from_bytes_start(
20073 helper: &mut DeserializeHelper,
20074 bytes_start: &BytesStart<'_>,
20075 ) -> Result<Box<Self>, Error> {
20076 let mut id: Option<String> = None;
20077 let mut xpath: Option<String> = None;
20078 let mut xpath_default_namespace: Option<super::XpathDefaultNamespaceType> = None;
20079 for attrib in helper.filter_xmlns_attributes(bytes_start) {
20080 let attrib = attrib?;
20081 if matches!(
20082 helper.resolve_local_name(attrib.key, &super::NS_XS),
20083 Some(b"id")
20084 ) {
20085 helper.read_attrib(&mut id, b"id", &attrib.value)?;
20086 } else if matches!(
20087 helper.resolve_local_name(attrib.key, &super::NS_XS),
20088 Some(b"xpath")
20089 ) {
20090 helper.read_attrib(&mut xpath, b"xpath", &attrib.value)?;
20091 } else if matches!(
20092 helper.resolve_local_name(attrib.key, &super::NS_XS),
20093 Some(b"xpathDefaultNamespace")
20094 ) {
20095 helper.read_attrib(
20096 &mut xpath_default_namespace,
20097 b"xpathDefaultNamespace",
20098 &attrib.value,
20099 )?;
20100 }
20101 }
20102 Ok(Box::new(Self {
20103 id: id,
20104 xpath: xpath.ok_or_else(|| ErrorKind::MissingAttribute("xpath".into()))?,
20105 xpath_default_namespace: xpath_default_namespace,
20106 annotation: None,
20107 state__: Box::new(FieldDeserializerState::Init__),
20108 }))
20109 }
20110 fn finish_state(
20111 &mut self,
20112 helper: &mut DeserializeHelper,
20113 state: FieldDeserializerState,
20114 ) -> Result<(), Error> {
20115 use FieldDeserializerState as S;
20116 match state {
20117 S::Annotation(Some(deserializer)) => {
20118 self.store_annotation(deserializer.finish(helper)?)?
20119 }
20120 _ => (),
20121 }
20122 Ok(())
20123 }
20124 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
20125 if self.annotation.is_some() {
20126 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
20127 b"annotation",
20128 )))?;
20129 }
20130 self.annotation = Some(value);
20131 Ok(())
20132 }
20133 fn handle_annotation<'de>(
20134 &mut self,
20135 helper: &mut DeserializeHelper,
20136 output: DeserializerOutput<'de, super::Annotation>,
20137 fallback: &mut Option<FieldDeserializerState>,
20138 ) -> Result<ElementHandlerOutput<'de>, Error> {
20139 use FieldDeserializerState as S;
20140 let DeserializerOutput {
20141 artifact,
20142 event,
20143 allow_any,
20144 } = output;
20145 if artifact.is_none() {
20146 fallback.get_or_insert(S::Annotation(None));
20147 *self.state__ = S::Done__;
20148 return Ok(ElementHandlerOutput::from_event(event, allow_any));
20149 }
20150 if let Some(fallback) = fallback.take() {
20151 self.finish_state(helper, fallback)?;
20152 }
20153 match artifact {
20154 DeserializerArtifact::None => unreachable!(),
20155 DeserializerArtifact::Data(data) => {
20156 self.store_annotation(data)?;
20157 *self.state__ = S::Done__;
20158 Ok(ElementHandlerOutput::from_event(event, allow_any))
20159 }
20160 DeserializerArtifact::Deserializer(deserializer) => {
20161 fallback.get_or_insert(S::Annotation(Some(deserializer)));
20162 *self.state__ = S::Done__;
20163 Ok(ElementHandlerOutput::from_event(event, allow_any))
20164 }
20165 }
20166 }
20167 }
20168 impl<'de> Deserializer<'de, super::Field> for Box<FieldDeserializer> {
20169 fn init(
20170 helper: &mut DeserializeHelper,
20171 event: Event<'de>,
20172 ) -> DeserializerResult<'de, super::Field> {
20173 helper.init_deserializer_from_start_event(event, FieldDeserializer::from_bytes_start)
20174 }
20175 fn next(
20176 mut self,
20177 helper: &mut DeserializeHelper,
20178 event: Event<'de>,
20179 ) -> DeserializerResult<'de, super::Field> {
20180 use FieldDeserializerState as S;
20181 let mut event = event;
20182 let mut fallback = None;
20183 let mut allow_any_element = false;
20184 let (event, allow_any) = loop {
20185 let state = replace(&mut *self.state__, S::Unknown__);
20186 event = match (state, event) {
20187 (S::Unknown__, _) => unreachable!(),
20188 (S::Annotation(Some(deserializer)), event) => {
20189 let output = deserializer.next(helper, event)?;
20190 match self.handle_annotation(helper, output, &mut fallback)? {
20191 ElementHandlerOutput::Continue { event, allow_any } => {
20192 allow_any_element = allow_any_element || allow_any;
20193 event
20194 }
20195 ElementHandlerOutput::Break { event, allow_any } => {
20196 break (event, allow_any)
20197 }
20198 }
20199 }
20200 (_, Event::End(_)) => {
20201 if let Some(fallback) = fallback.take() {
20202 self.finish_state(helper, fallback)?;
20203 }
20204 return Ok(DeserializerOutput {
20205 artifact: DeserializerArtifact::Data(self.finish(helper)?),
20206 event: DeserializerEvent::None,
20207 allow_any: false,
20208 });
20209 }
20210 (S::Init__, event) => {
20211 fallback.get_or_insert(S::Init__);
20212 *self.state__ = S::Annotation(None);
20213 event
20214 }
20215 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
20216 let output = helper.init_start_tag_deserializer(
20217 event,
20218 Some(&super::NS_XS),
20219 b"annotation",
20220 false,
20221 )?;
20222 match self.handle_annotation(helper, output, &mut fallback)? {
20223 ElementHandlerOutput::Continue { event, allow_any } => {
20224 allow_any_element = allow_any_element || allow_any;
20225 event
20226 }
20227 ElementHandlerOutput::Break { event, allow_any } => {
20228 break (event, allow_any)
20229 }
20230 }
20231 }
20232 (S::Done__, event) => {
20233 *self.state__ = S::Done__;
20234 break (DeserializerEvent::Continue(event), allow_any_element);
20235 }
20236 (state, event) => {
20237 *self.state__ = state;
20238 break (DeserializerEvent::Break(event), false);
20239 }
20240 }
20241 };
20242 if let Some(fallback) = fallback {
20243 *self.state__ = fallback;
20244 }
20245 Ok(DeserializerOutput {
20246 artifact: DeserializerArtifact::Deserializer(self),
20247 event,
20248 allow_any,
20249 })
20250 }
20251 fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::Field, Error> {
20252 let state = replace(&mut *self.state__, FieldDeserializerState::Unknown__);
20253 self.finish_state(helper, state)?;
20254 Ok(super::Field {
20255 id: self.id,
20256 xpath: self.xpath,
20257 xpath_default_namespace: self.xpath_default_namespace,
20258 annotation: self.annotation,
20259 })
20260 }
20261 }
20262 #[derive(Debug)]
20263 pub struct FacetInnerTypeDeserializer {
20264 id: Option<String>,
20265 value: String,
20266 fixed: bool,
20267 annotation: Option<super::Annotation>,
20268 state__: Box<FacetInnerTypeDeserializerState>,
20269 }
20270 #[derive(Debug)]
20271 enum FacetInnerTypeDeserializerState {
20272 Init__,
20273 Annotation(Option<<super::Annotation as WithDeserializer>::Deserializer>),
20274 Done__,
20275 Unknown__,
20276 }
20277 impl FacetInnerTypeDeserializer {
20278 fn from_bytes_start(
20279 helper: &mut DeserializeHelper,
20280 bytes_start: &BytesStart<'_>,
20281 ) -> Result<Box<Self>, Error> {
20282 let mut id: Option<String> = None;
20283 let mut value: Option<String> = None;
20284 let mut fixed: Option<bool> = None;
20285 for attrib in helper.filter_xmlns_attributes(bytes_start) {
20286 let attrib = attrib?;
20287 if matches!(
20288 helper.resolve_local_name(attrib.key, &super::NS_XS),
20289 Some(b"id")
20290 ) {
20291 helper.read_attrib(&mut id, b"id", &attrib.value)?;
20292 } else if matches!(
20293 helper.resolve_local_name(attrib.key, &super::NS_XS),
20294 Some(b"value")
20295 ) {
20296 helper.read_attrib(&mut value, b"value", &attrib.value)?;
20297 } else if matches!(
20298 helper.resolve_local_name(attrib.key, &super::NS_XS),
20299 Some(b"fixed")
20300 ) {
20301 helper.read_attrib(&mut fixed, b"fixed", &attrib.value)?;
20302 }
20303 }
20304 Ok(Box::new(Self {
20305 id: id,
20306 value: value.ok_or_else(|| ErrorKind::MissingAttribute("value".into()))?,
20307 fixed: fixed.unwrap_or_else(super::FacetInnerType::default_fixed),
20308 annotation: None,
20309 state__: Box::new(FacetInnerTypeDeserializerState::Init__),
20310 }))
20311 }
20312 fn finish_state(
20313 &mut self,
20314 helper: &mut DeserializeHelper,
20315 state: FacetInnerTypeDeserializerState,
20316 ) -> Result<(), Error> {
20317 use FacetInnerTypeDeserializerState as S;
20318 match state {
20319 S::Annotation(Some(deserializer)) => {
20320 self.store_annotation(deserializer.finish(helper)?)?
20321 }
20322 _ => (),
20323 }
20324 Ok(())
20325 }
20326 fn store_annotation(&mut self, value: super::Annotation) -> Result<(), Error> {
20327 if self.annotation.is_some() {
20328 Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
20329 b"annotation",
20330 )))?;
20331 }
20332 self.annotation = Some(value);
20333 Ok(())
20334 }
20335 fn handle_annotation<'de>(
20336 &mut self,
20337 helper: &mut DeserializeHelper,
20338 output: DeserializerOutput<'de, super::Annotation>,
20339 fallback: &mut Option<FacetInnerTypeDeserializerState>,
20340 ) -> Result<ElementHandlerOutput<'de>, Error> {
20341 use FacetInnerTypeDeserializerState as S;
20342 let DeserializerOutput {
20343 artifact,
20344 event,
20345 allow_any,
20346 } = output;
20347 if artifact.is_none() {
20348 fallback.get_or_insert(S::Annotation(None));
20349 *self.state__ = S::Done__;
20350 return Ok(ElementHandlerOutput::from_event(event, allow_any));
20351 }
20352 if let Some(fallback) = fallback.take() {
20353 self.finish_state(helper, fallback)?;
20354 }
20355 match artifact {
20356 DeserializerArtifact::None => unreachable!(),
20357 DeserializerArtifact::Data(data) => {
20358 self.store_annotation(data)?;
20359 *self.state__ = S::Done__;
20360 Ok(ElementHandlerOutput::from_event(event, allow_any))
20361 }
20362 DeserializerArtifact::Deserializer(deserializer) => {
20363 fallback.get_or_insert(S::Annotation(Some(deserializer)));
20364 *self.state__ = S::Done__;
20365 Ok(ElementHandlerOutput::from_event(event, allow_any))
20366 }
20367 }
20368 }
20369 }
20370 impl<'de> Deserializer<'de, super::FacetInnerType> for Box<FacetInnerTypeDeserializer> {
20371 fn init(
20372 helper: &mut DeserializeHelper,
20373 event: Event<'de>,
20374 ) -> DeserializerResult<'de, super::FacetInnerType> {
20375 helper.init_deserializer_from_start_event(
20376 event,
20377 FacetInnerTypeDeserializer::from_bytes_start,
20378 )
20379 }
20380 fn next(
20381 mut self,
20382 helper: &mut DeserializeHelper,
20383 event: Event<'de>,
20384 ) -> DeserializerResult<'de, super::FacetInnerType> {
20385 use FacetInnerTypeDeserializerState as S;
20386 let mut event = event;
20387 let mut fallback = None;
20388 let mut allow_any_element = false;
20389 let (event, allow_any) = loop {
20390 let state = replace(&mut *self.state__, S::Unknown__);
20391 event = match (state, event) {
20392 (S::Unknown__, _) => unreachable!(),
20393 (S::Annotation(Some(deserializer)), event) => {
20394 let output = deserializer.next(helper, event)?;
20395 match self.handle_annotation(helper, output, &mut fallback)? {
20396 ElementHandlerOutput::Continue { event, allow_any } => {
20397 allow_any_element = allow_any_element || allow_any;
20398 event
20399 }
20400 ElementHandlerOutput::Break { event, allow_any } => {
20401 break (event, allow_any)
20402 }
20403 }
20404 }
20405 (_, Event::End(_)) => {
20406 if let Some(fallback) = fallback.take() {
20407 self.finish_state(helper, fallback)?;
20408 }
20409 return Ok(DeserializerOutput {
20410 artifact: DeserializerArtifact::Data(self.finish(helper)?),
20411 event: DeserializerEvent::None,
20412 allow_any: false,
20413 });
20414 }
20415 (S::Init__, event) => {
20416 fallback.get_or_insert(S::Init__);
20417 *self.state__ = S::Annotation(None);
20418 event
20419 }
20420 (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => {
20421 let output = helper.init_start_tag_deserializer(
20422 event,
20423 Some(&super::NS_XS),
20424 b"annotation",
20425 false,
20426 )?;
20427 match self.handle_annotation(helper, output, &mut fallback)? {
20428 ElementHandlerOutput::Continue { event, allow_any } => {
20429 allow_any_element = allow_any_element || allow_any;
20430 event
20431 }
20432 ElementHandlerOutput::Break { event, allow_any } => {
20433 break (event, allow_any)
20434 }
20435 }
20436 }
20437 (S::Done__, event) => {
20438 *self.state__ = S::Done__;
20439 break (DeserializerEvent::Continue(event), allow_any_element);
20440 }
20441 (state, event) => {
20442 *self.state__ = state;
20443 break (DeserializerEvent::Break(event), false);
20444 }
20445 }
20446 };
20447 if let Some(fallback) = fallback {
20448 *self.state__ = fallback;
20449 }
20450 Ok(DeserializerOutput {
20451 artifact: DeserializerArtifact::Deserializer(self),
20452 event,
20453 allow_any,
20454 })
20455 }
20456 fn finish(
20457 mut self,
20458 helper: &mut DeserializeHelper,
20459 ) -> Result<super::FacetInnerType, Error> {
20460 let state = replace(
20461 &mut *self.state__,
20462 FacetInnerTypeDeserializerState::Unknown__,
20463 );
20464 self.finish_state(helper, state)?;
20465 Ok(super::FacetInnerType {
20466 id: self.id,
20467 value: self.value,
20468 fixed: self.fixed,
20469 annotation: self.annotation,
20470 })
20471 }
20472 }
20473}