From 70ffa0bb441c616e58e9ca0e9aaeb8ed9e38743a Mon Sep 17 00:00:00 2001 From: Bergmann89 Date: Sat, 20 Jun 2026 23:11:12 +0000 Subject: [PATCH 1/3] Implement proper support for dynamic types and substitution groups The old implementation did only handle substitution groups correctly. If on would like to use dynamic types in combination with substitution groups, the generated code would be incorrect. This commit fixes that issue, by implementing proper support for dynamic types and substitution groups. Suitable tests have been added to cover the new functionality. --- xsd-parser-types/src/quick_xml/deserialize.rs | 60 +- xsd-parser-types/src/quick_xml/mod.rs | 2 +- xsd-parser-types/src/quick_xml/serialize.rs | 140 + xsd-parser-types/src/xml/nillable.rs | 2 +- xsd-parser/src/config/generator.rs | 2 +- xsd-parser/src/config/interpreter.rs | 7 + xsd-parser/src/config/mod.rs | 38 +- xsd-parser/src/config/optimizer.rs | 5 + xsd-parser/src/lib.rs | 14 +- xsd-parser/src/meta_types_printer.rs | 14 +- xsd-parser/src/models/data/dynamic.rs | 28 +- xsd-parser/src/models/ident.rs | 8 +- xsd-parser/src/models/meta/attribute.rs | 2 +- xsd-parser/src/models/meta/dynamic.rs | 97 +- xsd-parser/src/models/meta/element.rs | 55 +- xsd-parser/src/models/meta/enumeration.rs | 2 +- xsd-parser/src/models/meta/mod.rs | 6 +- xsd-parser/src/models/meta/type_eq.rs | 47 +- xsd-parser/src/models/meta/types.rs | 12 +- xsd-parser/src/models/meta/union.rs | 2 +- xsd-parser/src/pipeline/generator/context.rs | 37 +- .../src/pipeline/generator/data/complex.rs | 6 +- .../src/pipeline/generator/data/dynamic.rs | 63 +- xsd-parser/src/pipeline/generator/meta.rs | 2 +- xsd-parser/src/pipeline/generator/mod.rs | 7 +- xsd-parser/src/pipeline/generator/state.rs | 86 +- xsd-parser/src/pipeline/interpreter/error.rs | 2 +- xsd-parser/src/pipeline/interpreter/mod.rs | 20 + xsd-parser/src/pipeline/interpreter/state.rs | 17 +- .../interpreter/state/fix_derived_types.rs | 48 + .../state/fix_element_naming_conflicts.rs | 2 +- .../interpreter/state/generate_types.rs | 1 + .../state/generate_types/type_processor.rs | 47 +- .../state/generate_types/update.rs | 7 +- .../state/generate_types/variant_processor.rs | 139 +- .../pipeline/optimizer/dynamic_to_choice.rs | 137 +- .../pipeline/optimizer/merge_dynamic_types.rs | 128 + xsd-parser/src/pipeline/optimizer/mod.rs | 7 + .../pipeline/optimizer/resolve_typedefs.rs | 14 +- .../renderer/steps/quick_xml/deserialize.rs | 300 +- .../renderer/steps/quick_xml/serialize.rs | 222 +- .../src/pipeline/renderer/steps/types.rs | 10 +- .../feature/dynamic_type/example/default.xml | 5 + .../feature/dynamic_type/expected/default.rs | 33 + .../expected/default_optimized.rs | 26 + .../dynamic_type/expected/quick_xml.rs | 917 + .../expected/quick_xml_optimized.rs | 1235 ++ xsd-parser/tests/feature/dynamic_type/mod.rs | 206 + .../tests/feature/dynamic_type/schema.xsd | 36 + .../example/default.xml | 6 + .../expected/default.rs | 44 + .../expected/default_optimized.rs | 32 + .../expected/quick_xml.rs | 1029 ++ .../expected/quick_xml_optimized.rs | 1525 ++ .../dynamic_type_substitution_group/mod.rs | 219 + .../schema.xsd | 54 + .../example/default.xml | 8 + .../example/default_flatten.xml | 7 + .../example/default_optimized.xml | 7 + .../expected/default.rs | 44 + .../expected/default_flatten.rs | 33 + .../expected/default_optimized.rs | 26 + .../expected/quick_xml.rs | 1073 ++ .../expected/quick_xml_flatten.rs | 934 ++ .../expected/quick_xml_optimized.rs | 1237 ++ .../mod.rs | 367 + .../schema.xsd | 38 + .../feature/dynamic_types/example/default.xml | 4 - .../feature/dynamic_types/expected/default.rs | 28 - .../expected/default_optimized.rs | 21 - xsd-parser/tests/feature/dynamic_types/mod.rs | 191 - .../tests/feature/dynamic_types/schema.xsd | 58 - xsd-parser/tests/feature/mod.rs | 7 +- .../example/default.xml | 4 - .../expected/default.rs | 30 - .../expected/default_optimized.rs | 24 - .../feature/nillable_dynamic_types/mod.rs | 201 - .../feature/nillable_dynamic_types/schema.xsd | 58 - .../substitution_group/example/default.xml | 5 + .../substitution_group/expected/default.rs | 33 + .../expected/default_optimized.rs | 26 + .../expected/quick_xml.rs | 620 +- .../expected/quick_xml_optimized.rs | 746 +- .../tests/feature/substitution_group/mod.rs | 208 + .../feature/substitution_group/schema.xsd | 38 + .../example/default.xml | 9 + .../expected/default.rs | 36 + .../expected/default_optimized.rs | 30 + .../expected/quick_xml.rs | 619 +- .../expected/quick_xml_optimized.rs | 750 +- .../substitution_group_nillable/mod.rs | 252 + .../substitution_group_nillable/schema.xsd | 38 + .../expected0/convert_dynamic_to_choice.rs | 5 + .../expected0/merge_dynamic_types.rs | 33 + .../expected1/merge_dynamic_types.rs | 23 + .../tests/optimizer/merge_dynamic_types.xsd | 30 + xsd-parser/tests/optimizer/mod.rs | 14 + .../tests/schema/ofd/expected/default.rs | 57 +- .../tests/schema/ofd/expected/quick_xml.rs | 13793 +++++++++------- .../tests/schema/onix/expected/default.rs | 193 +- .../tests/schema/onix/expected/quick_xml.rs | 9333 ++++++----- .../schema/opendrive/v1_6/expected/default.rs | 107 +- .../schema/xml_schema/expected/quick_xml.rs | 11595 ++++++++----- 103 files changed, 33435 insertions(+), 16770 deletions(-) create mode 100644 xsd-parser/src/pipeline/interpreter/state/fix_derived_types.rs create mode 100644 xsd-parser/src/pipeline/optimizer/merge_dynamic_types.rs create mode 100644 xsd-parser/tests/feature/dynamic_type/example/default.xml create mode 100644 xsd-parser/tests/feature/dynamic_type/expected/default.rs create mode 100644 xsd-parser/tests/feature/dynamic_type/expected/default_optimized.rs create mode 100644 xsd-parser/tests/feature/dynamic_type/expected/quick_xml.rs create mode 100644 xsd-parser/tests/feature/dynamic_type/expected/quick_xml_optimized.rs create mode 100644 xsd-parser/tests/feature/dynamic_type/mod.rs create mode 100644 xsd-parser/tests/feature/dynamic_type/schema.xsd create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group/example/default.xml create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group/expected/default.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group/expected/default_optimized.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group/expected/quick_xml.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group/expected/quick_xml_optimized.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group/mod.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group/schema.xsd create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default.xml create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default_flatten.xml create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default_optimized.xml create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default_flatten.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default_optimized.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml_flatten.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml_optimized.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/mod.rs create mode 100644 xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/schema.xsd delete mode 100644 xsd-parser/tests/feature/dynamic_types/example/default.xml delete mode 100644 xsd-parser/tests/feature/dynamic_types/expected/default.rs delete mode 100644 xsd-parser/tests/feature/dynamic_types/expected/default_optimized.rs delete mode 100644 xsd-parser/tests/feature/dynamic_types/mod.rs delete mode 100644 xsd-parser/tests/feature/dynamic_types/schema.xsd delete mode 100644 xsd-parser/tests/feature/nillable_dynamic_types/example/default.xml delete mode 100644 xsd-parser/tests/feature/nillable_dynamic_types/expected/default.rs delete mode 100644 xsd-parser/tests/feature/nillable_dynamic_types/expected/default_optimized.rs delete mode 100644 xsd-parser/tests/feature/nillable_dynamic_types/mod.rs delete mode 100644 xsd-parser/tests/feature/nillable_dynamic_types/schema.xsd create mode 100644 xsd-parser/tests/feature/substitution_group/example/default.xml create mode 100644 xsd-parser/tests/feature/substitution_group/expected/default.rs create mode 100644 xsd-parser/tests/feature/substitution_group/expected/default_optimized.rs rename xsd-parser/tests/feature/{dynamic_types => substitution_group}/expected/quick_xml.rs (58%) rename xsd-parser/tests/feature/{dynamic_types => substitution_group}/expected/quick_xml_optimized.rs (53%) create mode 100644 xsd-parser/tests/feature/substitution_group/mod.rs create mode 100644 xsd-parser/tests/feature/substitution_group/schema.xsd create mode 100644 xsd-parser/tests/feature/substitution_group_nillable/example/default.xml create mode 100644 xsd-parser/tests/feature/substitution_group_nillable/expected/default.rs create mode 100644 xsd-parser/tests/feature/substitution_group_nillable/expected/default_optimized.rs rename xsd-parser/tests/feature/{nillable_dynamic_types => substitution_group_nillable}/expected/quick_xml.rs (58%) rename xsd-parser/tests/feature/{nillable_dynamic_types => substitution_group_nillable}/expected/quick_xml_optimized.rs (53%) create mode 100644 xsd-parser/tests/feature/substitution_group_nillable/mod.rs create mode 100644 xsd-parser/tests/feature/substitution_group_nillable/schema.xsd create mode 100644 xsd-parser/tests/optimizer/expected0/merge_dynamic_types.rs create mode 100644 xsd-parser/tests/optimizer/expected1/merge_dynamic_types.rs create mode 100644 xsd-parser/tests/optimizer/merge_dynamic_types.xsd diff --git a/xsd-parser-types/src/quick_xml/deserialize.rs b/xsd-parser-types/src/quick_xml/deserialize.rs index a06099f8..9fca0174 100644 --- a/xsd-parser-types/src/quick_xml/deserialize.rs +++ b/xsd-parser-types/src/quick_xml/deserialize.rs @@ -949,12 +949,66 @@ impl DeserializeHelper { pub fn get_dynamic_type_name<'a>( &self, event: &'a Event<'_>, + ) -> Result>, Error> { + if let Some(name) = self.get_dynamic_type_from_attrib(event)? { + return Ok(Some(name)); + } + + Ok(self.get_dynamic_type_from_tag(event)) + } + + /// Extract the type name of a dynamic type from the xml tag name of the + /// passed event. + /// + /// This is used to dispatch dynamic types that are identified by the + /// element name (e.g. substitution groups). Returns `None` if the event + /// is not a [`Event::Start`] or [`Event::Empty`]. + #[must_use] + pub fn get_dynamic_type_from_tag<'a>(&self, event: &'a Event<'_>) -> Option> { + let (Event::Start(b) | Event::Empty(b)) = &event else { + return None; + }; + + Some(Cow::Borrowed(b.name().0)) + } + + /// Extract the type name of a dynamic type from the `xsi:type` attribute of + /// the passed event. + /// + /// This is used to dispatch dynamic types that are identified by their type + /// (e.g. abstract types resolved via the `xsi:type` attribute). Returns + /// `None` if the event is not a [`Event::Start`] or [`Event::Empty`], or if + /// the tag does not carry a `xsi:type` attribute. + /// + /// # Errors + /// + /// Raise an error if the attributes of the tag could not be resolved. + pub fn get_dynamic_type_from_attrib<'a>( + &self, + event: &'a Event<'_>, ) -> Result>, Error> { let (Event::Start(b) | Event::Empty(b)) = &event else { return Ok(None); }; - let attrib = b + self.get_dynamic_type_from_attrib_bytes(b) + } + + /// Extract the type name of a dynamic type from the `xsi:type` attribute of + /// the passed `BytesStart`. + /// + /// This is used to dispatch dynamic types that are identified by their type + /// (e.g. abstract types resolved via the `xsi:type` attribute). Returns + /// `None` if the tag does not carry a `xsi:type` attribute. + /// + /// # Errors + /// + /// Raise an error if the attributes of the tag could not be resolved. + pub fn get_dynamic_type_from_attrib_bytes<'a>( + &self, + bytes: &'a BytesStart<'_>, + ) -> Result>, Error> { + let attrib = bytes .attributes() .find(|attrib| { let Ok(attrib) = attrib else { return false }; @@ -969,9 +1023,7 @@ impl DeserializeHelper { }) .transpose()?; - let name = attrib.map_or_else(|| Cow::Borrowed(b.name().0), |attrib| attrib.value); - - Ok(Some(name)) + Ok(attrib.map(|attrib| attrib.value)) } /// Initializes a deserializer from the passed `event`. diff --git a/xsd-parser-types/src/quick_xml/mod.rs b/xsd-parser-types/src/quick_xml/mod.rs index c1a56245..0285c6a8 100644 --- a/xsd-parser-types/src/quick_xml/mod.rs +++ b/xsd-parser-types/src/quick_xml/mod.rs @@ -31,7 +31,7 @@ pub use self::reader::{ErrorReader, IoReader, SliceReader, XmlReader, XmlReaderS pub use self::serialize::{ BoxedSerializer, CollectNamespaces, ContentSerializer, DerefIter, IterSerializer, SerializeBytes, SerializeBytesToString, SerializeHelper, SerializeSync, Serializer, - WithBoxedSerializer, WithSerializeToBytes, WithSerializer, + WithBoxedSerializer, WithSerializeToBytes, WithSerializer, XsiTypeSerializer, }; #[cfg(feature = "async")] diff --git a/xsd-parser-types/src/quick_xml/serialize.rs b/xsd-parser-types/src/quick_xml/serialize.rs index ab78541f..f85f8a46 100644 --- a/xsd-parser-types/src/quick_xml/serialize.rs +++ b/xsd-parser-types/src/quick_xml/serialize.rs @@ -512,6 +512,146 @@ where } } +/* XsiTypeSerializer */ + +/// A [`Serializer`] that wraps another (boxed) serializer to serialize a value +/// of a dynamic type that is dispatched via the `xsi:type` attribute. +/// +/// The wrapped serializer emits the value using the element name of its actual +/// (concrete) type. This serializer rewrites the resulting element so that it +/// uses the dynamic type's base element `name` and moves the original element +/// name into a `xsi:type` attribute instead. If the value is already using the +/// base element name (i.e. it is the base type itself) no `xsi:type` attribute +/// is added. +#[derive(Debug)] +pub struct XsiTypeSerializer<'ser, T> { + inner: T, + name: &'ser str, + is_root: bool, + state: XsiTypeState, +} + +#[derive(Debug)] +enum XsiTypeState { + /// The serializer was just created, no event was emitted yet. + Init, + + /// The opening element was not emitted yet. + Pending, + + /// The opening element was emitted, waiting for the matching closing + /// element. The contained value is the current nesting depth. + Open(usize), + + /// The opening (and closing) element was emitted. + Done, +} + +impl<'ser, T> XsiTypeSerializer<'ser, T> { + /// Create a new [`XsiTypeSerializer`] that wraps the passed `inner` + /// serializer and rewrites the emitted element to use the passed base + /// element `name`. + #[must_use] + pub fn new(inner: T, name: &'ser str, is_root: bool) -> Self { + Self { + inner, + name, + is_root, + state: XsiTypeState::Init, + } + } + + /// Rewrite the opening element so that it uses the base element name and + /// references its original (concrete) name via a `xsi:type` attribute. + fn rewrite(&self, bytes: BytesStart<'ser>, helper: &mut SerializeHelper) -> BytesStart<'ser> { + // The value uses the base element name already, so it is the base type + // and does not need a `xsi:type` attribute. + if bytes.name().as_ref() == self.name.as_bytes() { + return bytes; + } + + let type_name = bytes.name().as_ref().to_owned(); + + let mut new = BytesStart::new(self.name); + + if self.is_root { + helper.write_xmlns(&mut new, Some(&NamespacePrefix::XSI), &Namespace::XSI); + } + + new.push_attribute((&b"xsi:type"[..], &type_name[..])); + new.extend_attributes(bytes.attributes().filter_map(|attr| { + let attr = attr.ok()?; + + if attr.key.as_ref() == b"xsi:type" || attr.key.as_ref() == b"xmlns:xsi" { + None + } else { + Some(attr) + } + })); + + new + } +} + +impl<'ser, T> Serializer<'ser> for XsiTypeSerializer<'ser, T> +where + T: Serializer<'ser>, +{ + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + let event = match self.inner.next(helper)? { + Ok(event) => event, + Err(error) => return Some(Err(error)), + }; + + if matches!(self.state, XsiTypeState::Init) { + self.state = XsiTypeState::Pending; + helper.begin_ns_scope(); + } + + if matches!(self.state, XsiTypeState::Pending) { + return Some(Ok(match event { + Event::Empty(bytes) => { + let bytes = self.rewrite(bytes, helper); + self.state = XsiTypeState::Done; + + Event::Empty(bytes) + } + Event::Start(bytes) => { + let bytes = self.rewrite(bytes, helper); + self.state = XsiTypeState::Open(1); + + Event::Start(bytes) + } + other => { + self.state = XsiTypeState::Done; + + other + } + })); + } + + if let XsiTypeState::Open(depth) = &mut self.state { + match &event { + Event::Start(_) => *depth += 1, + Event::End(_) => { + *depth -= 1; + + if *depth == 0 { + self.state = XsiTypeState::Done; + + helper.end_ns_scope(); + + return Some(Ok(Event::End(BytesEnd::new(self.name)))); + } + } + _ => (), + } + } + + Some(Ok(event)) + } +} + /// Trait for collecting namespaces of a type and all its sub-types. /// /// Implement this trait to allow the dynamic serialization mode to discover which diff --git a/xsd-parser-types/src/xml/nillable.rs b/xsd-parser-types/src/xml/nillable.rs index 2aebff4b..f7bfde2e 100644 --- a/xsd-parser-types/src/xml/nillable.rs +++ b/xsd-parser-types/src/xml/nillable.rs @@ -5,6 +5,7 @@ use std::ops::{Deref, DerefMut}; use quick_xml::events::{BytesStart, Event}; use crate::misc::Namespace; +use crate::traits::WithNamespace; #[cfg(feature = "quick-xml")] use crate::quick_xml::{ @@ -12,7 +13,6 @@ use crate::quick_xml::{ DeserializerOutput, DeserializerResult, Error, ErrorKind, SerializeHelper, Serializer, WithDeserializer, WithSerializer, }; -use crate::traits::WithNamespace; /// Implements a nillable XML element. /// diff --git a/xsd-parser/src/config/generator.rs b/xsd-parser/src/config/generator.rs index 0310e107..2cd83bea 100644 --- a/xsd-parser/src/config/generator.rs +++ b/xsd-parser/src/config/generator.rs @@ -325,7 +325,7 @@ pub struct TypePostfix { /// Postfix for the type that is used as content for [`Nillable`](xsd_parser_types::xml::Nillable) elements. pub nillable_content: String, - /// Postfix for concrete elements in a substitution group. + /// Postfix for concrete elements in a substitution group or concrete types of a dynamic type. pub dynamic_element: String, } diff --git a/xsd-parser/src/config/interpreter.rs b/xsd-parser/src/config/interpreter.rs index 494c977e..44f9ae00 100644 --- a/xsd-parser/src/config/interpreter.rs +++ b/xsd-parser/src/config/interpreter.rs @@ -16,6 +16,11 @@ pub struct InterpreterConfig { /// See [`with_type`](crate::Interpreter::with_type) for more details. pub types: Vec<(IdentQuadruple, MetaType)>, + /// List of types to be interpreted as dynamic types. + /// + /// See [`with_dynamic_type`](crate::Interpreter::with_dynamic_type) for more details. + pub dynamic_types: Vec, + /// Additional flags to control the interpreter. pub flags: InterpreterFlags, @@ -30,6 +35,7 @@ impl Default for InterpreterConfig { fn default() -> Self { Self { types: vec![], + dynamic_types: vec![], debug_output: None, flags: InterpreterFlags::BUILDIN_TYPES | InterpreterFlags::DEFAULT_TYPEDEFS @@ -43,6 +49,7 @@ impl Clone for InterpreterConfig { fn clone(&self) -> Self { Self { types: self.types.clone(), + dynamic_types: self.dynamic_types.clone(), debug_output: self.debug_output.clone(), flags: self.flags.clone(), naming: self.naming.as_deref().map(Naming::clone_boxed), diff --git a/xsd-parser/src/config/mod.rs b/xsd-parser/src/config/mod.rs index b7903cc7..dc2ee213 100644 --- a/xsd-parser/src/config/mod.rs +++ b/xsd-parser/src/config/mod.rs @@ -260,16 +260,7 @@ impl Config { /// Enable code generation for [`quick_xml`] serialization. pub fn with_quick_xml_serialize(self) -> Self { - self.with_render_steps([ - RenderStep::Types, - RenderStep::Defaults, - RenderStep::PrefixConstants, - RenderStep::NamespaceConstants, - RenderStep::QuickXmlSerialize { - namespaces: NamespaceSerialization::Global, - default_namespace: None, - }, - ]) + self.with_quick_xml_serialize_config(NamespaceSerialization::Global, None) } /// Enable code generation for [`quick_xml`] serialization. @@ -507,6 +498,33 @@ impl Config { self } + /// Add a list of types to be interpreted as dynamic types to the interpreter. + /// + /// For details please refer to [`InterpreterConfig::dynamic_types`]. + pub fn with_dynamic_types(mut self, types: I) -> Self + where + I: IntoIterator, + I::Item: Into, + { + for ident in types { + self.interpreter.dynamic_types.push(ident.into()); + } + + self + } + + /// Add a type to be interpreted as a dynamic type to the interpreter. + /// + /// For details please refer to [`InterpreterConfig::dynamic_types`]. + pub fn with_dynamic_type(mut self, ident: T) -> Self + where + T: Into, + { + self.interpreter.dynamic_types.push(ident.into()); + + self + } + /// Add a type to the interpreter that should be used to handle `xs:anySimpleType`. /// /// This is a convenient method for adding support for `xs:anySimpleType` with a custom type. diff --git a/xsd-parser/src/config/optimizer.rs b/xsd-parser/src/config/optimizer.rs index 8cff5196..8dc23b5b 100644 --- a/xsd-parser/src/config/optimizer.rs +++ b/xsd-parser/src/config/optimizer.rs @@ -120,5 +120,10 @@ bitflags! { /// /// See [`replace_xs_any_type_with_any_element`](crate::Optimizer::replace_xs_any_type_with_any_element) for details. const REPLACE_XS_ANY_TYPE_WITH_ANY_ELEMENT = 1 << 16; + + /// Whether to merge dynamic types or not. + /// + /// See [`merge_dynamic_types`](crate::Optimizer::merge_dynamic_types) for details. + const MERGE_DYNAMIC_TYPES = 1 << 17; } } diff --git a/xsd-parser/src/lib.rs b/xsd-parser/src/lib.rs index c06dbe3c..474dfb63 100644 --- a/xsd-parser/src/lib.rs +++ b/xsd-parser/src/lib.rs @@ -230,6 +230,11 @@ pub fn exec_interpreter_with_ident_cache( interpreter = interpreter.with_type(ident, ty)?; } + for ident in config.dynamic_types { + let ident = ident.resolve(schemas)?; + interpreter = interpreter.with_dynamic_type(ident); + } + let (types, ident_cache) = interpreter.finish()?; if let Some(output) = config.debug_output { @@ -285,7 +290,8 @@ pub fn exec_optimizer(config: OptimizerConfig, types: MetaTypes) -> Result( config.type_postfix.nillable_content, ); generator = generator.with_type_postfix( - IdentType::DynamicElement, + IdentType::SubstitutionElement, + config.type_postfix.dynamic_element.clone(), + ); + generator = generator.with_type_postfix( + IdentType::DynamicVariant, config.type_postfix.dynamic_element, ); diff --git a/xsd-parser/src/meta_types_printer.rs b/xsd-parser/src/meta_types_printer.rs index e9cece7b..ef32e649 100644 --- a/xsd-parser/src/meta_types_printer.rs +++ b/xsd-parser/src/meta_types_printer.rs @@ -191,12 +191,16 @@ impl<'a> MetaTypesPrinter<'a> { .as_ref() .map_or_else(|| String::from("None"), ToString::to_string) ); - indentln!("derived_types:"); + indentln!("derived_types:"); s.level += 1; - - for meta in &*x.derived_types { - indentln!("{}", meta.type_); + for (key, value) in &x.derived_types { + indentln!( + "{key}={},relationship={:?},display_name={:?}", + value.type_, + value.relationship, + value.display_name + ); } s.level -= 2; @@ -240,7 +244,7 @@ impl<'a> MetaTypesPrinter<'a> { indentln!("ident={}", x.ident); indentln!("form={:?}", x.form); - indentln!("nillable={:?}", x.nillable); + indentln!("flags={:?}", x.flags); indentln!("min_occurs={}", x.min_occurs); indentln!("max_occurs={:?}", x.max_occurs); diff --git a/xsd-parser/src/models/data/dynamic.rs b/xsd-parser/src/models/data/dynamic.rs index 08d30d9c..a9d15828 100644 --- a/xsd-parser/src/models/data/dynamic.rs +++ b/xsd-parser/src/models/data/dynamic.rs @@ -1,8 +1,12 @@ use std::borrow::Cow; -use proc_macro2::{Ident as Ident2, Literal}; +use proc_macro2::{Ident as Ident2, Literal, TokenStream}; -use crate::models::{data::PathData, meta::DynamicMeta, TypeIdent}; +use crate::models::{ + data::{PathData, TagName}, + meta::{DerivedTypeMeta, DynamicMeta}, + TypeIdent, +}; /// Contains additional information for the rendering process of a /// [`MetaTypeVariant::Dynamic`](crate::models::meta::MetaTypeVariant::Dynamic) @@ -22,23 +26,35 @@ pub struct DynamicData<'types> { /// Identifier of the deserializer for this type. pub deserializer_ident: Ident2, + /// List of traits that needs to be implemented by this type. + pub trait_impls: Vec, + + /// Name of the XML tag of the element. + pub tag_name: TagName<'types>, + /// List of additional traits that need to be implemented by the derived /// types (if this type was inherited from another dynamic type). pub sub_traits: Option>, /// List of derived types. - pub derived_types: Vec, + pub derived_types: Vec>, } /// Represents a derived type used by [`DynamicData`] #[derive(Debug)] -pub struct DerivedType { - /// Identifier of the derived type. - pub ident: TypeIdent, +pub struct DerivedType<'types> { + /// Identifier of the derived type (the key of the derived type in the original [`DynamicMeta`]). + pub key: TypeIdent, + + /// Reference to the original type information. + pub meta: Cow<'types, DerivedTypeMeta>, /// Name of the derived type as byte string literal. pub b_name: Literal, + /// Name of the XML tag of the element. + pub tag_name: TagName<'types>, + /// The actual target type of this derived type information. pub target_type: PathData, diff --git a/xsd-parser/src/models/ident.rs b/xsd-parser/src/models/ident.rs index 1f667e78..ca7c8b94 100644 --- a/xsd-parser/src/models/ident.rs +++ b/xsd-parser/src/models/ident.rs @@ -85,7 +85,10 @@ pub enum IdentType { NillableContent = 8, /// One concrete element in a substitution group. - DynamicElement = 9, + SubstitutionElement = 9, + + /// Represents a concrete type a dynamic type can have. + DynamicVariant = 10, } /* TypeIdent */ @@ -336,7 +339,8 @@ fn fmt_ident( Some(IdentType::AttributeGroup) => write!(f, "AttributeGroup(")?, Some(IdentType::Enumeration) => write!(f, "Enumeration(")?, Some(IdentType::NillableContent) => write!(f, "NillableContent(")?, - Some(IdentType::DynamicElement) => write!(f, "DynamicElement(")?, + Some(IdentType::SubstitutionElement) => write!(f, "SubstitutionElement(")?, + Some(IdentType::DynamicVariant) => write!(f, "DynamicVariant(")?, } if f.sign_minus() { diff --git a/xsd-parser/src/models/meta/attribute.rs b/xsd-parser/src/models/meta/attribute.rs index 99a1d6d4..0863478b 100644 --- a/xsd-parser/src/models/meta/attribute.rs +++ b/xsd-parser/src/models/meta/attribute.rs @@ -192,7 +192,7 @@ impl DerefMut for AttributesMeta { impl TypeEq for AttributesMeta { fn type_hash(&self, hasher: &mut H, types: &MetaTypes) { - TypeEq::type_hash_slice(&self.0, hasher, types); + TypeEq::type_hash_iter(&self.0, hasher, types); } fn type_eq(&self, other: &Self, types: &MetaTypes) -> bool { diff --git a/xsd-parser/src/models/meta/dynamic.rs b/xsd-parser/src/models/meta/dynamic.rs index dd3be9ff..dccc0b71 100644 --- a/xsd-parser/src/models/meta/dynamic.rs +++ b/xsd-parser/src/models/meta/dynamic.rs @@ -1,62 +1,118 @@ -//! Contains the [`DynamicMeta`] type information and all related types. +//! Contains the [`SubstitutionMeta`] type information and all related types. use std::hash::{Hash, Hasher}; +use indexmap::IndexMap; + use crate::models::TypeIdent; use super::{MetaTypes, TypeEq}; -/// Type information that contains data about dynamic types. +/// Type information that contains data about dynamic elements (substitution groups) or types. #[derive(Default, Debug, Clone)] pub struct DynamicMeta { - /// Base type of the dynamic type. + /// Base type of this dynamic type. pub type_: Option, - /// List of derived types. - pub derived_types: Vec, -} + /// Whether the type was defined as abstract or not. + pub is_abstract: bool, -/// Meta^ information about a derived type. -#[derive(Debug, Clone)] -pub struct DerivedTypeMeta { - /// Identifier of the derived type. - pub type_: TypeIdent, - - /// Name of the element to use inside the generated code. - pub display_name: Option, + /// Map of the derived types of this dynamic type. + pub derived_types: IndexMap, } impl TypeEq for DynamicMeta { fn type_hash(&self, hasher: &mut H, types: &MetaTypes) { let Self { type_, + is_abstract, derived_types, } = self; type_.type_hash(hasher, types); - TypeEq::type_hash_slice(derived_types, hasher, types); + is_abstract.hash(hasher); + TypeEq::type_hash_iter(derived_types, hasher, types); } fn type_eq(&self, other: &Self, types: &MetaTypes) -> bool { let Self { type_, + is_abstract, derived_types, } = self; type_.type_eq(&other.type_, types) + && is_abstract == &other.is_abstract && TypeEq::type_eq_iter(derived_types.iter(), other.derived_types.iter(), types) } } +/// Meta information about a single derived type of a dynamic type. +#[derive(Debug, Clone)] +pub struct DerivedTypeMeta { + /// Identifier of the type this derived type represents. + pub type_: TypeIdent, + + /// Name of the element to use inside the generated code. + pub display_name: Option, + + /// Relationship between this derived type and its owning [`DynamicMeta`]. + pub relationship: DeriveRelationship, +} + +/// Defines the relationship between a [`DerivedTypeMeta`] and its owning [`DynamicMeta`]. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum DeriveRelationship { + /// The derived type is the concrete type definition of this dynamic type. + ConcreteType, + + /// The derived type is a direct child of the base type. + DirectChild, + + /// The derived type is an indirect child of the base type. + IndirectChild, +} + impl DerivedTypeMeta { - /// Creates a new [`DerivedTypeMeta`] instance with the given `type_`. + /// Creates a new [`DerivedTypeMeta`] with the given type. #[must_use] - pub fn new(type_: TypeIdent) -> Self { + pub fn new(type_: TypeIdent, relationship: DeriveRelationship) -> Self { Self { type_, + relationship, display_name: None, } } + + /// Creates a new [`DerivedTypeMeta`] with the given type as a concrete type. + #[must_use] + pub fn new_concrete(type_: TypeIdent) -> Self { + Self::new(type_, DeriveRelationship::ConcreteType) + } + + /// Creates a new [`DerivedTypeMeta`] with the given type as a direct child. + #[must_use] + pub fn new_direct_child(type_: TypeIdent) -> Self { + Self::new(type_, DeriveRelationship::DirectChild) + } + + /// Creates a new [`DerivedTypeMeta`] with the given type as an indirect child. + #[must_use] + pub fn new_indirect_child(type_: TypeIdent) -> Self { + Self::new(type_, DeriveRelationship::IndirectChild) + } + + /// Creates a new [`DerivedTypeMeta`] with the given type and direct or indirect child relationship. + #[must_use] + pub fn new_child(type_: TypeIdent, is_direct: bool) -> Self { + let relationship = if is_direct { + DeriveRelationship::DirectChild + } else { + DeriveRelationship::IndirectChild + }; + + Self::new(type_, relationship) + } } impl TypeEq for DerivedTypeMeta { @@ -64,18 +120,23 @@ impl TypeEq for DerivedTypeMeta { let Self { type_, display_name, + relationship, } = self; type_.type_hash(hasher, types); display_name.hash(hasher); + relationship.hash(hasher); } fn type_eq(&self, other: &Self, types: &MetaTypes) -> bool { let Self { type_, display_name, + relationship, } = self; - type_.type_eq(&other.type_, types) && display_name == &other.display_name + type_.type_eq(&other.type_, types) + && display_name == &other.display_name + && relationship == &other.relationship } } diff --git a/xsd-parser/src/models/meta/element.rs b/xsd-parser/src/models/meta/element.rs index c66de700..d3425c9c 100644 --- a/xsd-parser/src/models/meta/element.rs +++ b/xsd-parser/src/models/meta/element.rs @@ -3,6 +3,8 @@ use std::hash::{Hash, Hasher}; use std::ops::{Deref, DerefMut}; +use bitflags::bitflags; + use crate::models::{ schema::{ xs::{ @@ -27,8 +29,8 @@ pub struct ElementMeta { /// The form of this element. pub form: FormChoiceType, - /// Wether the element is nillable or not. - pub nillable: bool, + /// Different flags that can be set on this element. + pub flags: ElementMetaFlags, /// Minimum occurrence of the field. pub min_occurs: MinOccurs, @@ -43,6 +45,33 @@ pub struct ElementMeta { pub documentation: Vec, } +bitflags! { + /// Different flags that can be set on an [`ElementMeta`]. + #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] + pub struct ElementMetaFlags: u32 { + /// Indicates that the element is nillable. + const NILLABLE = 1 << 0; + + /// If no `xsi:type` attribute is present, this element should be used as default element. + const DEFAULT_ELEMENT = 1 << 1; + + /// Indicates that the element should be identified by its tag name. + const IDENTIFY_BY_TAG = 1 << 2; + + /// Indicates that the element should be identified by the `xsi:type` attribute. + const IDENTIFY_BY_TYPE = 1 << 3; + + /// Indicates that the element should prefer identification by the `xsi:type` attribute. + const PREFER_IDENTIFY_BY_TYPE = 1 << 4; + } +} + +impl Default for ElementMetaFlags { + fn default() -> Self { + Self::IDENTIFY_BY_TAG + } +} + /// Variant of a [`ElementMeta`] /// /// Either it's any element or it has a specific type. @@ -109,7 +138,7 @@ impl ElementMeta { ident, variant: ElementMetaVariant::Type { type_, mode }, form, - nillable: false, + flags: ElementMetaFlags::default(), min_occurs: 1, max_occurs: MaxOccurs::Bounded(1), display_name: None, @@ -124,7 +153,7 @@ impl ElementMeta { ident, variant: ElementMetaVariant::Any { meta }, form: FormChoiceType::Unqualified, - nillable: false, + flags: ElementMetaFlags::default(), min_occurs: 1, max_occurs: MaxOccurs::Bounded(1), display_name: None, @@ -139,7 +168,7 @@ impl ElementMeta { ident, variant: ElementMetaVariant::Text, form: FormChoiceType::Unqualified, - nillable: false, + flags: ElementMetaFlags::default(), min_occurs: 1, max_occurs: MaxOccurs::Bounded(1), display_name: None, @@ -153,6 +182,12 @@ impl ElementMeta { matches!(&self.variant, ElementMetaVariant::Text) } + /// Returns `true` if this element is nillable, `false` otherwise. + #[must_use] + pub fn is_nillable(&self) -> bool { + self.flags.contains(ElementMetaFlags::NILLABLE) + } + /// Returns `true` if this element represents an `xs:any` element, `false` otherwise. #[must_use] pub fn is_any(&self) -> bool { @@ -176,7 +211,7 @@ impl TypeEq for ElementMeta { ident, variant, form, - nillable, + flags, min_occurs, max_occurs, display_name, @@ -186,7 +221,7 @@ impl TypeEq for ElementMeta { ident.hash(hasher); variant.type_hash(hasher, types); form.hash(hasher); - nillable.hash(hasher); + flags.hash(hasher); min_occurs.hash(hasher); max_occurs.hash(hasher); display_name.hash(hasher); @@ -198,7 +233,7 @@ impl TypeEq for ElementMeta { ident, variant, form, - nillable, + flags, min_occurs, max_occurs, display_name, @@ -208,7 +243,7 @@ impl TypeEq for ElementMeta { ident.eq(&other.ident) && variant.type_eq(&other.variant, types) && form.eq(&other.form) - && nillable.eq(&other.nillable) + && flags.eq(&other.flags) && min_occurs.eq(&other.min_occurs) && max_occurs.eq(&other.max_occurs) && display_name.eq(&other.display_name) @@ -258,7 +293,7 @@ impl DerefMut for ElementsMeta { impl TypeEq for ElementsMeta { fn type_hash(&self, hasher: &mut H, types: &MetaTypes) { - TypeEq::type_hash_slice(&self.0, hasher, types); + TypeEq::type_hash_iter(&self.0, hasher, types); } fn type_eq(&self, other: &Self, types: &MetaTypes) -> bool { diff --git a/xsd-parser/src/models/meta/enumeration.rs b/xsd-parser/src/models/meta/enumeration.rs index 2f82b2eb..f1070893 100644 --- a/xsd-parser/src/models/meta/enumeration.rs +++ b/xsd-parser/src/models/meta/enumeration.rs @@ -157,7 +157,7 @@ impl DerefMut for EnumerationMetaVariants { impl TypeEq for EnumerationMetaVariants { fn type_hash(&self, hasher: &mut H, types: &MetaTypes) { - TypeEq::type_hash_slice(&self.0, hasher, types); + TypeEq::type_hash_iter(&self.0, hasher, types); } fn type_eq(&self, other: &Self, types: &MetaTypes) -> bool { diff --git a/xsd-parser/src/models/meta/mod.rs b/xsd-parser/src/models/meta/mod.rs index 3c6cb43f..ae6fd2ab 100644 --- a/xsd-parser/src/models/meta/mod.rs +++ b/xsd-parser/src/models/meta/mod.rs @@ -25,8 +25,10 @@ pub use self::attribute::{AnyAttributeMeta, AttributeMeta, AttributeMetaVariant, pub use self::base::Base; pub use self::complex::{ComplexMeta, GroupMeta}; pub use self::custom::{CustomMeta, CustomMetaNamespace}; -pub use self::dynamic::{DerivedTypeMeta, DynamicMeta}; -pub use self::element::{AnyMeta, ElementMeta, ElementMetaVariant, ElementMode, ElementsMeta}; +pub use self::dynamic::{DeriveRelationship, DerivedTypeMeta, DynamicMeta}; +pub use self::element::{ + AnyMeta, ElementMeta, ElementMetaFlags, ElementMetaVariant, ElementMode, ElementsMeta, +}; pub use self::enumeration::{EnumerationMeta, EnumerationMetaVariant, EnumerationMetaVariants}; pub use self::reference::ReferenceMeta; pub use self::simple::{SimpleMeta, WhiteSpace}; diff --git a/xsd-parser/src/models/meta/type_eq.rs b/xsd-parser/src/models/meta/type_eq.rs index a70746e0..245fad2d 100644 --- a/xsd-parser/src/models/meta/type_eq.rs +++ b/xsd-parser/src/models/meta/type_eq.rs @@ -15,11 +15,17 @@ pub trait TypeEq: Sized { fn type_hash(&self, hasher: &mut H, types: &MetaTypes); /// Feeds a slice of this value into the given [`Hasher`]. - fn type_hash_slice(slice: &[Self], hasher: &mut H, types: &MetaTypes) { - hasher.write_usize(slice.len()); + fn type_hash_iter, H: Hasher>( + slice: T, + hasher: &mut H, + types: &MetaTypes, + ) { + let mut count = 0; for item in slice { item.type_hash(hasher, types); + count += 1; } + hasher.write_usize(count); } /// Check if this instance is equal to the `other` instance using the passed @@ -27,11 +33,10 @@ pub trait TypeEq: Sized { fn type_eq(&self, other: &Self, types: &MetaTypes) -> bool; /// Check if the two passed iterators contain type equal elements. - fn type_eq_iter<'a, X, Y>(x: X, y: Y, types: &MetaTypes) -> bool + fn type_eq_iter(x: X, y: Y, types: &MetaTypes) -> bool where - Self: 'a, - X: IntoIterator, - Y: IntoIterator, + X: IntoIterator, + Y: IntoIterator, { let mut x = x.into_iter(); let mut y = y.into_iter(); @@ -40,7 +45,7 @@ pub trait TypeEq: Sized { match (x.next(), y.next()) { (None, None) => return true, (Some(x), Some(y)) => { - if !x.type_eq(y, types) { + if !x.type_eq(&y, types) { return false; } } @@ -63,6 +68,34 @@ impl TypeEq for TypeIdent { } } +impl TypeEq for &T +where + T: TypeEq, +{ + fn type_hash(&self, hasher: &mut H, types: &MetaTypes) { + (*self).type_hash(hasher, types); + } + + fn type_eq(&self, other: &Self, types: &MetaTypes) -> bool { + (*self).type_eq(*other, types) + } +} + +impl TypeEq for (T1, T2) +where + T1: TypeEq, + T2: TypeEq, +{ + fn type_hash(&self, hasher: &mut H, types: &MetaTypes) { + self.0.type_hash(hasher, types); + self.1.type_hash(hasher, types); + } + + fn type_eq(&self, other: &Self, types: &MetaTypes) -> bool { + self.0.type_eq(&other.0, types) && self.1.type_eq(&other.1, types) + } +} + impl TypeEq for Option where T: TypeEq, diff --git a/xsd-parser/src/models/meta/types.rs b/xsd-parser/src/models/meta/types.rs index cd2bb87f..6e948363 100644 --- a/xsd-parser/src/models/meta/types.rs +++ b/xsd-parser/src/models/meta/types.rs @@ -3,7 +3,7 @@ use std::collections::BTreeMap; use xsd_parser_types::misc::Namespace; use crate::models::{ - schema::{NamespaceId, SchemaId}, + schema::{xs::FormChoiceType, NamespaceId, SchemaId}, Name, Naming, TypeIdent, }; use crate::traits::{NameBuilder as NameBuilderTrait, Naming as NamingTrait}; @@ -70,6 +70,16 @@ impl MetaTypes { self.naming.builder() } + /// Get the form of the passed `ident` falling back to [`FormChoiceType::Unqualified`] + /// if the type could not be found or the form was not set for the type. + #[must_use] + pub fn get_form(&self, ident: &TypeIdent) -> FormChoiceType { + self.items + .get(ident) + .and_then(|x| x.form) + .unwrap_or(FormChoiceType::Unqualified) + } + /// Get the identifier and the type of the passed `ident` with all single /// type references resolved. /// diff --git a/xsd-parser/src/models/meta/union.rs b/xsd-parser/src/models/meta/union.rs index 2a6339ef..b8551a03 100644 --- a/xsd-parser/src/models/meta/union.rs +++ b/xsd-parser/src/models/meta/union.rs @@ -114,7 +114,7 @@ impl DerefMut for UnionMetaTypes { impl TypeEq for UnionMetaTypes { fn type_hash(&self, hasher: &mut H, types: &MetaTypes) { - TypeEq::type_hash_slice(&self.0, hasher, types); + TypeEq::type_hash_iter(&self.0, hasher, types); } fn type_eq(&self, other: &Self, types: &MetaTypes) -> bool { diff --git a/xsd-parser/src/pipeline/generator/context.rs b/xsd-parser/src/pipeline/generator/context.rs index 20149515..8d9c02d7 100644 --- a/xsd-parser/src/pipeline/generator/context.rs +++ b/xsd-parser/src/pipeline/generator/context.rs @@ -9,7 +9,7 @@ use xsd_parser_types::xml::NamespacesShared; use crate::config::GeneratorFlags; use crate::models::{ code::{ModuleIdent, ModulePath}, - data::Occurs, + data::{Occurs, PathData}, meta::{BuildInMeta, MetaTypeVariant}, schema::xs::Use, TypeIdent, @@ -70,9 +70,7 @@ impl<'a, 'types> Context<'a, 'types> { } pub(super) fn get_trait_infos(&mut self) -> &TraitInfos { - self.state - .trait_infos - .get_or_insert_with(|| TraitInfos::new(self.meta.types)) + &self.state.trait_infos } pub(super) fn get_or_create_type_ref(&mut self, ident: &TypeIdent) -> Result<&TypeRef, Error> { @@ -118,7 +116,7 @@ impl<'a, 'types> Context<'a, 'types> { self.get_trait_infos() .get(&ident) .into_iter() - .flat_map(|info| &info.traits_all) + .flat_map(|info| &info.traits_to_impl) .cloned() .collect::>() .into_iter() @@ -133,6 +131,35 @@ impl<'a, 'types> Context<'a, 'types> { .collect::, _>>() } + pub(super) fn make_traits_derive(&mut self) -> Result>, Error> { + let ident = self.ident.clone(); + + self.get_trait_infos() + .get(&ident) + .and_then(|info| { + if info.traits_to_derive.is_empty() { + None + } else { + Some(info.traits_to_derive.clone()) + } + }) + .map(|traits_to_derive| { + traits_to_derive + .iter() + .map(|ident| { + self.get_or_create_type_ref(ident).map(|x| { + let ident = format_ident!("{}Trait", x.path.ident()); + + let target_type = (*x.path).clone().with_ident(ident); + + PathData::from_path(target_type) + }) + }) + .collect::, _>>() + }) + .transpose() + } + #[allow(clippy::too_many_lines)] pub(super) fn make_value_renderer( &mut self, diff --git a/xsd-parser/src/pipeline/generator/data/complex.rs b/xsd-parser/src/pipeline/generator/data/complex.rs index a84c97b4..baeabc39 100644 --- a/xsd-parser/src/pipeline/generator/data/complex.rs +++ b/xsd-parser/src/pipeline/generator/data/complex.rs @@ -632,7 +632,7 @@ impl<'types> ComplexDataElement<'types> { } ElementMetaVariant::Type { type_, mode } => { let mixed = mixed && *mode == ElementMode::Element; - let nillable = meta.nillable + let nillable = meta.is_nillable() && ctx.check_generator_flags(GeneratorFlags::NILLABLE_TYPE_SUPPORT); if occurs == Occurs::Single @@ -686,7 +686,7 @@ impl<'types> ComplexDataElement<'types> { ident: ElementIdent::named(ident), variant: ElementMetaVariant::Text, form: FormChoiceType::Unqualified, - nillable: false, + flags: Default::default(), min_occurs: 0, max_occurs: MaxOccurs::Bounded(1), display_name: None, @@ -737,7 +737,7 @@ impl<'types> ComplexDataElement<'types> { mode: ElementMode::Group, }, form: FormChoiceType::Unqualified, - nillable: false, + flags: Default::default(), min_occurs, max_occurs, display_name: None, diff --git a/xsd-parser/src/pipeline/generator/data/dynamic.rs b/xsd-parser/src/pipeline/generator/data/dynamic.rs index f0d79623..bef58000 100644 --- a/xsd-parser/src/pipeline/generator/data/dynamic.rs +++ b/xsd-parser/src/pipeline/generator/data/dynamic.rs @@ -4,8 +4,9 @@ use proc_macro2::Literal; use quote::format_ident; use crate::models::{ - data::{DerivedType, DynamicData, PathData}, - meta::{DerivedTypeMeta, DynamicMeta, MetaTypeVariant}, + data::{DerivedType, DynamicData, TagName}, + meta::{DerivedTypeMeta, DynamicMeta}, + TypeIdent, }; use super::super::{Context, Error}; @@ -17,30 +18,15 @@ impl<'types> DynamicData<'types> { ) -> Result { let type_ident = ctx.current_type_ref().path.ident().clone(); let trait_ident = format_ident!("{type_ident}Trait"); - let ident = ctx.ident.clone(); - let sub_traits = ctx - .get_trait_infos() - .get(&ident) - .map(|info| info.traits_direct.clone()) - .map(|traits_direct| { - traits_direct - .iter() - .map(|ident| { - ctx.get_or_create_type_ref(ident).map(|x| { - let ident = format_ident!("{}Trait", x.path.ident()); + let trait_impls = ctx.make_trait_impls()?; + let sub_traits = ctx.make_traits_derive()?; + let form = ctx.types.get_form(ctx.ident); + let tag_name = TagName::new(ctx.types, ctx.ident.ns, &ctx.ident.name, form); - let target_type = (*x.path).clone().with_ident(ident); - - PathData::from_path(target_type) - }) - }) - .collect::, _>>() - }) - .transpose()?; let derived_types = meta .derived_types .iter() - .map(|x| make_derived_type_data(ctx, x)) + .map(|(type_, meta)| make_derived_type_data(ctx, type_, meta)) .collect::, _>>()?; let meta = Cow::Borrowed(meta); @@ -51,6 +37,8 @@ impl<'types> DynamicData<'types> { type_ident, trait_ident, deserializer_ident, + trait_impls, + tag_name, sub_traits, derived_types, }) @@ -59,34 +47,29 @@ impl<'types> DynamicData<'types> { fn make_derived_type_data<'types>( ctx: &mut Context<'_, 'types>, + key: &'types TypeIdent, meta: &'types DerivedTypeMeta, -) -> Result { - let s_name = meta.type_.name.to_string(); +) -> Result, Error> { + let s_name = key.name.to_string(); let b_name = Literal::byte_string(s_name.as_bytes()); + let form = ctx.types.get_form(key); + let tag_name = TagName::new(ctx.types, key.ns, &key.name, form); - let ty = ctx - .types - .items - .get(&meta.type_) - .ok_or_else(|| Error::UnknownType(meta.type_.clone()))?; - - let base_ident = if let MetaTypeVariant::Dynamic(di) = &ty.variant { - di.type_.clone() - } else { - None - }; - - let ident = base_ident.unwrap_or(meta.type_.clone()); - let target_ref = ctx.get_or_create_type_ref(&ident)?; + let key = key.clone(); + let target_ref = ctx.get_or_create_type_ref(&meta.type_)?; let target_type = target_ref.path.clone(); let variant_ident = ctx .types .naming - .format_variant_ident(&ident.name, meta.display_name.as_deref()); + .format_variant_ident(&key.name, meta.display_name.as_deref()); + + let meta = Cow::Borrowed(meta); Ok(DerivedType { - ident, + key, + meta, b_name, + tag_name, target_type, variant_ident, }) diff --git a/xsd-parser/src/pipeline/generator/meta.rs b/xsd-parser/src/pipeline/generator/meta.rs index a2abe6f8..3edf3b9f 100644 --- a/xsd-parser/src/pipeline/generator/meta.rs +++ b/xsd-parser/src/pipeline/generator/meta.rs @@ -18,7 +18,7 @@ pub struct MetaData<'types> { /// List of postfixed to add to the name of the generated types. /// /// This corresponds to the variants of [`IdentType`](crate::models::IdentType). - pub postfixes: [String; 10], + pub postfixes: [String; 11], /// Tells the generator how to deal with boxed elements. pub box_flags: BoxFlags, diff --git a/xsd-parser/src/pipeline/generator/mod.rs b/xsd-parser/src/pipeline/generator/mod.rs index 5f1454c0..3a3b4d39 100644 --- a/xsd-parser/src/pipeline/generator/mod.rs +++ b/xsd-parser/src/pipeline/generator/mod.rs @@ -103,7 +103,8 @@ impl<'types> Generator<'types> { String::new(), // BuildIn = 6 String::new(), // Enumeration = 7 String::from("NotNil"), // NillableContent = 8 - String::from("Dyn"), // DynamicElement = 9 + String::from("Dyn"), // SubstitutionElement = 9 + String::from("Dyn"), // DynamicVariant = 10 ], box_flags: BoxFlags::AUTO, typedef_mode: TypedefMode::Auto, @@ -118,7 +119,7 @@ impl<'types> Generator<'types> { let state = State { cache: BTreeMap::new(), pending: VecDeque::new(), - trait_infos: None, + trait_infos: TraitInfos::empty(), loop_detection: LoopDetection::default(), }; @@ -443,6 +444,8 @@ impl<'types> State<'types> { Entry::Vacant(e) => { let id = self.loop_detection.next_id(e.key().clone()); + self.trait_infos.update(meta.types, e.key()); + Self::create_type_ref(id, &*meta.naming, &mut self.pending, e, meta, ident) } } diff --git a/xsd-parser/src/pipeline/generator/state.rs b/xsd-parser/src/pipeline/generator/state.rs index 9bcb2ad0..3699e0ab 100644 --- a/xsd-parser/src/pipeline/generator/state.rs +++ b/xsd-parser/src/pipeline/generator/state.rs @@ -3,9 +3,10 @@ use std::ops::Deref; use bit_set::BitSet; +use crate::models::meta::DeriveRelationship; use crate::models::{ data::PathData, - meta::{DynamicMeta, MetaType, MetaTypeVariant, MetaTypes}, + meta::{MetaType, MetaTypeVariant, MetaTypes}, TypeIdent, }; @@ -15,7 +16,7 @@ use crate::models::{ pub(super) struct State<'types> { pub cache: BTreeMap, pub pending: VecDeque>, - pub trait_infos: Option, + pub trait_infos: TraitInfos, pub loop_detection: LoopDetection, } @@ -61,67 +62,38 @@ pub(super) struct TraitInfos(BTreeMap); impl TraitInfos { #[must_use] - pub(super) fn new(types: &MetaTypes) -> Self { - let mut ret = Self(BTreeMap::new()); - - for (base_ident, ty) in types.items.iter() { - let MetaTypeVariant::Dynamic(ai) = &ty.variant else { - continue; - }; + pub(super) fn empty() -> Self { + Self(BTreeMap::new()) + } - for meta in &ai.derived_types { - ret.0 - .entry(meta.type_.clone()) - .or_default() - .traits_all - .insert(base_ident.clone()); - - #[allow(clippy::single_match)] - match types.get_variant(&meta.type_) { - Some(MetaTypeVariant::Dynamic(DynamicMeta { - type_: Some(type_ident), - .. - })) => { - ret.0 - .entry(type_ident.clone()) - .or_default() - .traits_all - .insert(base_ident.clone()); - } - _ => (), - } - } + pub(super) fn update(&mut self, types: &MetaTypes, ident: &TypeIdent) { + if let Some(base_type) = types.items.get(ident) { + self.update_impl(types, ident, base_type); } + } - for ident in ret.0.keys().cloned().collect::>() { - let mut traits_second_level = BTreeSet::new(); + fn update_impl(&mut self, types: &MetaTypes, base_ident: &TypeIdent, base_ty: &MetaType) { + let MetaTypeVariant::Dynamic(meta) = &base_ty.variant else { + return; + }; - ret.collect_traits(&ident, 0, &mut traits_second_level); + for meta in meta.derived_types.values() { + let info = self.0.entry(meta.type_.clone()).or_default(); - let info = ret.0.get_mut(&ident).unwrap(); - info.traits_direct = info - .traits_all - .difference(&traits_second_level) - .cloned() - .collect(); - } + info.traits_to_impl.insert(base_ident.clone()); - ret - } + let Some(derived_ty) = types.items.get(&meta.type_) else { + continue; + }; - fn collect_traits( - &self, - ident: &TypeIdent, - depth: usize, - traits_second_level: &mut BTreeSet, - ) { - if depth > 1 { - traits_second_level.insert(ident.clone()); - } + let MetaTypeVariant::Dynamic(_) = &derived_ty.variant else { + continue; + }; - if let Some(info) = self.0.get(ident) { - for trait_ in &info.traits_all { - self.collect_traits(trait_, depth + 1, traits_second_level); + if base_ident.type_ == meta.type_.type_ + && meta.relationship == DeriveRelationship::DirectChild + { + info.traits_to_derive.insert(base_ident.clone()); } } } @@ -139,8 +111,8 @@ impl Deref for TraitInfos { #[derive(Default, Debug)] pub(super) struct TraitInfo { - pub traits_all: BTreeSet, - pub traits_direct: BTreeSet, + pub traits_to_impl: BTreeSet, + pub traits_to_derive: BTreeSet, } /* LoopDetection */ diff --git a/xsd-parser/src/pipeline/interpreter/error.rs b/xsd-parser/src/pipeline/interpreter/error.rs index 19b968ff..e7bf9efc 100644 --- a/xsd-parser/src/pipeline/interpreter/error.rs +++ b/xsd-parser/src/pipeline/interpreter/error.rs @@ -42,7 +42,7 @@ pub enum Error { /// Expected dynamic element. /// /// Expected the specified element to be dynamic because it is referenced - /// as substitution group. + /// as substitution group or within a dynamic type. #[error("Expected dynamic element: {0}!")] ExpectedDynamicElement(TypeIdent), diff --git a/xsd-parser/src/pipeline/interpreter/mod.rs b/xsd-parser/src/pipeline/interpreter/mod.rs index eb0606f7..f1e2a655 100644 --- a/xsd-parser/src/pipeline/interpreter/mod.rs +++ b/xsd-parser/src/pipeline/interpreter/mod.rs @@ -92,6 +92,26 @@ impl<'a> Interpreter<'a> { Ok(self) } + /// Add a type identifier to the list of types that should be interpreted as + /// dynamic types. + /// + /// While some languages (like C++, C# or Java) have good support for dynamic + /// types and type inheritance in general, others (like C or Rust) don't. To + /// be able to generate code for this languages as well, dynamic types are + /// interpreted slightly differently. Since the XML schema does not provide + /// any information about which types are dynamic and which are not (except + /// if it is explicitly marked as abstract), the user have to provide this + /// information manually. + #[instrument(level = "trace", skip(self))] + pub fn with_dynamic_type(mut self, ident: I) -> Self + where + I: Into + Debug, + { + self.state.add_dynamic_type(ident); + + self + } + /// Add a simple type definition to the resulting [`MetaTypes`] structure using /// `ident` as identifier for the new type and `type_` as target type for the /// type definition. diff --git a/xsd-parser/src/pipeline/interpreter/state.rs b/xsd-parser/src/pipeline/interpreter/state.rs index fb2f6487..52814d5e 100644 --- a/xsd-parser/src/pipeline/interpreter/state.rs +++ b/xsd-parser/src/pipeline/interpreter/state.rs @@ -1,12 +1,14 @@ mod crate_ident_cache; mod crate_node_cache; mod create_node_list; +mod fix_derived_types; mod fix_element_naming_conflicts; mod generate_types; mod prepare_modules; mod prepare_schemas; use std::collections::btree_map::{BTreeMap, Entry}; +use std::collections::HashSet; use std::str::from_utf8; use indexmap::IndexMap; @@ -30,6 +32,9 @@ pub(super) struct State<'a> { /// The types that are generated by the interpreter. types: MetaTypes, + /// List of types to be interpreted as dynamic type. + dynamic_types: HashSet, + /// Cache for the nodes that are defined in the schemas. This is used to quickly access the nodes by their identifier. node_cache: NodeCache<'a>, @@ -84,6 +89,7 @@ impl<'a> State<'a> { let mut ret = Self { schemas, types: MetaTypes::default(), + dynamic_types: HashSet::default(), node_cache: NodeCache::default(), ident_cache: IdentCache::default(), }; @@ -100,6 +106,7 @@ impl<'a> State<'a> { let nodes = self.create_node_list()?; self.generate_types(nodes)?; self.fix_element_naming_conflicts(); + self.fix_derived_types(); Ok((self.types, self.ident_cache)) } @@ -143,6 +150,14 @@ impl<'a> State<'a> { Ok(()) } + pub(super) fn add_dynamic_type(&mut self, ident: I) + where + I: Into, + { + let ident = ident.into(); + self.dynamic_types.insert(ident); + } + pub(super) fn resolve_type_ident(&self, ident: TypeIdent) -> Result { self.ident_cache.resolve(ident) } @@ -181,7 +196,7 @@ impl<'a> State<'a> { *ty = self.resolve_type_ident_allow_unknown(ty.clone())?; } - for meta in &mut x.derived_types { + for meta in x.derived_types.values_mut() { meta.type_ = self.resolve_type_ident_allow_unknown(meta.type_.clone())?; } } diff --git a/xsd-parser/src/pipeline/interpreter/state/fix_derived_types.rs b/xsd-parser/src/pipeline/interpreter/state/fix_derived_types.rs new file mode 100644 index 00000000..468a6e6e --- /dev/null +++ b/xsd-parser/src/pipeline/interpreter/state/fix_derived_types.rs @@ -0,0 +1,48 @@ +use crate::{ + config::MetaType, + models::meta::{BuildInMeta, MetaTypeVariant}, +}; + +use super::State; + +impl State<'_> { + /// Fixes the derived types by resolving their base types. This is necessary + /// because the derived types may reference other types that have not been + /// fully resolved during the initial parsing phase. For example the variant + /// of an element may change from `Referece` to `Dynamic` after a type references + /// it as substitution group. + pub(super) fn fix_derived_types(&mut self) { + for ident in self.types.items.keys().cloned().collect::>() { + let placeholder = MetaType::new(MetaTypeVariant::BuildIn(BuildInMeta::String)); + let mut ty = self.types.items.insert(ident.clone(), placeholder).unwrap(); + + let MetaTypeVariant::Dynamic(meta) = &mut ty.variant else { + self.types.items.insert(ident.clone(), ty); + + continue; + }; + + for (key, derived) in &mut meta.derived_types { + loop { + let Some((ident, derived_ty)) = self.types.get_resolved(&derived.type_) else { + break; + }; + if key.type_ != ident.type_ { + derived.type_ = ident.clone(); + break; + } + let MetaTypeVariant::Dynamic(derived_meta) = &derived_ty.variant else { + break; + }; + let Some(base) = &derived_meta.type_ else { + break; + }; + + derived.type_ = base.clone(); + } + } + + self.types.items.insert(ident, ty); + } + } +} diff --git a/xsd-parser/src/pipeline/interpreter/state/fix_element_naming_conflicts.rs b/xsd-parser/src/pipeline/interpreter/state/fix_element_naming_conflicts.rs index 72a47055..c4055d4d 100644 --- a/xsd-parser/src/pipeline/interpreter/state/fix_element_naming_conflicts.rs +++ b/xsd-parser/src/pipeline/interpreter/state/fix_element_naming_conflicts.rs @@ -106,7 +106,7 @@ impl IdentSlice for DynamicMeta { } fn get_ident(&self, index: usize) -> (NamespaceId, &str) { - let type_ = &self.derived_types[index].type_; + let type_ = self.derived_types.as_slice().get_index(index).unwrap().0; (type_.ns, type_.name.as_str()) } diff --git a/xsd-parser/src/pipeline/interpreter/state/generate_types.rs b/xsd-parser/src/pipeline/interpreter/state/generate_types.rs index b11bb4e1..2b9ad5d0 100644 --- a/xsd-parser/src/pipeline/interpreter/state/generate_types.rs +++ b/xsd-parser/src/pipeline/interpreter/state/generate_types.rs @@ -30,6 +30,7 @@ impl State<'_> { let mut processor = TypeProcessor::new( self.schemas, &mut self.types, + &self.dynamic_types, &self.node_cache, &mut self.ident_cache, ); diff --git a/xsd-parser/src/pipeline/interpreter/state/generate_types/type_processor.rs b/xsd-parser/src/pipeline/interpreter/state/generate_types/type_processor.rs index 93806407..e3d84e38 100644 --- a/xsd-parser/src/pipeline/interpreter/state/generate_types/type_processor.rs +++ b/xsd-parser/src/pipeline/interpreter/state/generate_types/type_processor.rs @@ -1,4 +1,4 @@ -use std::collections::{HashMap, VecDeque}; +use std::collections::{HashMap, HashSet, VecDeque}; use std::{borrow::Cow, collections::btree_map::Entry}; use tracing::instrument; @@ -19,6 +19,7 @@ pub(super) struct TypeProcessor<'state, 'schema> { schemas: &'schema Schemas, types: &'state mut MetaTypes, + dynamic_types: &'state HashSet, node_cache: &'state NodeCache<'schema>, ident_cache: &'state mut IdentCache, } @@ -27,6 +28,7 @@ impl<'state, 'schema> TypeProcessor<'state, 'schema> { pub(super) fn new( schemas: &'schema Schemas, types: &'state mut MetaTypes, + dynamic_types: &'state HashSet, node_cache: &'state NodeCache<'schema>, ident_cache: &'state mut IdentCache, ) -> Self { @@ -36,6 +38,7 @@ impl<'state, 'schema> TypeProcessor<'state, 'schema> { schemas, types, + dynamic_types, node_cache, ident_cache, } @@ -121,18 +124,32 @@ impl<'state, 'schema> TypeProcessor<'state, 'schema> { &mut self, ident: &TypeIdent, ) -> Option<&MetaTypeVariant> { - match self.get_variant(ident) { - MetaTypeVariant::Enumeration(_) - | MetaTypeVariant::BuildIn(_) - | MetaTypeVariant::Custom(_) - | MetaTypeVariant::Union(_) - | MetaTypeVariant::Reference(_) - | MetaTypeVariant::SimpleType(_) => None, - ty @ (MetaTypeVariant::ComplexType(_) - | MetaTypeVariant::All(_) - | MetaTypeVariant::Choice(_) - | MetaTypeVariant::Sequence(_) - | MetaTypeVariant::Dynamic(_)) => Some(ty), + let mut ident = Cow::Borrowed(ident); + + loop { + match self.types.get_variant(&ident) { + None => { + // Hard dependencies should be available here + panic!("Unable to get type for {ident}"); + } + Some( + MetaTypeVariant::Enumeration(_) + | MetaTypeVariant::BuildIn(_) + | MetaTypeVariant::Custom(_) + | MetaTypeVariant::Union(_) + | MetaTypeVariant::Reference(_) + | MetaTypeVariant::SimpleType(_), + ) => return None, + Some( + ty @ (MetaTypeVariant::ComplexType(_) + | MetaTypeVariant::All(_) + | MetaTypeVariant::Choice(_) + | MetaTypeVariant::Sequence(_)), + ) => return Some(ty), + Some(MetaTypeVariant::Dynamic(dt)) => { + ident = Cow::Owned(dt.type_.clone().expect("Dynamic type to have base type")); + } + } } } @@ -244,6 +261,10 @@ impl<'state, 'schema> TypeProcessor<'state, 'schema> { .unwrap_or_default() } + pub(super) fn is_dynamic(&self, ident: &TypeIdent) -> bool { + self.dynamic_types.contains(ident) + } + pub(super) fn group_cache(&self) -> Option<&HashMap> { self.stack.iter().rev().find_map(|x| { if let StackEntry::Type { group_cache, .. } = x { diff --git a/xsd-parser/src/pipeline/interpreter/state/generate_types/update.rs b/xsd-parser/src/pipeline/interpreter/state/generate_types/update.rs index 5a0c08be..8bc182e9 100644 --- a/xsd-parser/src/pipeline/interpreter/state/generate_types/update.rs +++ b/xsd-parser/src/pipeline/interpreter/state/generate_types/update.rs @@ -1,4 +1,4 @@ -use crate::models::meta::{AttributeMeta, ElementMeta}; +use crate::models::meta::{AttributeMeta, ElementMeta, ElementMetaFlags}; use crate::models::schema::xs::{AttributeType, ElementType, GroupType}; pub(super) trait Update { @@ -36,7 +36,10 @@ impl Update for ElementMeta { fn update(&mut self, other: &ElementType) { self.min_occurs = other.min_occurs; self.max_occurs = other.max_occurs; - self.nillable.update(&other.nillable); + + if let Some(nillable) = &other.nillable { + self.flags.set(ElementMetaFlags::NILLABLE, *nillable); + } } } diff --git a/xsd-parser/src/pipeline/interpreter/state/generate_types/variant_processor.rs b/xsd-parser/src/pipeline/interpreter/state/generate_types/variant_processor.rs index c19841c5..8ac81284 100644 --- a/xsd-parser/src/pipeline/interpreter/state/generate_types/variant_processor.rs +++ b/xsd-parser/src/pipeline/interpreter/state/generate_types/variant_processor.rs @@ -277,34 +277,14 @@ impl<'a, 'state, 'schema> VariantProcessor<'a, 'state, 'schema> { if let Some(substitution_group) = &ty.substitution_group { let mut ident = self.owner.current_ident().clone(); - ident.type_ = IdentType::DynamicElement; + ident.type_ = IdentType::SubstitutionElement; let type_ = self.finish_mut()?; self.owner.add_type(ident.clone(), type_, false)?; init_any!(self, Reference, ReferenceMeta::new(ident), true); - self.walk_substitution_groups(substitution_group, |processor, base_ident| { - let ident = processor.owner.current_ident().clone(); - let base_ty = processor - .owner - .get_substitution_group_element_mut(base_ident); - - if let MetaTypeVariant::Reference(ti) = &mut base_ty.variant { - base_ty.variant = MetaTypeVariant::Dynamic(DynamicMeta { - type_: Some(ti.type_.clone()), - derived_types: vec![DerivedTypeMeta::new(ti.type_.clone())], - }); - } - - let MetaTypeVariant::Dynamic(ai) = &mut base_ty.variant else { - return Err(Error::ExpectedDynamicElement(base_ident.clone())); - }; - - ai.derived_types.push(DerivedTypeMeta::new(ident)); - - Ok(()) - })?; + self.walk_substitution_groups(substitution_group, prepare_substitution_group)?; } if ty.abstract_ { @@ -316,6 +296,7 @@ impl<'a, 'state, 'schema> VariantProcessor<'a, 'state, 'schema> { let ai = init_any!(self, Dynamic); ai.type_ = type_; + ai.is_abstract = true; } Ok(()) @@ -374,12 +355,7 @@ impl<'a, 'state, 'schema> VariantProcessor<'a, 'state, 'schema> { for c in &ty.content { ret = match c { C::OpenContent(_) | C::Assert(_) => Ok(()), - C::ComplexContent(x) => { - let ci = get_or_init_any!(self, ComplexType); - ci.is_dynamic = ty.abstract_; - - self.apply_complex_content(x) - } + C::ComplexContent(x) => self.apply_complex_content(x), C::SimpleContent(x) => self.apply_simple_content(x), C::All(x) => self.apply_all(x, x.min_occurs, x.max_occurs), C::Choice(x) => self.apply_choice(x, x.min_occurs, x.max_occurs), @@ -403,6 +379,52 @@ impl<'a, 'state, 'schema> VariantProcessor<'a, 'state, 'schema> { self.owner.pop_stack(); } + let ci = get_or_init_any!(self, ComplexType); + let mut base = ci.base.clone().into_ident(); + + let current_ident = self.owner.current_ident().clone(); + + let mut ident = current_ident.clone(); + let is_dynamic = ty.abstract_ || self.owner.is_dynamic(&ident); + + if is_dynamic { + ident.type_ = IdentType::DynamicVariant; + + let type_ = self.finish_mut()?; + self.owner.add_type(ident.clone(), type_, false)?; + + let dm = init_any!(self, Dynamic, DynamicMeta::default(), true); + dm.is_abstract = ty.abstract_; + dm.type_ = Some(ident.clone()); + + if !dm.is_abstract { + dm.derived_types + .entry(current_ident.clone()) + .or_insert_with(|| DerivedTypeMeta::new_concrete(ident.clone())); + } + } + + let mut is_direct = true; + while let Some(base_ident) = base.take() { + let base_ty = self.owner.get_type_mut(&base_ident); + + match &mut base_ty.variant { + MetaTypeVariant::Dynamic(dm) => { + dm.derived_types + .entry(current_ident.clone()) + .or_insert_with(|| DerivedTypeMeta::new_child(ident.clone(), is_direct)); + + base.clone_from(&dm.type_); + } + MetaTypeVariant::ComplexType(ci) => { + base = ci.base.clone().into_ident(); + } + _ => (), + } + + is_direct = false; + } + ret } @@ -1315,26 +1337,27 @@ impl<'a, 'state, 'schema> VariantProcessor<'a, 'state, 'schema> { #[instrument(err, level = "trace", skip(self, f))] fn walk_substitution_groups(&mut self, groups: &QNameList, mut f: F) -> Result<(), Error> where - F: FnMut(&mut Self, &TypeIdent) -> Result<(), Error>, + F: FnMut(&mut Self, &TypeIdent, usize) -> Result<(), Error>, { fn inner<'x, 'y, 'z, F>( processor: &mut VariantProcessor<'x, 'y, 'z>, groups: &QNameList, + depth: usize, f: &mut F, ) -> Result<(), Error> where - F: FnMut(&mut VariantProcessor<'x, 'y, 'z>, &TypeIdent) -> Result<(), Error>, + F: FnMut(&mut VariantProcessor<'x, 'y, 'z>, &TypeIdent, usize) -> Result<(), Error>, { for head in &groups.0 { let ident = processor .owner .resolve_type_ident(head, IdentType::Element)?; - f(processor, &ident)?; + f(processor, &ident, depth)?; processor.with_element_node(ident, |processor, element, _ident| { if let Some(groups) = &element.substitution_group { - inner(processor, groups, f)?; + inner(processor, groups, depth + 1, f)?; } Ok(()) @@ -1344,7 +1367,7 @@ impl<'a, 'state, 'schema> VariantProcessor<'a, 'state, 'schema> { Ok(()) } - inner(self, groups, &mut f) + inner(self, groups, 0, &mut f) } fn simple_content_builder(&mut self, f: F) -> Result<(), Error> @@ -1699,3 +1722,53 @@ impl ElementsMeta { } } } + +/* Helper */ + +fn prepare_substitution_group( + processor: &mut VariantProcessor<'_, '_, '_>, + base_ident: &TypeIdent, + depth: usize, +) -> Result<(), Error> { + let current_ident = processor.owner.current_ident().clone(); + let base_ty = processor + .owner + .get_substitution_group_element_mut(base_ident); + let mut helper_type = None; + + if let MetaTypeVariant::Reference(ti) = &mut base_ty.variant { + if !ti.is_simple() { + let mut helper_ident = base_ident.clone(); + helper_ident.type_ = IdentType::SubstitutionElement; + + let type_ = MetaType::from(ti.clone()); + ti.type_ = helper_ident.clone(); + + helper_type = Some((helper_ident, type_)); + } + + let mut meta = DynamicMeta { + type_: Some(ti.type_.clone()), + ..Default::default() + }; + meta.derived_types + .entry(base_ident.clone()) + .or_insert_with(|| DerivedTypeMeta::new_concrete(ti.type_.clone())); + + base_ty.variant = MetaTypeVariant::Dynamic(meta); + } + + let MetaTypeVariant::Dynamic(meta) = &mut base_ty.variant else { + return Err(Error::ExpectedDynamicElement(base_ident.clone())); + }; + + meta.derived_types + .entry(current_ident.clone()) + .or_insert_with(|| DerivedTypeMeta::new_child(current_ident, depth == 0)); + + if let Some((ident, type_)) = helper_type { + processor.owner.add_type(ident, type_, false)?; + } + + Ok(()) +} diff --git a/xsd-parser/src/pipeline/optimizer/dynamic_to_choice.rs b/xsd-parser/src/pipeline/optimizer/dynamic_to_choice.rs index 904caa7f..91300780 100644 --- a/xsd-parser/src/pipeline/optimizer/dynamic_to_choice.rs +++ b/xsd-parser/src/pipeline/optimizer/dynamic_to_choice.rs @@ -1,10 +1,18 @@ +use std::collections::btree_map::Entry; + +use bitflags::Flags; + use crate::models::{ - meta::{ComplexMeta, ElementMeta, ElementMode, GroupMeta, MetaType, MetaTypeVariant}, - TypeIdent, + meta::{ + ComplexMeta, DeriveRelationship, DynamicMeta, ElementMeta, ElementMetaFlags, ElementMode, + GroupMeta, MetaType, MetaTypeVariant, + }, + schema::xs::FormChoiceType, + IdentType, TypeIdent, }; use crate::traits::{NameBuilderExt as _, VecHelper}; -use super::Optimizer; +use super::{Error, Optimizer}; impl Optimizer { /// This will use a enum that contains all known variants of the dynamic @@ -26,10 +34,19 @@ impl Optimizer { /// ```rust #[doc = include_str!("../../../tests/optimizer/expected1/convert_dynamic_to_choice.rs")] /// ``` - pub fn convert_dynamic_to_choice(mut self) -> Self { - use std::collections::btree_map::Entry; + pub fn convert_dynamic_to_choice(mut self, ident: TypeIdent) -> Result { + tracing::debug!("convert_dynamic_to_choice(ident={ident:?})"); + + self.convert_dynamic_to_choice_impl(ident)?; + + Ok(self) + } - tracing::debug!("convert_dynamic_to_choice"); + /// This will convert all dynamic types to choices. + /// + /// For details see [`convert_dynamic_to_choice`](Self::convert_dynamic_to_choice). + pub fn convert_dynamics_to_choices(mut self) -> Self { + tracing::debug!("convert_dynamics_to_choices"); let idents = self .types @@ -46,59 +63,77 @@ impl Optimizer { .collect::>(); for ident in idents { - let content_name = self.types.name_builder().shared_name("Content").finish(); - let content_ident = TypeIdent::new(content_name).with_ns(ident.ns); - - let mut si = GroupMeta::default(); - let type_ = self.types.items.get(&ident).unwrap(); - self.add_elements(&mut si, type_); - - let type_ = self.types.items.get_mut(&ident).unwrap(); - type_.variant = MetaTypeVariant::ComplexType(ComplexMeta { - content: Some(content_ident.clone()), - is_dynamic: true, - ..Default::default() - }); - - match self.types.items.entry(content_ident) { - Entry::Vacant(e) => { - e.insert(MetaType::new(if si.elements.is_empty() { - MetaTypeVariant::Sequence(si) - } else { - MetaTypeVariant::Choice(si) - })); - } - Entry::Occupied(_) => crate::unreachable!(), - } + let _ = self.convert_dynamic_to_choice_impl(ident); } self } - fn add_elements(&self, group: &mut GroupMeta, ty: &MetaType) { - let form = ty.form(); - let MetaTypeVariant::Dynamic(x) = &ty.variant else { - crate::unreachable!(); + fn convert_dynamic_to_choice_impl(&mut self, ident: TypeIdent) -> Result<(), Error> { + let Some(ty) = self.types.items.get(&ident) else { + return Err(Error::UnknownType(ident)); + }; + + let MetaTypeVariant::Dynamic(dm) = &ty.variant else { + return Err(Error::ExpectedDynamicType(ident)); }; - for meta in &x.derived_types { - let derived_ty = self.types.get_resolved_type(&meta.type_).unwrap(); - if let MetaTypeVariant::Dynamic(_) = &derived_ty.variant { - self.add_elements(group, derived_ty); - } else { - group - .elements - .find_or_insert(meta.type_.to_property_ident(), |ident| { - let mut el = - ElementMeta::new(ident, meta.type_.clone(), ElementMode::Element, form); - - if let Some(display_name) = &meta.display_name { - el.display_name = Some(display_name.clone()); - } - - el - }); + let content_name = self.types.name_builder().shared_name("Content").finish(); + let content_ident = TypeIdent::new(content_name).with_ns(ident.ns); + + let mut si = GroupMeta::default(); + let ty = self.types.items.get(&ident).unwrap(); + add_elements(&mut si, ty.form(), dm); + + let ty = self.types.items.get_mut(&ident).unwrap(); + ty.variant = MetaTypeVariant::ComplexType(ComplexMeta { + content: Some(content_ident.clone()), + is_dynamic: true, + ..Default::default() + }); + + match self.types.items.entry(content_ident) { + Entry::Vacant(e) => { + e.insert(MetaType::new(if si.elements.is_empty() { + MetaTypeVariant::Sequence(si) + } else { + MetaTypeVariant::Choice(si) + })); + } + Entry::Occupied(_) => crate::unreachable!(), + } + + Ok(()) + } +} + +fn add_elements(group: &mut GroupMeta, form: FormChoiceType, meta: &DynamicMeta) { + for (key, meta) in &meta.derived_types { + let el = group + .elements + .find_or_insert(key.to_property_ident(), |ident| { + let mut el = + ElementMeta::new(ident, meta.type_.clone(), ElementMode::Element, form); + + el.flags.clear(); + + if let Some(display_name) = &meta.display_name { + el.display_name = Some(display_name.clone()); + } + + el + }); + + match key.type_ { + IdentType::Type => { + el.flags.insert(ElementMetaFlags::IDENTIFY_BY_TYPE); + + if meta.relationship == DeriveRelationship::ConcreteType { + el.flags.insert(ElementMetaFlags::DEFAULT_ELEMENT); + } } + IdentType::Element => el.flags.insert(ElementMetaFlags::IDENTIFY_BY_TAG), + _ => (), } } } diff --git a/xsd-parser/src/pipeline/optimizer/merge_dynamic_types.rs b/xsd-parser/src/pipeline/optimizer/merge_dynamic_types.rs new file mode 100644 index 00000000..33cf9725 --- /dev/null +++ b/xsd-parser/src/pipeline/optimizer/merge_dynamic_types.rs @@ -0,0 +1,128 @@ +use indexmap::IndexMap; + +use crate::models::{ + meta::{DerivedTypeMeta, MetaTypeVariant}, + TypeIdent, +}; + +use super::{Error, Optimizer}; + +impl Optimizer { + /// This will merge the derived types of a dynamic type into the base type if + /// the base type is also a dynamic type representing the same element. This + /// is useful if the schema uses dynamic types in combination with substitution + /// groups. Both of them cover more or less the same dynamic types, but used + /// different `Box`es to store them. After you've applied this optimization + /// the instances of the substitution group and the dynamic type will be stored + /// in the same `Box`. + /// + /// This optimization need to be used with care, because it can lead to a loss + /// of information. If you serialize a XML document that was deserialized with + /// this optimization before, the serializer can not determine if an element + /// needs to be emitted as a substitution group or as a dynamic type anymore. + /// + /// # Errors + /// + /// Returns an error if the passed `ident` could not be found or the referenced + /// type is not dynamic type. + /// + /// # Examples + /// + /// Consider the following XML schema. + /// ```xml + #[doc = include_str!("../../../tests/optimizer/merge_dynamic_types.xsd")] + /// ``` + /// + /// Without this optimization this will result in the following code: + /// ```rust + #[doc = include_str!("../../../tests/optimizer/expected0/merge_dynamic_types.rs")] + /// ``` + /// + /// With this optimization the following code is generated: + /// ```rust + #[doc = include_str!("../../../tests/optimizer/expected1/merge_dynamic_types.rs")] + /// ``` + pub fn merge_dynamic_type(mut self, ident: TypeIdent) -> Result { + tracing::debug!("merge_dynamic_types(ident={ident:?})"); + + self.merge_dynamic_types_impl(ident)?; + + Ok(self) + } + + /// This will flatten all complex types. + /// + /// For details see [`merge_dynamic_type`](Self::merge_dynamic_type). + pub fn merge_dynamic_types(mut self) -> Self { + tracing::debug!("merge_dynamic_types"); + + let idents = self + .types + .items + .iter() + .filter_map(|(ident, type_)| { + if matches!(&type_.variant, MetaTypeVariant::Dynamic(_)) { + Some(ident) + } else { + None + } + }) + .cloned() + .collect::>(); + + for ident in idents { + let _ = self.merge_dynamic_types_impl(ident); + } + + self + } + + fn merge_dynamic_types_impl(&mut self, ident: TypeIdent) -> Result<(), Error> { + tracing::debug!("merge_dynamic_types_impl(ident={ident:?})"); + + let Some(ty) = self.types.items.get(&ident) else { + return Err(Error::UnknownType(ident)); + }; + + let MetaTypeVariant::Dynamic(dm) = &ty.variant else { + return Err(Error::ExpectedDynamicType(ident)); + }; + + let Some(base_ident) = dm + .type_ + .as_ref() + .and_then(|ident| self.types.get_resolved_ident(ident)) + else { + return Ok(()); + }; + + let mut derived_types = IndexMap::new(); + self.add_derived_types(&mut derived_types, base_ident, &dm.derived_types); + + if let Some(MetaTypeVariant::Dynamic(dm)) = self.types.get_variant_mut(&ident) { + dm.derived_types = derived_types; + } + + Ok(()) + } + + fn add_derived_types( + &self, + new: &mut IndexMap, + base_ident: &TypeIdent, + old: &IndexMap, + ) { + for (key, old) in old { + if let Some((ident, ty)) = self.types.get_resolved(&old.type_) { + if base_ident == ident { + if let MetaTypeVariant::Dynamic(dm) = &ty.variant { + self.add_derived_types(new, base_ident, &dm.derived_types); + continue; + } + } + } + + new.entry(key.clone()).or_insert_with(|| old.clone()); + } + } +} diff --git a/xsd-parser/src/pipeline/optimizer/mod.rs b/xsd-parser/src/pipeline/optimizer/mod.rs index 7cd877cc..cca5ad3a 100644 --- a/xsd-parser/src/pipeline/optimizer/mod.rs +++ b/xsd-parser/src/pipeline/optimizer/mod.rs @@ -19,6 +19,7 @@ mod empty_unions; mod flatten_complex_type; mod flatten_unions; mod merge_choice_cardinality; +mod merge_dynamic_types; mod merge_enum_unions; mod misc; mod remove_duplicates; @@ -82,6 +83,12 @@ pub enum Error { #[error("The type is not a complex type: {0}!")] ExpectedComplexType(TypeIdent), + /// The type is not a dynamic type. + /// + /// Is raised if a type is expected to be a dynamic type, but it is not. + #[error("The type is not a dynamic type: {0}!")] + ExpectedDynamicType(TypeIdent), + /// The complex type is missing a content type. /// /// Is raised if the content type of a complex type could not be resolved. diff --git a/xsd-parser/src/pipeline/optimizer/resolve_typedefs.rs b/xsd-parser/src/pipeline/optimizer/resolve_typedefs.rs index 00f19b2e..ef538605 100644 --- a/xsd-parser/src/pipeline/optimizer/resolve_typedefs.rs +++ b/xsd-parser/src/pipeline/optimizer/resolve_typedefs.rs @@ -60,7 +60,7 @@ impl Optimizer { MetaTypeVariant::Dynamic(x) => { x.type_ = x.type_.as_ref().map(|x| typedefs.resolve(x)).cloned(); - for meta in &mut x.derived_types { + for meta in x.derived_types.values_mut() { meta.type_ = typedefs.resolve(&meta.type_).clone(); } } @@ -99,18 +99,6 @@ impl Optimizer { } } - for type_ in self.types.items.values_mut() { - let MetaTypeVariant::Dynamic(di) = &mut type_.variant else { - continue; - }; - - for meta in &mut di.derived_types { - if let Some(new_type) = replaced_references.get(&meta.type_) { - meta.type_ = new_type.clone(); - } - } - } - self } } diff --git a/xsd-parser/src/pipeline/renderer/steps/quick_xml/deserialize.rs b/xsd-parser/src/pipeline/renderer/steps/quick_xml/deserialize.rs index 88dc2b92..2068f67b 100644 --- a/xsd-parser/src/pipeline/renderer/steps/quick_xml/deserialize.rs +++ b/xsd-parser/src/pipeline/renderer/steps/quick_xml/deserialize.rs @@ -3,7 +3,7 @@ use std::collections::{hash_map::Entry, HashMap, HashSet}; use std::ops::Not; -use proc_macro2::{Ident as Ident2, TokenStream}; +use proc_macro2::{Ident as Ident2, Literal, TokenStream}; use quote::{format_ident, quote}; use crate::config::TypedefMode; @@ -15,11 +15,11 @@ use crate::models::{ ReferenceData, SimpleData, StructMode, UnionData, UnionTypeVariant, }, meta::{ - ComplexMeta, ElementMeta, ElementMetaVariant, ElementMode, MetaTypeVariant, MetaTypes, - WhiteSpace, + ComplexMeta, DeriveRelationship, ElementMeta, ElementMetaFlags, ElementMetaVariant, + ElementMode, MetaTypeVariant, MetaTypes, WhiteSpace, }, schema::{xs::Use, MaxOccurs}, - TypeIdent, + IdentType, TypeIdent, }; use super::super::super::{ @@ -209,16 +209,21 @@ impl DynamicData<'_> { .. } = self; - let variants = derived_types.iter().map(|x| { + let mut duplicates = HashSet::new(); + let variants = derived_types.iter().filter_map(|x| { + if !duplicates.insert((&x.key.ns, &x.key.name, &x.meta.type_)) { + return None; + } + let target_type = ctx.resolve_type_for_deserialize_module(&x.target_type); let variant_ident = &x.variant_ident; let with_deserializer = resolve_ident!(ctx, "::xsd_parser_types::quick_xml::WithDeserializer"); - quote! { + Some(quote! { #variant_ident(<#target_type as #with_deserializer>::Deserializer), - } + }) }); let code = quote! { @@ -231,6 +236,7 @@ impl DynamicData<'_> { ctx.quick_xml_deserialize().append(code); } + #[expect(clippy::too_many_lines)] fn render_deserializer_impls(&self, ctx: &mut Context<'_, '_>) { let Self { type_ident, @@ -268,30 +274,82 @@ impl DynamicData<'_> { boxed_deserializer_ident(config.boxed_deserializer, deserializer_ident); let deref_self = config.boxed_deserializer.then(|| quote!(*)); - let variants_init = derived_types + /* init */ + + let variants_init_type = derived_types .iter() - .map(|x| x.render_deserializer_init(ctx, type_ident, deserializer_ident)); - let variants_next = derived_types + .filter_map(|x| x.render_deserializer_init_type(ctx, type_ident, deserializer_ident)) + .collect::>(); + let variants_init_element = derived_types .iter() - .map(|x| x.render_deserializer_next(ctx, type_ident, deserializer_ident)); - let variants_finish = derived_types.iter().map(|x| { + .filter_map(|x| x.render_deserializer_init_element(ctx, type_ident, deserializer_ident)) + .collect::>(); + let variants_init_type = variants_init_type.is_empty().not().then(|| { + let qname = resolve_quick_xml_ident!(ctx, "::xsd_parser_types::quick_xml::QName"); + let get_qname = quote!(#qname(&type_name)); + let get_type_name = quote!(type_name); + let matcher = make_type_element_matcher(ctx, &get_qname, &get_type_name); + let body = if let Some(default) = self.get_default_type_name(ctx) { + quote! { + let type_name = helper.get_dynamic_type_from_attrib(&event)?.unwrap_or(#default).into_owned(); + + #( #variants_init_type )* + } + } else { + quote! { + if let Some(type_name) = helper.get_dynamic_type_from_attrib(&event)? { + let type_name = type_name.into_owned(); + + #( #variants_init_type )* + } + } + }; + + quote! { + if #matcher { + #body + } + } + }); + + /* next */ + + let mut duplicates = HashSet::new(); + let variants_next = derived_types.iter().filter_map(|x| { + if !duplicates.insert((&x.key.ns, &x.key.name, &x.meta.type_)) { + return None; + } + + Some(x.render_deserializer_next(ctx, type_ident, deserializer_ident)) + }); + + /* finish */ + + let mut duplicates = HashSet::new(); + let variants_finish = derived_types.iter().filter_map(|x| { + if !duplicates.insert((&x.key.ns, &x.key.name, &x.meta.type_)) { + return None; + } + let variant_ident = &x.variant_ident; let box_ = resolve_build_in!(ctx, "::alloc::boxed::Box"); ctx.add_quick_xml_deserialize_usings(true, ["::xsd_parser_types::quick_xml::Deserializer"]); - quote! { + Some(quote! { #boxed_deserializer_ident::#variant_ident(x) => Ok(super::#type_ident(#box_::new(x.finish(helper)?))), - } + }) }); + /* compile code */ + let code = quote! { impl<'de> #deserializer<'de, super::#type_ident> for #deserializer_type { fn init( helper: &mut #deserialize_helper, event: #event<'de>, ) -> #deserializer_result<'de, super::#type_ident> { - let Some(type_name) = helper.get_dynamic_type_name(&event)? else { + let Some(type_name) = helper.get_dynamic_type_from_tag(&event) else { return Ok(#deserializer_output { artifact: #deserializer_artifact::None, event: #deserializer_event::None, @@ -300,7 +358,8 @@ impl DynamicData<'_> { }; let type_name = type_name.into_owned(); - #( #variants_init )* + #variants_init_type + #( #variants_init_element )* Ok(#deserializer_output { artifact: #deserializer_artifact::None, @@ -332,9 +391,52 @@ impl DynamicData<'_> { ctx.quick_xml_deserialize().append(code); } + + fn get_default_type_name(&self, ctx: &Context<'_, '_>) -> Option { + let default = self.derived_types.iter().find(|x| { + x.key.type_ == IdentType::Type + && x.meta.relationship == DeriveRelationship::ConcreteType + })?; + + let ident = &default.key; + let s_name = ident.name.to_string(); + let b_name = Literal::byte_string(s_name.as_bytes()); + + let cow = resolve_quick_xml_ident!(ctx, "::alloc::borrow::Cow"); + + Some(quote! { + #cow::Borrowed(#b_name) + }) + } } -impl DerivedType { +impl DerivedType<'_> { + fn render_deserializer_init_element( + &self, + ctx: &Context<'_, '_>, + type_ident: &Ident2, + deserializer_ident: &Ident2, + ) -> Option { + if self.key.type_ == IdentType::Element { + Some(self.render_deserializer_init(ctx, type_ident, deserializer_ident)) + } else { + None + } + } + + fn render_deserializer_init_type( + &self, + ctx: &Context<'_, '_>, + type_ident: &Ident2, + deserializer_ident: &Ident2, + ) -> Option { + if self.key.type_ == IdentType::Type { + Some(self.render_deserializer_init(ctx, type_ident, deserializer_ident)) + } else { + None + } + } + fn render_deserializer_init( &self, ctx: &Context<'_, '_>, @@ -342,7 +444,7 @@ impl DerivedType { deserializer_ident: &Ident2, ) -> TokenStream { let Self { - ident, + key, b_name, target_type, variant_ident, @@ -390,7 +492,7 @@ impl DerivedType { .meta .types .modules - .get(&ident.ns) + .get(&key.ns) .and_then(|x| x.make_ns_const()) { let ns_name = ctx.resolve_type_for_deserialize_module(&path); @@ -1061,10 +1163,15 @@ impl ComplexDataEnum<'_> { .elements .iter() .find_map(|x| x.deserializer_enum_variant_init_text(ctx)); - let elements = self + let elements_by_tag = self .elements .iter() - .filter_map(|x| x.deserializer_enum_variant_init_element(ctx)) + .filter_map(|x| x.deserializer_enum_variant_init_element_by_tag(ctx)) + .collect::>(); + let elements_by_type = self + .elements + .iter() + .filter_map(|x| x.deserializer_enum_variant_init_element_by_type(ctx)) .collect::>(); let groups = self .elements @@ -1077,7 +1184,7 @@ impl ComplexDataEnum<'_> { .filter_map(|x| x.deserializer_enum_variant_init_any(ctx)) .collect::>(); - let x = if elements.is_empty() { + let x = if elements_by_tag.is_empty() && elements_by_type.is_empty() { quote!(_) } else { quote!(x) @@ -1094,6 +1201,33 @@ impl ComplexDataEnum<'_> { ) }; + let elements_by_type = elements_by_type.is_empty().not().then(|| { + let get_qname = quote!(x.name()); + let get_type_name = quote!(x.name().local_name().as_ref()); + let matcher = make_type_element_matcher(ctx, &get_qname, &get_type_name); + let body = if let Some(default) = self.get_default_type_name(ctx) { + quote! { + let type_name = helper.get_dynamic_type_from_attrib_bytes(x)?.unwrap_or(#default).into_owned(); + + #( #elements_by_type )* + } + } else { + quote! { + if let Some(type_name) = helper.get_dynamic_type_from_attrib_bytes(x)? { + let type_name = type_name.into_owned(); + + #( #elements_by_type )* + } + } + }; + + quote! { + if #matcher { + #body + } + } + }); + quote! { fn find_suitable<'de>( &mut self, @@ -1104,7 +1238,8 @@ impl ComplexDataEnum<'_> { #allow_any_decl if let #event::Start(#x) | #event::Empty(#x) = &event { - #( #elements )* + #( #elements_by_tag )* + #elements_by_type #( #groups )* #( #any )* } @@ -1118,6 +1253,21 @@ impl ComplexDataEnum<'_> { } } + fn get_default_type_name(&self, ctx: &Context<'_, '_>) -> Option { + let default = self + .elements + .iter() + .find(|x| x.meta().flags.contains(ElementMetaFlags::DEFAULT_ELEMENT))?; + + let b_name = &default.b_name; + + let cow = resolve_quick_xml_ident!(ctx, "::alloc::borrow::Cow"); + + Some(quote! { + #cow::Borrowed(#b_name) + }) + } + fn render_deserializer_fn_from_bytes_start(&self, ctx: &mut Context<'_, '_>) -> TokenStream { let config = ctx.get::(); let is_defaultable = ctx.is_defaultable_type(); @@ -2951,6 +3101,8 @@ impl ComplexDataElement<'_> { &self, ctx: &Context<'_, '_>, call_handler: &TokenStream, + get_qname: &TokenStream, + get_type_name: &TokenStream, ) -> Option { if !self.treat_as_element() { return None; @@ -2981,13 +3133,13 @@ impl ComplexDataElement<'_> { let ns_name = ctx.resolve_type_for_deserialize_module(&path); Some(quote! { - if matches!(helper.resolve_local_name(x.name(), &#ns_name), Some(#b_name)) { + if matches!(helper.resolve_local_name(#get_qname, &#ns_name), Some(#b_name)) { #body } }) } else { Some(quote! { - if x.name().local_name().as_ref() == #b_name { + if #get_type_name == #b_name { #body } }) @@ -3070,13 +3222,56 @@ impl ComplexDataElement<'_> { } } - fn deserializer_enum_variant_init_element(&self, ctx: &Context<'_, '_>) -> Option { + fn deserializer_enum_variant_init_element_by_type( + &self, + ctx: &Context<'_, '_>, + ) -> Option { + if self + .meta() + .flags + .contains(ElementMetaFlags::IDENTIFY_BY_TYPE) + { + let qname = resolve_quick_xml_ident!(ctx, "::xsd_parser_types::quick_xml::QName"); + + let get_qname = quote!(#qname(&type_name)); + let get_type_name = quote!(type_name); + + self.deserializer_enum_variant_init_element(ctx, &get_qname, &get_type_name) + } else { + None + } + } + + fn deserializer_enum_variant_init_element_by_tag( + &self, + ctx: &Context<'_, '_>, + ) -> Option { + if self + .meta() + .flags + .contains(ElementMetaFlags::IDENTIFY_BY_TAG) + { + let get_qname = quote!(x.name()); + let get_type_name = quote!(x.name().local_name().as_ref()); + + self.deserializer_enum_variant_init_element(ctx, &get_qname, &get_type_name) + } else { + None + } + } + + fn deserializer_enum_variant_init_element( + &self, + ctx: &Context<'_, '_>, + get_qname: &TokenStream, + get_type_name: &TokenStream, + ) -> Option { let default = resolve_build_in!(ctx, "::core::default::Default"); let handler_ident = self.handler_ident(); let call_handler = quote!(self.#handler_ident(helper, #default::default(), None, output)); - self.deserializer_init_element(ctx, &call_handler) + self.deserializer_init_element(ctx, &call_handler, get_qname, get_type_name) } fn deserializer_enum_variant_init_group( @@ -3626,8 +3821,10 @@ impl ComplexDataElement<'_> { fn deserializer_struct_field_init_element(&self, ctx: &Context<'_, '_>) -> Option { let handler_ident = self.handler_ident(); let call_handler = quote!(self.#handler_ident(helper, output, &mut *fallback)); + let get_qname = quote!(x.name()); + let get_type_name = quote!(x.name().local_name().as_ref()); - self.deserializer_init_element(ctx, &call_handler) + self.deserializer_init_element(ctx, &call_handler, &get_qname, &get_type_name) } fn deserializer_struct_field_init_group( @@ -4248,13 +4445,7 @@ impl MaxOccurs { } } -fn boxed_deserializer_ident(is_boxed: bool, deserializer_ident: &Ident2) -> Ident2 { - if is_boxed { - deserializer_ident.clone() - } else { - format_ident!("Self") - } -} +/* DefaultableCache */ #[derive(Default, Debug)] struct DefaultableCache { @@ -4384,3 +4575,42 @@ impl DefaultableCache { } } } + +/* Helper */ + +fn boxed_deserializer_ident(is_boxed: bool, deserializer_ident: &Ident2) -> Ident2 { + if is_boxed { + deserializer_ident.clone() + } else { + format_ident!("Self") + } +} + +fn make_type_element_matcher( + ctx: &Context<'_, '_>, + get_qname: &TokenStream, + get_type_name: &TokenStream, +) -> TokenStream { + let ident = ctx.ident; + let s_name = ident.name.to_string(); + let b_name = Literal::byte_string(s_name.as_bytes()); + + if let Some(path) = ctx + .types + .meta + .types + .modules + .get(&ident.ns) + .and_then(|x| x.make_ns_const()) + { + let ns_name = ctx.resolve_type_for_deserialize_module(&path); + + quote! { + matches!(helper.resolve_local_name(#get_qname, &#ns_name), Some(#b_name)) + } + } else { + quote! { + #get_type_name == #b_name + } + } +} diff --git a/xsd-parser/src/pipeline/renderer/steps/quick_xml/serialize.rs b/xsd-parser/src/pipeline/renderer/steps/quick_xml/serialize.rs index 4e42a768..58f83681 100644 --- a/xsd-parser/src/pipeline/renderer/steps/quick_xml/serialize.rs +++ b/xsd-parser/src/pipeline/renderer/steps/quick_xml/serialize.rs @@ -20,9 +20,12 @@ use crate::models::{ EnumerationDataVariant, EnumerationVariantValue, Occurs, PathData, ReferenceData, SimpleData, TagName, UnionData, UnionTypeVariant, }, - meta::{CustomMetaNamespace, ElementMetaVariant, MetaTypeVariant, MetaTypes}, + meta::{ + CustomMetaNamespace, DeriveRelationship, DerivedTypeMeta, ElementMeta, ElementMetaFlags, + ElementMetaVariant, MetaTypeVariant, MetaTypes, + }, schema::{xs::FormChoiceType, NamespaceId}, - TypeIdent, + IdentType, TypeIdent, }; use super::super::super::{ @@ -224,6 +227,9 @@ impl DynamicData<'_> { let boxed_serializer = resolve_ident!(ctx, "::xsd_parser_types::quick_xml::BoxedSerializer"); + let dynamic_type_serializer = self.render_dynamic_type_serializer(ctx); + let dynamic_element_serializer = self.render_dynamic_element_serializer(ctx); + let code = quote! { impl #with_serializer for #type_ident { type Serializer<'x> = #boxed_serializer<'x>; @@ -233,7 +239,8 @@ impl DynamicData<'_> { name: #option<&'ser #str_>, is_root: #bool_ ) -> #result, #error> { - let _name = name; + #dynamic_type_serializer + #( #dynamic_element_serializer )* self.0.serializer(None, is_root) } @@ -242,6 +249,64 @@ impl DynamicData<'_> { ctx.current_module().append(code); } + + fn render_dynamic_type_serializer(&self, ctx: &Context<'_, '_>) -> Option { + filter_dynamic_types(&self.derived_types, |x| (&x.key, &x.meta)) + .map(|x| { + let target_type = ctx.resolve_type_for_module(&x.target_type); + + quote!((*self.0).as_any().is::<#target_type>()) + }) + .fold(None, |acc, condition| { + Some(if let Some(acc) = acc { + quote!(#acc || #condition) + } else { + condition + }) + }) + .map(|condition| { + let config = ctx.get_ref::(); + let tag_name = self + .tag_name + .get_for_default_namespace(&config.default_namespace); + let box_ = resolve_build_in!(ctx, "::alloc::boxed::Box"); + let xsi_type_serializer = + resolve_ident!(ctx, "::xsd_parser_types::quick_xml::XsiTypeSerializer"); + + quote! { + if #condition { + return Ok(#box_::new(#xsi_type_serializer::new( + self.0.serializer(None, is_root)?, + name.unwrap_or(#tag_name), + is_root, + ))); + } + } + }) + } + + fn render_dynamic_element_serializer<'x, 'a>( + &'x self, + ctx: &'x Context<'a, '_>, + ) -> impl Iterator + use<'x, 'a> { + self.derived_types.iter().filter_map(move |x| { + if x.key.type_ != IdentType::Element { + return None; + } + + let target_type = ctx.resolve_type_for_module(&x.target_type); + let config = ctx.get_ref::(); + let tag_name = x + .tag_name + .get_for_default_namespace(&config.default_namespace); + + Some(quote! { + if (*self.0).as_any().is::<#target_type>() { + return self.0.serializer(Some(#tag_name), is_root); + } + }) + }) + } } /* ReferenceData */ @@ -855,7 +920,7 @@ impl ComplexDataEnum<'_> { let state_variants = self .elements .iter() - .map(|x| x.render_serializer_state_variant(ctx)); + .filter_map(|x| x.render_serializer_state_variant(ctx)); let state_end = self.represents_element().then(|| { quote! { End__, @@ -877,6 +942,12 @@ impl ComplexDataEnum<'_> { } fn render_serializer_impl(&self, ctx: &mut Context<'_, '_>) { + let config = ctx.get_ref::(); + let element_name = self.tag_name.as_ref().map_or_else( + || ctx.ident.name.to_string(), + |x| x.get_for_default_namespace(&config.default_namespace), + ); + let serializer_ident = &self.serializer_ident; let serializer_state_ident = &self.serializer_state_ident; @@ -904,6 +975,7 @@ impl ComplexDataEnum<'_> { ctx, &self.serializer_state_ident, !self.is_content(), + &element_name, ); quote! { @@ -1240,16 +1312,23 @@ impl ComplexDataContent<'_> { } impl ComplexDataElement<'_> { - fn render_serializer_state_variant(&self, ctx: &Context<'_, '_>) -> TokenStream { + fn render_serializer_state_variant(&self, ctx: &Context<'_, '_>) -> Option { let target_type = ctx.resolve_type_for_serialize_module(&self.target_type); let variant_ident = &self.variant_ident; - let serializer = self - .occurs - .make_serializer_type(ctx, &target_type, self.need_indirection); + let mut serializer = + self.occurs + .make_serializer_type(ctx, &target_type, self.need_indirection)?; - quote! { - #variant_ident(#serializer), + if self.meta().use_dynamic_type_serializer() { + let xsi_type_serializer = + resolve_quick_xml_ident!(ctx, "::xsd_parser_types::quick_xml::XsiTypeSerializer"); + + serializer = quote!(#xsi_type_serializer<'ser, #serializer>); } + + Some(quote! { + #variant_ident(#serializer), + }) } fn render_serializer_enum_state_init( @@ -1257,6 +1336,7 @@ impl ComplexDataElement<'_> { ctx: &Context<'_, '_>, state_ident: &Ident2, forward_root: bool, + dynamic_type: &str, ) -> TokenStream { let value = match self.occurs { Occurs::None => unreachable!(), @@ -1267,7 +1347,13 @@ impl ComplexDataElement<'_> { Occurs::DynamicList | Occurs::StaticList(_) => quote!(&x[..]), }; - self.render_serializer_state_init(ctx, state_ident, &value, forward_root) + self.render_serializer_state_init( + ctx, + state_ident, + &value, + forward_root, + Some(dynamic_type), + ) } fn render_serializer_struct_state_init( @@ -1288,7 +1374,7 @@ impl ComplexDataElement<'_> { Occurs::DynamicList | Occurs::StaticList(_) => quote!(&self.value.#field_ident[..]), }; - self.render_serializer_state_init(ctx, state_ident, &value, false) + self.render_serializer_state_init(ctx, state_ident, &value, false, None) } fn render_serializer_state_init( @@ -1297,6 +1383,7 @@ impl ComplexDataElement<'_> { state_ident: &Ident2, value: &TokenStream, forward_root: bool, + dynamic_type: Option<&str>, ) -> TokenStream { let config = ctx.get_ref::(); let field_name = self @@ -1316,16 +1403,14 @@ impl ComplexDataElement<'_> { .then(|| quote!(None)) .unwrap_or_else(|| quote!(Some(#field_name))); - match self.occurs { + let mut serializer = match self.occurs { Occurs::None => crate::unreachable!(), Occurs::Single => { let with_serializer = resolve_quick_xml_ident!(ctx, "::xsd_parser_types::quick_xml::WithSerializer"); quote! { - *self.state = #state_ident::#variant_ident( - #with_serializer::serializer(#value, #element_name, #is_root)? - ) + #with_serializer::serializer(#value, #element_name, #is_root)? } } Occurs::StaticList(_) if self.need_indirection => { @@ -1335,12 +1420,10 @@ impl ComplexDataElement<'_> { resolve_quick_xml_ident!(ctx, "::xsd_parser_types::quick_xml::IterSerializer"); quote! { - *self.state = #state_ident::#variant_ident( - #iter_serializer::new( - #deref_iter::new(#value), - #element_name, - #is_root - ) + #iter_serializer::new( + #deref_iter::new(#value), + #element_name, + #is_root ) } } @@ -1349,16 +1432,39 @@ impl ComplexDataElement<'_> { resolve_quick_xml_ident!(ctx, "::xsd_parser_types::quick_xml::IterSerializer"); quote! { - *self.state = #state_ident::#variant_ident( - #iter_serializer::new( - #value, - #element_name, - #is_root - ) + #iter_serializer::new( + #value, + #element_name, + #is_root ) } } + }; + + if let Some(dynamic_type) = dynamic_type { + if self.meta().use_dynamic_type_serializer() { + let xsi_type_serializer = resolve_quick_xml_ident!( + ctx, + "::xsd_parser_types::quick_xml::XsiTypeSerializer" + ); + + serializer = + quote!(#xsi_type_serializer::new(#serializer, #dynamic_type, #is_root)); + } } + + quote!(*self.state = #state_ident::#variant_ident(#serializer)) + } +} + +impl ElementMeta { + fn use_dynamic_type_serializer(&self) -> bool { + self.flags.contains(ElementMetaFlags::IDENTIFY_BY_TYPE) + && !self.flags.contains(ElementMetaFlags::DEFAULT_ELEMENT) + && (self + .flags + .contains(ElementMetaFlags::PREFER_IDENTIFY_BY_TYPE) + || !self.flags.contains(ElementMetaFlags::IDENTIFY_BY_TAG)) } } @@ -1520,9 +1626,19 @@ impl NamespaceCollector { } } MetaTypeVariant::Dynamic(x) => { - for meta in &x.derived_types { + for meta in x.derived_types.values() { self.merge(&mut state, types, &meta.type_, default_ns); } + + let has_dynamic_types = filter_dynamic_types(&x.derived_types, |x| *x) + .next() + .is_some(); + + if has_dynamic_types { + if let Some(id) = self.xsi_namespace { + Self::add_ns(&mut state, types, NamespaceKey::Normal(id)); + } + } } MetaTypeVariant::All(x) | MetaTypeVariant::Choice(x) @@ -1531,11 +1647,20 @@ impl NamespaceCollector { if let ElementMetaVariant::Type { type_, .. } = &el.variant { self.merge(&mut state, types, type_, default_ns); } - if self.nillable_type_support && el.nillable { + + if self.nillable_type_support && el.is_nillable() { if let Some(id) = self.xsi_namespace { Self::add_ns(&mut state, types, NamespaceKey::Normal(id)); } } + + if let MetaTypeVariant::Choice(_) = &ty.variant { + if el.use_dynamic_type_serializer() { + if let Some(id) = self.xsi_namespace { + Self::add_ns(&mut state, types, NamespaceKey::Normal(id)); + } + } + } } } MetaTypeVariant::ComplexType(x) => { @@ -1692,3 +1817,40 @@ impl NamespaceCollector { } } } + +/* Helper */ + +fn filter_dynamic_types<'a, I, F>( + iter: &'a I, + f: F, +) -> impl Iterator::Item> +where + &'a I: IntoIterator + 'a, + F: Fn(&<&'a I as IntoIterator>::Item) -> (&'a TypeIdent, &'a DerivedTypeMeta), +{ + let derived_elements = iter + .into_iter() + .filter_map(|x| { + let (key, meta) = f(&x); + + if key.type_ == IdentType::Element { + Some(&meta.type_) + } else { + None + } + }) + .collect::>(); + + iter.into_iter().filter_map(move |x| { + let (key, meta) = f(&x); + + if key.type_ != IdentType::Type + || meta.relationship == DeriveRelationship::ConcreteType + || derived_elements.contains(&meta.type_) + { + return None; + } + + Some(x) + }) +} diff --git a/xsd-parser/src/pipeline/renderer/steps/types.rs b/xsd-parser/src/pipeline/renderer/steps/types.rs index 40d4e701..22513f80 100644 --- a/xsd-parser/src/pipeline/renderer/steps/types.rs +++ b/xsd-parser/src/pipeline/renderer/steps/types.rs @@ -43,6 +43,7 @@ impl UnionData<'_> { variants, .. } = self; + let docs = ctx.render_type_docs(); let derive = get_derive(ctx, Option::::None); let trait_impls = render_trait_impls(type_ident, trait_impls); @@ -94,12 +95,13 @@ impl DynamicData<'_> { type_ident, trait_ident, sub_traits, + trait_impls, .. } = self; let docs = ctx.render_type_docs(); let derive = get_derive(ctx, Option::::None); - let trait_impls = render_trait_impls(type_ident, &[]); + let trait_impls = render_trait_impls(type_ident, trait_impls); let dyn_traits = sub_traits.as_ref().map_or_else( || get_dyn_type_traits(ctx, []), |traits| format_traits(traits.iter().map(|x| ctx.resolve_type_for_module(x))), @@ -117,6 +119,12 @@ impl DynamicData<'_> { pub trait #trait_ident: #dyn_traits { } #( #trait_impls )* + + impl #type_ident { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } + } }; ctx.current_module().append(code); diff --git a/xsd-parser/tests/feature/dynamic_type/example/default.xml b/xsd-parser/tests/feature/dynamic_type/example/default.xml new file mode 100644 index 00000000..402c23f0 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type/example/default.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/xsd-parser/tests/feature/dynamic_type/expected/default.rs b/xsd-parser/tests/feature/dynamic_type/expected/default.rs new file mode 100644 index 00000000..4e51bb41 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type/expected/default.rs @@ -0,0 +1,33 @@ +use core::fmt::Debug; +use xsd_parser_types::AsAny; +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +#[derive(Debug)] +pub struct AnimalType(pub Box); +pub trait AnimalTypeTrait: Debug + AsAny {} +impl AnimalType { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +#[derive(Debug)] +pub struct AnimalDyn { + pub id: i32, +} +impl AnimalTypeTrait for AnimalDyn {} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +impl AnimalTypeTrait for DogType {} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl AnimalTypeTrait for LabradorType {} diff --git a/xsd-parser/tests/feature/dynamic_type/expected/default_optimized.rs b/xsd-parser/tests/feature/dynamic_type/expected/default_optimized.rs new file mode 100644 index 00000000..7654e96a --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type/expected/default_optimized.rs @@ -0,0 +1,26 @@ +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +#[derive(Debug)] +pub enum AnimalType { + Animal(AnimalDyn), + Dog(DogType), + Labrador(LabradorType), +} +#[derive(Debug)] +pub struct AnimalDyn { + pub id: i32, +} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} diff --git a/xsd-parser/tests/feature/dynamic_type/expected/quick_xml.rs b/xsd-parser/tests/feature/dynamic_type/expected/quick_xml.rs new file mode 100644 index 00000000..fa08a3dc --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type/expected/quick_xml.rs @@ -0,0 +1,917 @@ +use core::fmt::Debug; +use xsd_parser_types::{ + misc::{Namespace, NamespacePrefix}, + quick_xml::{ + BoxedSerializer, Error, WithBoxedSerializer, WithDeserializer, WithSerializer, + XsiTypeSerializer, + }, + AsAny, +}; +pub const NS_XS: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema"); +pub const NS_XML: Namespace = Namespace::new_const(b"http://www.w3.org/XML/1998/namespace"); +pub const NS_XSI: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema-instance"); +pub const NS_TNS: Namespace = Namespace::new_const(b"http://example.com"); +pub const PREFIX_XS: NamespacePrefix = NamespacePrefix::new_const(b"xs"); +pub const PREFIX_XML: NamespacePrefix = NamespacePrefix::new_const(b"xml"); +pub const PREFIX_XSI: NamespacePrefix = NamespacePrefix::new_const(b"xsi"); +pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns"); +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +impl WithSerializer for ListType { + type Serializer<'x> = quick_xml_serialize::ListTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::ListTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::ListTypeSerializerState::Init__), + name: name.unwrap_or("list"), + is_root, + }) + } +} +impl WithDeserializer for ListType { + type Deserializer = quick_xml_deserialize::ListTypeDeserializer; +} +#[derive(Debug)] +pub struct AnimalType(pub Box); +pub trait AnimalTypeTrait: Debug + AsAny + WithBoxedSerializer {} +impl AnimalType { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +impl WithSerializer for AnimalType { + type Serializer<'x> = BoxedSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + if (*self.0).as_any().is::() || (*self.0).as_any().is::() { + return Ok(Box::new(XsiTypeSerializer::new( + self.0.serializer(None, is_root)?, + name.unwrap_or("animal"), + is_root, + ))); + } + self.0.serializer(None, is_root) + } +} +impl WithDeserializer for AnimalType { + type Deserializer = quick_xml_deserialize::AnimalTypeDeserializer; +} +#[derive(Debug)] +pub struct AnimalDyn { + pub id: i32, +} +impl AnimalTypeTrait for AnimalDyn {} +impl WithSerializer for AnimalDyn { + type Serializer<'x> = quick_xml_serialize::AnimalDynSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::AnimalDynSerializer { + value: self, + state: Box::new(quick_xml_serialize::AnimalDynSerializerState::Init__), + name: name.unwrap_or("animal"), + is_root, + }) + } +} +impl WithDeserializer for AnimalDyn { + type Deserializer = quick_xml_deserialize::AnimalDynDeserializer; +} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +impl AnimalTypeTrait for DogType {} +impl WithSerializer for DogType { + type Serializer<'x> = quick_xml_serialize::DogTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::DogTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::DogTypeSerializerState::Init__), + name: name.unwrap_or("dog"), + is_root, + }) + } +} +impl WithDeserializer for DogType { + type Deserializer = quick_xml_deserialize::DogTypeDeserializer; +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl AnimalTypeTrait for LabradorType {} +impl WithSerializer for LabradorType { + type Serializer<'x> = quick_xml_serialize::LabradorTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::LabradorTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::LabradorTypeSerializerState::Init__), + name: name.unwrap_or("labrador"), + is_root, + }) + } +} +impl WithDeserializer for LabradorType { + type Deserializer = quick_xml_deserialize::LabradorTypeDeserializer; +} +pub mod quick_xml_deserialize { + use core::mem::replace; + use std::borrow::Cow; + use xsd_parser_types::quick_xml::{ + BytesStart, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent, + DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event, + QName, WithDeserializer, + }; + #[derive(Debug)] + pub struct ListTypeDeserializer { + animal: Vec, + state__: Box, + } + #[derive(Debug)] + enum ListTypeDeserializerState { + Init__, + Animal(Option<::Deserializer>), + Done__, + Unknown__, + } + impl ListTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + helper.raise_unexpected_attrib_checked(&attrib)?; + } + Ok(Self { + animal: Vec::new(), + state__: Box::new(ListTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: ListTypeDeserializerState, + ) -> Result<(), Error> { + use ListTypeDeserializerState as S; + match state { + S::Animal(Some(deserializer)) => self.store_animal(deserializer.finish(helper)?)?, + _ => (), + } + Ok(()) + } + fn store_animal(&mut self, value: super::AnimalType) -> Result<(), Error> { + self.animal.push(value); + Ok(()) + } + fn handle_animal<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::AnimalType>, + fallback: &mut Option, + ) -> Result, Error> { + use ListTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_animal(data)?; + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Animal(Some(deserializer))); + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::ListType> for ListTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + use ListTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Animal(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Animal(None); + event + } + (S::Animal(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = ::init(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, ListTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::ListType { + animal: self.animal, + }) + } + } + #[derive(Debug)] + pub enum AnimalTypeDeserializer { + Animal(::Deserializer), + Dog(::Deserializer), + Labrador(::Deserializer), + } + impl<'de> Deserializer<'de, super::AnimalType> for AnimalTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalType> { + let Some(type_name) = helper.get_dynamic_type_from_tag(&event) else { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::None, + allow_any: false, + }); + }; + let type_name = type_name.into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"animal") + ) { + let type_name = helper + .get_dynamic_type_from_attrib(&event)? + .unwrap_or(Cow::Borrowed(b"animal")) + .into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"animal") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"dog") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Dog(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"labrador") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Labrador(x)), + event, + allow_any, + }); + } + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + fn next( + self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalType> { + match self { + Self::Animal(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }) + } + Self::Dog(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Dog(x)), + event, + allow_any, + }) + } + Self::Labrador(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Labrador(x)), + event, + allow_any, + }) + } + } + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + match self { + Self::Animal(x) => Ok(super::AnimalType(Box::new(x.finish(helper)?))), + Self::Dog(x) => Ok(super::AnimalType(Box::new(x.finish(helper)?))), + Self::Labrador(x) => Ok(super::AnimalType(Box::new(x.finish(helper)?))), + } + } + } + #[derive(Debug)] + pub struct AnimalDynDeserializer { + id: i32, + state__: Box, + } + #[derive(Debug)] + enum AnimalDynDeserializerState { + Init__, + Unknown__, + } + impl AnimalDynDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + state__: Box::new(AnimalDynDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: AnimalDynDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::AnimalDyn> for AnimalDynDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalDyn> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalDyn> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, AnimalDynDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::AnimalDyn { id: self.id }) + } + } + #[derive(Debug)] + pub struct DogTypeDeserializer { + id: i32, + name: String, + state__: Box, + } + #[derive(Debug)] + enum DogTypeDeserializerState { + Init__, + Unknown__, + } + impl DogTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + state__: Box::new(DogTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: DogTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::DogType> for DogTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, DogTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::DogType { + id: self.id, + name: self.name, + }) + } + } + #[derive(Debug)] + pub struct LabradorTypeDeserializer { + id: i32, + name: String, + color: String, + state__: Box, + } + #[derive(Debug)] + enum LabradorTypeDeserializerState { + Init__, + Unknown__, + } + impl LabradorTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + let mut color: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"color") + ) { + helper.read_attrib(&mut color, b"color", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + color: color.ok_or_else(|| ErrorKind::MissingAttribute("color".into()))?, + state__: Box::new(LabradorTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: LabradorTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::LabradorType> for LabradorTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, LabradorTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::LabradorType { + id: self.id, + name: self.name, + color: self.color, + }) + } + } +} +pub mod quick_xml_serialize { + use xsd_parser_types::quick_xml::{ + BytesEnd, BytesStart, Error, Event, IterSerializer, SerializeHelper, Serializer, + }; + #[derive(Debug)] + pub struct ListTypeSerializer<'ser> { + pub(super) value: &'ser super::ListType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum ListTypeSerializerState<'ser> { + Init__, + Animal(IterSerializer<'ser, &'ser [super::AnimalType], super::AnimalType>), + End__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> ListTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + ListTypeSerializerState::Init__ => { + *self.state = ListTypeSerializerState::Animal(IterSerializer::new( + &self.value.animal[..], + Some("animal"), + false, + )); + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + helper.write_xmlns( + &mut bytes, + Some(&super::PREFIX_XSI), + &super::NS_XSI, + ); + } + return Ok(Some(Event::Start(bytes))); + } + ListTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = ListTypeSerializerState::End__, + }, + ListTypeSerializerState::End__ => { + *self.state = ListTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); + } + ListTypeSerializerState::Done__ => return Ok(None), + ListTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for ListTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = ListTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct AnimalDynSerializer<'ser> { + pub(super) value: &'ser super::AnimalDyn, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum AnimalDynSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> AnimalDynSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + AnimalDynSerializerState::Init__ => { + *self.state = AnimalDynSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + AnimalDynSerializerState::Done__ => return Ok(None), + AnimalDynSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for AnimalDynSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = AnimalDynSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct DogTypeSerializer<'ser> { + pub(super) value: &'ser super::DogType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum DogTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> DogTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + DogTypeSerializerState::Init__ => { + *self.state = DogTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + DogTypeSerializerState::Done__ => return Ok(None), + DogTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for DogTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = DogTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct LabradorTypeSerializer<'ser> { + pub(super) value: &'ser super::LabradorType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum LabradorTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> LabradorTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + LabradorTypeSerializerState::Init__ => { + *self.state = LabradorTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "color", &self.value.color)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + LabradorTypeSerializerState::Done__ => return Ok(None), + LabradorTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for LabradorTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = LabradorTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } +} diff --git a/xsd-parser/tests/feature/dynamic_type/expected/quick_xml_optimized.rs b/xsd-parser/tests/feature/dynamic_type/expected/quick_xml_optimized.rs new file mode 100644 index 00000000..c7425f16 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type/expected/quick_xml_optimized.rs @@ -0,0 +1,1235 @@ +use xsd_parser_types::{ + misc::{Namespace, NamespacePrefix}, + quick_xml::{Error, WithDeserializer, WithSerializer}, +}; +pub const NS_XS: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema"); +pub const NS_XML: Namespace = Namespace::new_const(b"http://www.w3.org/XML/1998/namespace"); +pub const NS_XSI: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema-instance"); +pub const NS_TNS: Namespace = Namespace::new_const(b"http://example.com"); +pub const PREFIX_XS: NamespacePrefix = NamespacePrefix::new_const(b"xs"); +pub const PREFIX_XML: NamespacePrefix = NamespacePrefix::new_const(b"xml"); +pub const PREFIX_XSI: NamespacePrefix = NamespacePrefix::new_const(b"xsi"); +pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns"); +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +impl WithSerializer for ListType { + type Serializer<'x> = quick_xml_serialize::ListTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::ListTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::ListTypeSerializerState::Init__), + name: name.unwrap_or("list"), + is_root, + }) + } +} +impl WithDeserializer for ListType { + type Deserializer = quick_xml_deserialize::ListTypeDeserializer; +} +#[derive(Debug)] +pub enum AnimalType { + Animal(AnimalDyn), + Dog(DogType), + Labrador(LabradorType), +} +impl WithSerializer for AnimalType { + type Serializer<'x> = quick_xml_serialize::AnimalTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + let _name = name; + Ok(quick_xml_serialize::AnimalTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::AnimalTypeSerializerState::Init__), + is_root, + }) + } +} +impl WithDeserializer for AnimalType { + type Deserializer = quick_xml_deserialize::AnimalTypeDeserializer; +} +#[derive(Debug)] +pub struct AnimalDyn { + pub id: i32, +} +impl WithSerializer for AnimalDyn { + type Serializer<'x> = quick_xml_serialize::AnimalDynSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::AnimalDynSerializer { + value: self, + state: Box::new(quick_xml_serialize::AnimalDynSerializerState::Init__), + name: name.unwrap_or("animal"), + is_root, + }) + } +} +impl WithDeserializer for AnimalDyn { + type Deserializer = quick_xml_deserialize::AnimalDynDeserializer; +} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +impl WithSerializer for DogType { + type Serializer<'x> = quick_xml_serialize::DogTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::DogTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::DogTypeSerializerState::Init__), + name: name.unwrap_or("dog"), + is_root, + }) + } +} +impl WithDeserializer for DogType { + type Deserializer = quick_xml_deserialize::DogTypeDeserializer; +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl WithSerializer for LabradorType { + type Serializer<'x> = quick_xml_serialize::LabradorTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::LabradorTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::LabradorTypeSerializerState::Init__), + name: name.unwrap_or("labrador"), + is_root, + }) + } +} +impl WithDeserializer for LabradorType { + type Deserializer = quick_xml_deserialize::LabradorTypeDeserializer; +} +pub mod quick_xml_deserialize { + use core::mem::replace; + use std::borrow::Cow; + use xsd_parser_types::quick_xml::{ + BytesStart, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent, + DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event, + QName, RawByteStr, WithDeserializer, + }; + #[derive(Debug)] + pub struct ListTypeDeserializer { + animal: Vec, + state__: Box, + } + #[derive(Debug)] + enum ListTypeDeserializerState { + Init__, + Animal(Option<::Deserializer>), + Done__, + Unknown__, + } + impl ListTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + helper.raise_unexpected_attrib_checked(&attrib)?; + } + Ok(Self { + animal: Vec::new(), + state__: Box::new(ListTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: ListTypeDeserializerState, + ) -> Result<(), Error> { + use ListTypeDeserializerState as S; + match state { + S::Animal(Some(deserializer)) => self.store_animal(deserializer.finish(helper)?)?, + _ => (), + } + Ok(()) + } + fn store_animal(&mut self, value: super::AnimalType) -> Result<(), Error> { + self.animal.push(value); + Ok(()) + } + fn handle_animal<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::AnimalType>, + fallback: &mut Option, + ) -> Result, Error> { + use ListTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_animal(data)?; + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Animal(Some(deserializer))); + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::ListType> for ListTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + use ListTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Animal(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Animal(None); + event + } + (S::Animal(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = ::init(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, ListTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::ListType { + animal: self.animal, + }) + } + } + #[derive(Debug)] + pub struct AnimalTypeDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum AnimalTypeDeserializerState { + Init__, + Animal( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Dog( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Labrador( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::AnimalType), + Unknown__, + } + impl AnimalTypeDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::NS_TNS), + Some(b"animal") + ) { + let type_name = helper + .get_dynamic_type_from_attrib_bytes(x)? + .unwrap_or(Cow::Borrowed(b"animal")) + .into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"animal") + ) { + let output = ::init(helper, event)?; + return self.handle_animal(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"dog") + ) { + let output = ::init(helper, event)?; + return self.handle_dog(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"labrador") + ) { + let output = + ::init(helper, event)?; + return self.handle_labrador(helper, Default::default(), None, output); + } + } + } + *self.state__ = AnimalTypeDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: AnimalTypeDeserializerState, + ) -> Result { + use AnimalTypeDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Animal(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_animal(&mut values, value)?; + } + Ok(super::AnimalType::Animal( + helper.finish_element("animal", values)?, + )) + } + S::Dog(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_dog(&mut values, value)?; + } + Ok(super::AnimalType::Dog( + helper.finish_element("dog", values)?, + )) + } + S::Labrador(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_labrador(&mut values, value)?; + } + Ok(super::AnimalType::Labrador( + helper.finish_element("labrador", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_animal( + values: &mut Option, + value: super::AnimalDyn, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"animal", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_dog( + values: &mut Option, + value: super::DogType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"dog")))?; + } + *values = Some(value); + Ok(()) + } + fn store_labrador( + values: &mut Option, + value: super::LabradorType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"labrador", + )))?; + } + *values = Some(value); + Ok(()) + } + fn handle_animal<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnimalDyn>, + ) -> Result, Error> { + use AnimalTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_animal(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_animal(&mut values, data)?; + let data = Self::finish_state(helper, S::Animal(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Animal(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_dog<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::DogType>, + ) -> Result, Error> { + use AnimalTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_dog(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_dog(&mut values, data)?; + let data = Self::finish_state(helper, S::Dog(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Dog(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_labrador<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LabradorType>, + ) -> Result, Error> { + use AnimalTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_labrador(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_labrador(&mut values, data)?; + let data = Self::finish_state(helper, S::Labrador(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Labrador(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::AnimalType> for AnimalTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalType> { + let deserializer = Self { + state__: Box::new(AnimalTypeDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, AnimalTypeDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalType> { + use AnimalTypeDeserializerState as S; + let mut event = event; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Animal(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_animal(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Dog(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_dog(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Labrador(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_labrador(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state, event @ Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Animal(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_TNS), + b"animal", + false, + )?; + match self.handle_animal(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Dog(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_TNS), + b"dog", + false, + )?; + match self.handle_dog(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Labrador(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_TNS), + b"labrador", + false, + )?; + match self.handle_labrador(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + } + }; + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + Self::finish_state(helper, *self.state__) + } + } + #[derive(Debug)] + pub struct AnimalDynDeserializer { + id: i32, + state__: Box, + } + #[derive(Debug)] + enum AnimalDynDeserializerState { + Init__, + Unknown__, + } + impl AnimalDynDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + state__: Box::new(AnimalDynDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: AnimalDynDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::AnimalDyn> for AnimalDynDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalDyn> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalDyn> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, AnimalDynDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::AnimalDyn { id: self.id }) + } + } + #[derive(Debug)] + pub struct DogTypeDeserializer { + id: i32, + name: String, + state__: Box, + } + #[derive(Debug)] + enum DogTypeDeserializerState { + Init__, + Unknown__, + } + impl DogTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + state__: Box::new(DogTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: DogTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::DogType> for DogTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, DogTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::DogType { + id: self.id, + name: self.name, + }) + } + } + #[derive(Debug)] + pub struct LabradorTypeDeserializer { + id: i32, + name: String, + color: String, + state__: Box, + } + #[derive(Debug)] + enum LabradorTypeDeserializerState { + Init__, + Unknown__, + } + impl LabradorTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + let mut color: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"color") + ) { + helper.read_attrib(&mut color, b"color", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + color: color.ok_or_else(|| ErrorKind::MissingAttribute("color".into()))?, + state__: Box::new(LabradorTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: LabradorTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::LabradorType> for LabradorTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, LabradorTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::LabradorType { + id: self.id, + name: self.name, + color: self.color, + }) + } + } +} +pub mod quick_xml_serialize { + use xsd_parser_types::quick_xml::{ + BytesEnd, BytesStart, Error, Event, IterSerializer, SerializeHelper, Serializer, + WithSerializer, XsiTypeSerializer, + }; + #[derive(Debug)] + pub struct ListTypeSerializer<'ser> { + pub(super) value: &'ser super::ListType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum ListTypeSerializerState<'ser> { + Init__, + Animal(IterSerializer<'ser, &'ser [super::AnimalType], super::AnimalType>), + End__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> ListTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + ListTypeSerializerState::Init__ => { + *self.state = ListTypeSerializerState::Animal(IterSerializer::new( + &self.value.animal[..], + Some("animal"), + false, + )); + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + helper.write_xmlns( + &mut bytes, + Some(&super::PREFIX_XSI), + &super::NS_XSI, + ); + } + return Ok(Some(Event::Start(bytes))); + } + ListTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = ListTypeSerializerState::End__, + }, + ListTypeSerializerState::End__ => { + *self.state = ListTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); + } + ListTypeSerializerState::Done__ => return Ok(None), + ListTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for ListTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = ListTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct AnimalTypeSerializer<'ser> { + pub(super) value: &'ser super::AnimalType, + pub(super) state: Box>, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum AnimalTypeSerializerState<'ser> { + Init__, + Animal(::Serializer<'ser>), + Dog(XsiTypeSerializer<'ser, ::Serializer<'ser>>), + Labrador( + XsiTypeSerializer<'ser, ::Serializer<'ser>>, + ), + Done__, + Phantom__(&'ser ()), + } + impl<'ser> AnimalTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + AnimalTypeSerializerState::Init__ => match self.value { + super::AnimalType::Animal(x) => { + *self.state = AnimalTypeSerializerState::Animal( + WithSerializer::serializer(x, Some("animal"), self.is_root)?, + ) + } + super::AnimalType::Dog(x) => { + *self.state = AnimalTypeSerializerState::Dog(XsiTypeSerializer::new( + WithSerializer::serializer(x, Some("dog"), self.is_root)?, + "animal", + self.is_root, + )) + } + super::AnimalType::Labrador(x) => { + *self.state = + AnimalTypeSerializerState::Labrador(XsiTypeSerializer::new( + WithSerializer::serializer(x, Some("labrador"), self.is_root)?, + "animal", + self.is_root, + )) + } + }, + AnimalTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AnimalTypeSerializerState::Done__, + }, + AnimalTypeSerializerState::Dog(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AnimalTypeSerializerState::Done__, + }, + AnimalTypeSerializerState::Labrador(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AnimalTypeSerializerState::Done__, + }, + AnimalTypeSerializerState::Done__ => return Ok(None), + AnimalTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for AnimalTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = AnimalTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct AnimalDynSerializer<'ser> { + pub(super) value: &'ser super::AnimalDyn, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum AnimalDynSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> AnimalDynSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + AnimalDynSerializerState::Init__ => { + *self.state = AnimalDynSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + AnimalDynSerializerState::Done__ => return Ok(None), + AnimalDynSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for AnimalDynSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = AnimalDynSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct DogTypeSerializer<'ser> { + pub(super) value: &'ser super::DogType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum DogTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> DogTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + DogTypeSerializerState::Init__ => { + *self.state = DogTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + DogTypeSerializerState::Done__ => return Ok(None), + DogTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for DogTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = DogTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct LabradorTypeSerializer<'ser> { + pub(super) value: &'ser super::LabradorType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum LabradorTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> LabradorTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + LabradorTypeSerializerState::Init__ => { + *self.state = LabradorTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "color", &self.value.color)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + LabradorTypeSerializerState::Done__ => return Ok(None), + LabradorTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for LabradorTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = LabradorTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } +} diff --git a/xsd-parser/tests/feature/dynamic_type/mod.rs b/xsd-parser/tests/feature/dynamic_type/mod.rs new file mode 100644 index 00000000..256a130b --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type/mod.rs @@ -0,0 +1,206 @@ +use xsd_parser::{ + config::{GeneratorFlags, OptimizerFlags}, + Config, IdentType, +}; + +use crate::utils::{generate_test, ConfigEx}; + +fn config() -> Config { + Config::test_default() + .with_derive(["Debug"]) + .with_generator_flags(GeneratorFlags::FLATTEN_CONTENT) + .with_dynamic_type((IdentType::Type, "tns:animal")) + .with_generate([(IdentType::Element, "tns:list")]) +} + +/* default */ + +#[test] +fn generate_default() { + generate_test( + "tests/feature/dynamic_type/schema.xsd", + "tests/feature/dynamic_type/expected/default.rs", + config(), + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod default { + #![allow(unused_imports)] + + include!("expected/default.rs"); +} + +/* default (optimized) */ + +#[test] +fn generate_default_optimized() { + generate_test( + "tests/feature/dynamic_type/schema.xsd", + "tests/feature/dynamic_type/expected/default_optimized.rs", + config().with_optimizer_flags(OptimizerFlags::all()), + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod default_optmized { + #![allow(unused_imports)] + + include!("expected/default_optimized.rs"); +} + +/* quick_xml */ + +#[test] +fn generate_quick_xml() { + generate_test( + "tests/feature/dynamic_type/schema.xsd", + "tests/feature/dynamic_type/expected/quick_xml.rs", + config().with_quick_xml(), + ); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn read_quick_xml() { + use quick_xml::{AnimalDyn, DogType, LabradorType, List}; + + let obj = crate::utils::quick_xml_read_test::( + "tests/feature/dynamic_type/example/default.xml", + ); + + let mut items = obj.animal.iter(); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 1); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 2); + assert_eq!(item.name, "Rex"); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 3); + assert_eq!(item.name, "Buddy"); + assert_eq!(item.color, "black"); + + assert!(items.next().is_none()); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn write_quick_xml() { + use quick_xml::{AnimalDyn, AnimalType, DogType, LabradorType, List}; + + let obj = List { + animal: vec![ + AnimalType::new(AnimalDyn { id: 1 }), + AnimalType::new(DogType { + id: 2, + name: "Rex".into(), + }), + AnimalType::new(LabradorType { + id: 3, + name: "Buddy".into(), + color: "black".into(), + }), + ], + }; + + crate::utils::quick_xml_write_test( + &obj, + "list", + "tests/feature/dynamic_type/example/default.xml", + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod quick_xml { + #![allow(unused_imports)] + + include!("expected/quick_xml.rs"); +} + +/* quick_xml (optimized) */ + +#[test] +fn generate_quick_xml_optimized() { + generate_test( + "tests/feature/dynamic_type/schema.xsd", + "tests/feature/dynamic_type/expected/quick_xml_optimized.rs", + config() + .with_quick_xml() + .with_optimizer_flags(OptimizerFlags::all()), + ); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn read_quick_xml_optimized() { + use quick_xml_optimized::{AnimalType, List}; + + let obj = crate::utils::quick_xml_read_test::( + "tests/feature/dynamic_type/example/default.xml", + ); + + let mut items = obj.animal.into_iter(); + + let item = items.next().unwrap(); + let AnimalType::Animal(item) = item else { + panic!("Expected `AnimalType::Animal`"); + }; + assert_eq!(item.id, 1); + + let item = items.next().unwrap(); + let AnimalType::Dog(item) = item else { + panic!("Expected `AnimalType::Dog`"); + }; + assert_eq!(item.id, 2); + assert_eq!(item.name, "Rex"); + + let item = items.next().unwrap(); + let AnimalType::Labrador(item) = item else { + panic!("Expected `AnimalType::Labrador`"); + }; + assert_eq!(item.id, 3); + assert_eq!(item.name, "Buddy"); + assert_eq!(item.color, "black"); + + assert!(items.next().is_none()); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn write_quick_xml_optimized() { + use quick_xml_optimized::{AnimalDyn, AnimalType, DogType, LabradorType, List}; + + let obj = List { + animal: vec![ + AnimalType::Animal(AnimalDyn { id: 1 }), + AnimalType::Dog(DogType { + id: 2, + name: "Rex".into(), + }), + AnimalType::Labrador(LabradorType { + id: 3, + name: "Buddy".into(), + color: "black".into(), + }), + ], + }; + + crate::utils::quick_xml_write_test( + &obj, + "list", + "tests/feature/dynamic_type/example/default.xml", + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod quick_xml_optimized { + #![allow(unused_imports)] + + include!("expected/quick_xml_optimized.rs"); +} diff --git a/xsd-parser/tests/feature/dynamic_type/schema.xsd b/xsd-parser/tests/feature/dynamic_type/schema.xsd new file mode 100644 index 00000000..d5ebb37b --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type/schema.xsd @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group/example/default.xml b/xsd-parser/tests/feature/dynamic_type_substitution_group/example/default.xml new file mode 100644 index 00000000..6d5e7e2a --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group/example/default.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/default.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/default.rs new file mode 100644 index 00000000..5e16bc42 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/default.rs @@ -0,0 +1,44 @@ +use core::fmt::Debug; +use xsd_parser_types::AsAny; +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +#[derive(Debug)] +pub struct Animal(pub Box); +pub trait AnimalTrait: Debug + AsAny {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +#[derive(Debug)] +pub struct CatType { + pub id: i32, + pub breed: String, +} +impl AnimalTrait for CatType {} +#[derive(Debug)] +pub struct DogType(pub Box); +pub trait DogTypeTrait: Debug + AsAny {} +impl AnimalTrait for DogType {} +impl DogType { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl DogTypeTrait for LabradorType {} +#[derive(Debug)] +pub struct BeagleType { + pub id: i32, + pub name: String, + pub age: i32, +} +impl DogTypeTrait for BeagleType {} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/default_optimized.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/default_optimized.rs new file mode 100644 index 00000000..63f69442 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/default_optimized.rs @@ -0,0 +1,32 @@ +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +#[derive(Debug)] +pub enum Animal { + Cat(CatType), + Dog(DogType), +} +#[derive(Debug)] +pub struct CatType { + pub id: i32, + pub breed: String, +} +#[derive(Debug)] +pub enum DogType { + Labrador(LabradorType), + Beagle(BeagleType), +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +#[derive(Debug)] +pub struct BeagleType { + pub id: i32, + pub name: String, + pub age: i32, +} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/quick_xml.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/quick_xml.rs new file mode 100644 index 00000000..286d050b --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/quick_xml.rs @@ -0,0 +1,1029 @@ +use core::fmt::Debug; +use xsd_parser_types::{ + misc::{Namespace, NamespacePrefix}, + quick_xml::{ + BoxedSerializer, Error, WithBoxedSerializer, WithDeserializer, WithSerializer, + XsiTypeSerializer, + }, + AsAny, +}; +pub const NS_XS: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema"); +pub const NS_XML: Namespace = Namespace::new_const(b"http://www.w3.org/XML/1998/namespace"); +pub const NS_XSI: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema-instance"); +pub const NS_TNS: Namespace = Namespace::new_const(b"http://example.com"); +pub const PREFIX_XS: NamespacePrefix = NamespacePrefix::new_const(b"xs"); +pub const PREFIX_XML: NamespacePrefix = NamespacePrefix::new_const(b"xml"); +pub const PREFIX_XSI: NamespacePrefix = NamespacePrefix::new_const(b"xsi"); +pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns"); +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +impl WithSerializer for ListType { + type Serializer<'x> = quick_xml_serialize::ListTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::ListTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::ListTypeSerializerState::Init__), + name: name.unwrap_or("list"), + is_root, + }) + } +} +impl WithDeserializer for ListType { + type Deserializer = quick_xml_deserialize::ListTypeDeserializer; +} +#[derive(Debug)] +pub struct Animal(pub Box); +pub trait AnimalTrait: Debug + AsAny + WithBoxedSerializer {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +impl WithSerializer for Animal { + type Serializer<'x> = BoxedSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + if (*self.0).as_any().is::() { + return self.0.serializer(Some("cat"), is_root); + } + if (*self.0).as_any().is::() { + return self.0.serializer(Some("dog"), is_root); + } + self.0.serializer(None, is_root) + } +} +impl WithDeserializer for Animal { + type Deserializer = quick_xml_deserialize::AnimalDeserializer; +} +#[derive(Debug)] +pub struct CatType { + pub id: i32, + pub breed: String, +} +impl AnimalTrait for CatType {} +impl WithSerializer for CatType { + type Serializer<'x> = quick_xml_serialize::CatTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::CatTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::CatTypeSerializerState::Init__), + name: name.unwrap_or("cat"), + is_root, + }) + } +} +impl WithDeserializer for CatType { + type Deserializer = quick_xml_deserialize::CatTypeDeserializer; +} +#[derive(Debug)] +pub struct DogType(pub Box); +pub trait DogTypeTrait: Debug + AsAny + WithBoxedSerializer {} +impl AnimalTrait for DogType {} +impl DogType { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +impl WithSerializer for DogType { + type Serializer<'x> = BoxedSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + if (*self.0).as_any().is::() || (*self.0).as_any().is::() { + return Ok(Box::new(XsiTypeSerializer::new( + self.0.serializer(None, is_root)?, + name.unwrap_or("dog"), + is_root, + ))); + } + self.0.serializer(None, is_root) + } +} +impl WithDeserializer for DogType { + type Deserializer = quick_xml_deserialize::DogTypeDeserializer; +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl DogTypeTrait for LabradorType {} +impl WithSerializer for LabradorType { + type Serializer<'x> = quick_xml_serialize::LabradorTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::LabradorTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::LabradorTypeSerializerState::Init__), + name: name.unwrap_or("labrador"), + is_root, + }) + } +} +impl WithDeserializer for LabradorType { + type Deserializer = quick_xml_deserialize::LabradorTypeDeserializer; +} +#[derive(Debug)] +pub struct BeagleType { + pub id: i32, + pub name: String, + pub age: i32, +} +impl DogTypeTrait for BeagleType {} +impl WithSerializer for BeagleType { + type Serializer<'x> = quick_xml_serialize::BeagleTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::BeagleTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::BeagleTypeSerializerState::Init__), + name: name.unwrap_or("beagle"), + is_root, + }) + } +} +impl WithDeserializer for BeagleType { + type Deserializer = quick_xml_deserialize::BeagleTypeDeserializer; +} +pub mod quick_xml_deserialize { + use core::mem::replace; + use xsd_parser_types::quick_xml::{ + BytesStart, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent, + DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event, + QName, WithDeserializer, + }; + #[derive(Debug)] + pub struct ListTypeDeserializer { + animal: Vec, + state__: Box, + } + #[derive(Debug)] + enum ListTypeDeserializerState { + Init__, + Animal(Option<::Deserializer>), + Done__, + Unknown__, + } + impl ListTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + helper.raise_unexpected_attrib_checked(&attrib)?; + } + Ok(Self { + animal: Vec::new(), + state__: Box::new(ListTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: ListTypeDeserializerState, + ) -> Result<(), Error> { + use ListTypeDeserializerState as S; + match state { + S::Animal(Some(deserializer)) => self.store_animal(deserializer.finish(helper)?)?, + _ => (), + } + Ok(()) + } + fn store_animal(&mut self, value: super::Animal) -> Result<(), Error> { + self.animal.push(value); + Ok(()) + } + fn handle_animal<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::Animal>, + fallback: &mut Option, + ) -> Result, Error> { + use ListTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_animal(data)?; + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Animal(Some(deserializer))); + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::ListType> for ListTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + use ListTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Animal(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Animal(None); + event + } + (S::Animal(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = ::init(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, ListTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::ListType { + animal: self.animal, + }) + } + } + #[derive(Debug)] + pub enum AnimalDeserializer { + Cat(::Deserializer), + Dog(::Deserializer), + } + impl<'de> Deserializer<'de, super::Animal> for AnimalDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Animal> { + let Some(type_name) = helper.get_dynamic_type_from_tag(&event) else { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::None, + allow_any: false, + }); + }; + let type_name = type_name.into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"cat") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Cat(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"dog") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Dog(x)), + event, + allow_any, + }); + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + fn next( + self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Animal> { + match self { + Self::Cat(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Cat(x)), + event, + allow_any, + }) + } + Self::Dog(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Dog(x)), + event, + allow_any, + }) + } + } + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + match self { + Self::Cat(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + Self::Dog(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + } + } + } + #[derive(Debug)] + pub struct CatTypeDeserializer { + id: i32, + breed: String, + state__: Box, + } + #[derive(Debug)] + enum CatTypeDeserializerState { + Init__, + Unknown__, + } + impl CatTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut breed: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"breed") + ) { + helper.read_attrib(&mut breed, b"breed", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + breed: breed.ok_or_else(|| ErrorKind::MissingAttribute("breed".into()))?, + state__: Box::new(CatTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: CatTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::CatType> for CatTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CatType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CatType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, CatTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::CatType { + id: self.id, + breed: self.breed, + }) + } + } + #[derive(Debug)] + pub enum DogTypeDeserializer { + Labrador(::Deserializer), + Beagle(::Deserializer), + } + impl<'de> Deserializer<'de, super::DogType> for DogTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + let Some(type_name) = helper.get_dynamic_type_from_tag(&event) else { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::None, + allow_any: false, + }); + }; + let type_name = type_name.into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"dog") + ) { + if let Some(type_name) = helper.get_dynamic_type_from_attrib(&event)? { + let type_name = type_name.into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"labrador") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::DogType(Box::new(x)), |x| Self::Labrador(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"beagle") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::DogType(Box::new(x)), |x| Self::Beagle(x)), + event, + allow_any, + }); + } + } + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + fn next( + self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + match self { + Self::Labrador(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::DogType(Box::new(x)), |x| Self::Labrador(x)), + event, + allow_any, + }) + } + Self::Beagle(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::DogType(Box::new(x)), |x| Self::Beagle(x)), + event, + allow_any, + }) + } + } + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + match self { + Self::Labrador(x) => Ok(super::DogType(Box::new(x.finish(helper)?))), + Self::Beagle(x) => Ok(super::DogType(Box::new(x.finish(helper)?))), + } + } + } + #[derive(Debug)] + pub struct LabradorTypeDeserializer { + id: i32, + name: String, + color: String, + state__: Box, + } + #[derive(Debug)] + enum LabradorTypeDeserializerState { + Init__, + Unknown__, + } + impl LabradorTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + let mut color: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"color") + ) { + helper.read_attrib(&mut color, b"color", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + color: color.ok_or_else(|| ErrorKind::MissingAttribute("color".into()))?, + state__: Box::new(LabradorTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: LabradorTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::LabradorType> for LabradorTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, LabradorTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::LabradorType { + id: self.id, + name: self.name, + color: self.color, + }) + } + } + #[derive(Debug)] + pub struct BeagleTypeDeserializer { + id: i32, + name: String, + age: i32, + state__: Box, + } + #[derive(Debug)] + enum BeagleTypeDeserializerState { + Init__, + Unknown__, + } + impl BeagleTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + let mut age: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"age") + ) { + helper.read_attrib(&mut age, b"age", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + age: age.ok_or_else(|| ErrorKind::MissingAttribute("age".into()))?, + state__: Box::new(BeagleTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: BeagleTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::BeagleType> for BeagleTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::BeagleType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::BeagleType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, BeagleTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::BeagleType { + id: self.id, + name: self.name, + age: self.age, + }) + } + } +} +pub mod quick_xml_serialize { + use xsd_parser_types::quick_xml::{ + BytesEnd, BytesStart, Error, Event, IterSerializer, SerializeHelper, Serializer, + }; + #[derive(Debug)] + pub struct ListTypeSerializer<'ser> { + pub(super) value: &'ser super::ListType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum ListTypeSerializerState<'ser> { + Init__, + Animal(IterSerializer<'ser, &'ser [super::Animal], super::Animal>), + End__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> ListTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + ListTypeSerializerState::Init__ => { + *self.state = ListTypeSerializerState::Animal(IterSerializer::new( + &self.value.animal[..], + Some("animal"), + false, + )); + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + helper.write_xmlns( + &mut bytes, + Some(&super::PREFIX_XSI), + &super::NS_XSI, + ); + } + return Ok(Some(Event::Start(bytes))); + } + ListTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = ListTypeSerializerState::End__, + }, + ListTypeSerializerState::End__ => { + *self.state = ListTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); + } + ListTypeSerializerState::Done__ => return Ok(None), + ListTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for ListTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = ListTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct CatTypeSerializer<'ser> { + pub(super) value: &'ser super::CatType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum CatTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> CatTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + CatTypeSerializerState::Init__ => { + *self.state = CatTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "breed", &self.value.breed)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + CatTypeSerializerState::Done__ => return Ok(None), + CatTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for CatTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = CatTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct LabradorTypeSerializer<'ser> { + pub(super) value: &'ser super::LabradorType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum LabradorTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> LabradorTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + LabradorTypeSerializerState::Init__ => { + *self.state = LabradorTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "color", &self.value.color)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + LabradorTypeSerializerState::Done__ => return Ok(None), + LabradorTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for LabradorTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = LabradorTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct BeagleTypeSerializer<'ser> { + pub(super) value: &'ser super::BeagleType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum BeagleTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> BeagleTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + BeagleTypeSerializerState::Init__ => { + *self.state = BeagleTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "age", &self.value.age)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + BeagleTypeSerializerState::Done__ => return Ok(None), + BeagleTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for BeagleTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = BeagleTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } +} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/quick_xml_optimized.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/quick_xml_optimized.rs new file mode 100644 index 00000000..95b564a8 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group/expected/quick_xml_optimized.rs @@ -0,0 +1,1525 @@ +use xsd_parser_types::{ + misc::{Namespace, NamespacePrefix}, + quick_xml::{Error, WithDeserializer, WithSerializer}, +}; +pub const NS_XS: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema"); +pub const NS_XML: Namespace = Namespace::new_const(b"http://www.w3.org/XML/1998/namespace"); +pub const NS_XSI: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema-instance"); +pub const NS_TNS: Namespace = Namespace::new_const(b"http://example.com"); +pub const PREFIX_XS: NamespacePrefix = NamespacePrefix::new_const(b"xs"); +pub const PREFIX_XML: NamespacePrefix = NamespacePrefix::new_const(b"xml"); +pub const PREFIX_XSI: NamespacePrefix = NamespacePrefix::new_const(b"xsi"); +pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns"); +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +impl WithSerializer for ListType { + type Serializer<'x> = quick_xml_serialize::ListTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::ListTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::ListTypeSerializerState::Init__), + name: name.unwrap_or("list"), + is_root, + }) + } +} +impl WithDeserializer for ListType { + type Deserializer = quick_xml_deserialize::ListTypeDeserializer; +} +#[derive(Debug)] +pub enum Animal { + Cat(CatType), + Dog(DogType), +} +impl WithSerializer for Animal { + type Serializer<'x> = quick_xml_serialize::AnimalSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + let _name = name; + Ok(quick_xml_serialize::AnimalSerializer { + value: self, + state: Box::new(quick_xml_serialize::AnimalSerializerState::Init__), + is_root, + }) + } +} +impl WithDeserializer for Animal { + type Deserializer = quick_xml_deserialize::AnimalDeserializer; +} +#[derive(Debug)] +pub struct CatType { + pub id: i32, + pub breed: String, +} +impl WithSerializer for CatType { + type Serializer<'x> = quick_xml_serialize::CatTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::CatTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::CatTypeSerializerState::Init__), + name: name.unwrap_or("cat"), + is_root, + }) + } +} +impl WithDeserializer for CatType { + type Deserializer = quick_xml_deserialize::CatTypeDeserializer; +} +#[derive(Debug)] +pub enum DogType { + Labrador(LabradorType), + Beagle(BeagleType), +} +impl WithSerializer for DogType { + type Serializer<'x> = quick_xml_serialize::DogTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + let _name = name; + Ok(quick_xml_serialize::DogTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::DogTypeSerializerState::Init__), + is_root, + }) + } +} +impl WithDeserializer for DogType { + type Deserializer = quick_xml_deserialize::DogTypeDeserializer; +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl WithSerializer for LabradorType { + type Serializer<'x> = quick_xml_serialize::LabradorTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::LabradorTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::LabradorTypeSerializerState::Init__), + name: name.unwrap_or("labrador"), + is_root, + }) + } +} +impl WithDeserializer for LabradorType { + type Deserializer = quick_xml_deserialize::LabradorTypeDeserializer; +} +#[derive(Debug)] +pub struct BeagleType { + pub id: i32, + pub name: String, + pub age: i32, +} +impl WithSerializer for BeagleType { + type Serializer<'x> = quick_xml_serialize::BeagleTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::BeagleTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::BeagleTypeSerializerState::Init__), + name: name.unwrap_or("beagle"), + is_root, + }) + } +} +impl WithDeserializer for BeagleType { + type Deserializer = quick_xml_deserialize::BeagleTypeDeserializer; +} +pub mod quick_xml_deserialize { + use core::mem::replace; + use xsd_parser_types::quick_xml::{ + BytesStart, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent, + DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event, + QName, RawByteStr, WithDeserializer, + }; + #[derive(Debug)] + pub struct ListTypeDeserializer { + animal: Vec, + state__: Box, + } + #[derive(Debug)] + enum ListTypeDeserializerState { + Init__, + Animal(Option<::Deserializer>), + Done__, + Unknown__, + } + impl ListTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + helper.raise_unexpected_attrib_checked(&attrib)?; + } + Ok(Self { + animal: Vec::new(), + state__: Box::new(ListTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: ListTypeDeserializerState, + ) -> Result<(), Error> { + use ListTypeDeserializerState as S; + match state { + S::Animal(Some(deserializer)) => self.store_animal(deserializer.finish(helper)?)?, + _ => (), + } + Ok(()) + } + fn store_animal(&mut self, value: super::Animal) -> Result<(), Error> { + self.animal.push(value); + Ok(()) + } + fn handle_animal<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::Animal>, + fallback: &mut Option, + ) -> Result, Error> { + use ListTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_animal(data)?; + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Animal(Some(deserializer))); + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::ListType> for ListTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + use ListTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Animal(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Animal(None); + event + } + (S::Animal(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = ::init(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, ListTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::ListType { + animal: self.animal, + }) + } + } + #[derive(Debug)] + pub struct AnimalDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum AnimalDeserializerState { + Init__, + Cat( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Dog( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::Animal), + Unknown__, + } + impl AnimalDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + let mut event = event; + let mut allow_any_element = false; + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::NS_TNS), + Some(b"cat") + ) { + let output = ::init(helper, event)?; + return self.handle_cat(helper, Default::default(), None, output); + } + event = { + let output = ::init(helper, event)?; + match self.handle_dog(helper, Default::default(), None, output)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + output => { + return Ok(output); + } + } + }; + } + *self.state__ = AnimalDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent( + event, + allow_any_element, + )) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: AnimalDeserializerState, + ) -> Result { + use AnimalDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Cat(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_cat(&mut values, value)?; + } + Ok(super::Animal::Cat(helper.finish_element("cat", values)?)) + } + S::Dog(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_dog(&mut values, value)?; + } + Ok(super::Animal::Dog(helper.finish_element("dog", values)?)) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_cat( + values: &mut Option, + value: super::CatType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"cat")))?; + } + *values = Some(value); + Ok(()) + } + fn store_dog( + values: &mut Option, + value: super::DogType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"dog")))?; + } + *values = Some(value); + Ok(()) + } + fn handle_cat<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CatType>, + ) -> Result, Error> { + use AnimalDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_cat(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_cat(&mut values, data)?; + let data = Self::finish_state(helper, S::Cat(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Cat(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_dog<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::DogType>, + ) -> Result, Error> { + use AnimalDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_dog(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_dog(&mut values, data)?; + let data = Self::finish_state(helper, S::Dog(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Dog(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::Animal> for AnimalDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Animal> { + let deserializer = Self { + state__: Box::new(AnimalDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, AnimalDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Animal> { + use AnimalDeserializerState as S; + let mut event = event; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Cat(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_cat(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Dog(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_dog(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state, event @ Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Cat(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_TNS), + b"cat", + false, + )?; + match self.handle_cat(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Dog(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = ::init(helper, event)?; + match self.handle_dog(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + } + }; + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + Self::finish_state(helper, *self.state__) + } + } + #[derive(Debug)] + pub struct CatTypeDeserializer { + id: i32, + breed: String, + state__: Box, + } + #[derive(Debug)] + enum CatTypeDeserializerState { + Init__, + Unknown__, + } + impl CatTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut breed: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"breed") + ) { + helper.read_attrib(&mut breed, b"breed", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + breed: breed.ok_or_else(|| ErrorKind::MissingAttribute("breed".into()))?, + state__: Box::new(CatTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: CatTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::CatType> for CatTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CatType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CatType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, CatTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::CatType { + id: self.id, + breed: self.breed, + }) + } + } + #[derive(Debug)] + pub struct DogTypeDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum DogTypeDeserializerState { + Init__, + Labrador( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Beagle( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::DogType), + Unknown__, + } + impl DogTypeDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::NS_TNS), + Some(b"dog") + ) { + if let Some(type_name) = helper.get_dynamic_type_from_attrib_bytes(x)? { + let type_name = type_name.into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"labrador") + ) { + let output = + ::init(helper, event)?; + return self.handle_labrador(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"beagle") + ) { + let output = + ::init(helper, event)?; + return self.handle_beagle(helper, Default::default(), None, output); + } + } + } + } + *self.state__ = DogTypeDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: DogTypeDeserializerState, + ) -> Result { + use DogTypeDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Labrador(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_labrador(&mut values, value)?; + } + Ok(super::DogType::Labrador( + helper.finish_element("labrador", values)?, + )) + } + S::Beagle(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_beagle(&mut values, value)?; + } + Ok(super::DogType::Beagle( + helper.finish_element("beagle", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_labrador( + values: &mut Option, + value: super::LabradorType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"labrador", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_beagle( + values: &mut Option, + value: super::BeagleType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"beagle", + )))?; + } + *values = Some(value); + Ok(()) + } + fn handle_labrador<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LabradorType>, + ) -> Result, Error> { + use DogTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_labrador(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_labrador(&mut values, data)?; + let data = Self::finish_state(helper, S::Labrador(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Labrador(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_beagle<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::BeagleType>, + ) -> Result, Error> { + use DogTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_beagle(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_beagle(&mut values, data)?; + let data = Self::finish_state(helper, S::Beagle(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Beagle(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::DogType> for DogTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + let deserializer = Self { + state__: Box::new(DogTypeDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, DogTypeDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + use DogTypeDeserializerState as S; + let mut event = event; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Labrador(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_labrador(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Beagle(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_beagle(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state, event @ Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Labrador(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_TNS), + b"labrador", + false, + )?; + match self.handle_labrador(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Beagle(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_TNS), + b"beagle", + false, + )?; + match self.handle_beagle(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + } + }; + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + Self::finish_state(helper, *self.state__) + } + } + #[derive(Debug)] + pub struct LabradorTypeDeserializer { + id: i32, + name: String, + color: String, + state__: Box, + } + #[derive(Debug)] + enum LabradorTypeDeserializerState { + Init__, + Unknown__, + } + impl LabradorTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + let mut color: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"color") + ) { + helper.read_attrib(&mut color, b"color", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + color: color.ok_or_else(|| ErrorKind::MissingAttribute("color".into()))?, + state__: Box::new(LabradorTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: LabradorTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::LabradorType> for LabradorTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, LabradorTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::LabradorType { + id: self.id, + name: self.name, + color: self.color, + }) + } + } + #[derive(Debug)] + pub struct BeagleTypeDeserializer { + id: i32, + name: String, + age: i32, + state__: Box, + } + #[derive(Debug)] + enum BeagleTypeDeserializerState { + Init__, + Unknown__, + } + impl BeagleTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + let mut age: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"age") + ) { + helper.read_attrib(&mut age, b"age", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + age: age.ok_or_else(|| ErrorKind::MissingAttribute("age".into()))?, + state__: Box::new(BeagleTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: BeagleTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::BeagleType> for BeagleTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::BeagleType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::BeagleType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, BeagleTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::BeagleType { + id: self.id, + name: self.name, + age: self.age, + }) + } + } +} +pub mod quick_xml_serialize { + use xsd_parser_types::quick_xml::{ + BytesEnd, BytesStart, Error, Event, IterSerializer, SerializeHelper, Serializer, + WithSerializer, XsiTypeSerializer, + }; + #[derive(Debug)] + pub struct ListTypeSerializer<'ser> { + pub(super) value: &'ser super::ListType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum ListTypeSerializerState<'ser> { + Init__, + Animal(IterSerializer<'ser, &'ser [super::Animal], super::Animal>), + End__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> ListTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + ListTypeSerializerState::Init__ => { + *self.state = ListTypeSerializerState::Animal(IterSerializer::new( + &self.value.animal[..], + Some("animal"), + false, + )); + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + helper.write_xmlns( + &mut bytes, + Some(&super::PREFIX_XSI), + &super::NS_XSI, + ); + } + return Ok(Some(Event::Start(bytes))); + } + ListTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = ListTypeSerializerState::End__, + }, + ListTypeSerializerState::End__ => { + *self.state = ListTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); + } + ListTypeSerializerState::Done__ => return Ok(None), + ListTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for ListTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = ListTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct AnimalSerializer<'ser> { + pub(super) value: &'ser super::Animal, + pub(super) state: Box>, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum AnimalSerializerState<'ser> { + Init__, + Cat(::Serializer<'ser>), + Dog(::Serializer<'ser>), + Done__, + Phantom__(&'ser ()), + } + impl<'ser> AnimalSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + AnimalSerializerState::Init__ => { + match self.value { + super::Animal::Cat(x) => { + *self.state = AnimalSerializerState::Cat( + WithSerializer::serializer(x, Some("cat"), self.is_root)?, + ) + } + super::Animal::Dog(x) => { + *self.state = AnimalSerializerState::Dog( + WithSerializer::serializer(x, Some("dog"), self.is_root)?, + ) + } + } + } + AnimalSerializerState::Cat(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AnimalSerializerState::Done__, + }, + AnimalSerializerState::Dog(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AnimalSerializerState::Done__, + }, + AnimalSerializerState::Done__ => return Ok(None), + AnimalSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for AnimalSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = AnimalSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct CatTypeSerializer<'ser> { + pub(super) value: &'ser super::CatType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum CatTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> CatTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + CatTypeSerializerState::Init__ => { + *self.state = CatTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "breed", &self.value.breed)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + CatTypeSerializerState::Done__ => return Ok(None), + CatTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for CatTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = CatTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct DogTypeSerializer<'ser> { + pub(super) value: &'ser super::DogType, + pub(super) state: Box>, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum DogTypeSerializerState<'ser> { + Init__, + Labrador( + XsiTypeSerializer<'ser, ::Serializer<'ser>>, + ), + Beagle(XsiTypeSerializer<'ser, ::Serializer<'ser>>), + Done__, + Phantom__(&'ser ()), + } + impl<'ser> DogTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + DogTypeSerializerState::Init__ => match self.value { + super::DogType::Labrador(x) => { + *self.state = DogTypeSerializerState::Labrador(XsiTypeSerializer::new( + WithSerializer::serializer(x, Some("labrador"), self.is_root)?, + "dog", + self.is_root, + )) + } + super::DogType::Beagle(x) => { + *self.state = DogTypeSerializerState::Beagle(XsiTypeSerializer::new( + WithSerializer::serializer(x, Some("beagle"), self.is_root)?, + "dog", + self.is_root, + )) + } + }, + DogTypeSerializerState::Labrador(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = DogTypeSerializerState::Done__, + }, + DogTypeSerializerState::Beagle(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = DogTypeSerializerState::Done__, + }, + DogTypeSerializerState::Done__ => return Ok(None), + DogTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for DogTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = DogTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct LabradorTypeSerializer<'ser> { + pub(super) value: &'ser super::LabradorType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum LabradorTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> LabradorTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + LabradorTypeSerializerState::Init__ => { + *self.state = LabradorTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "color", &self.value.color)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + LabradorTypeSerializerState::Done__ => return Ok(None), + LabradorTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for LabradorTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = LabradorTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct BeagleTypeSerializer<'ser> { + pub(super) value: &'ser super::BeagleType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum BeagleTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> BeagleTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + BeagleTypeSerializerState::Init__ => { + *self.state = BeagleTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "age", &self.value.age)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + BeagleTypeSerializerState::Done__ => return Ok(None), + BeagleTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for BeagleTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = BeagleTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } +} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group/mod.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group/mod.rs new file mode 100644 index 00000000..3ac51b47 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group/mod.rs @@ -0,0 +1,219 @@ +use xsd_parser::{ + config::{GeneratorFlags, OptimizerFlags}, + Config, IdentType, +}; + +use crate::utils::{generate_test, ConfigEx}; + +fn config() -> Config { + Config::test_default() + .with_derive(["Debug"]) + .with_generator_flags(GeneratorFlags::FLATTEN_CONTENT) + .with_generate([(IdentType::Element, "tns:list")]) +} + +/* default */ + +#[test] +fn generate_default() { + generate_test( + "tests/feature/dynamic_type_substitution_group/schema.xsd", + "tests/feature/dynamic_type_substitution_group/expected/default.rs", + config(), + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod default { + #![allow(unused_imports)] + + include!("expected/default.rs"); +} + +/* default (optimized) */ + +#[test] +fn generate_default_optimized() { + generate_test( + "tests/feature/dynamic_type_substitution_group/schema.xsd", + "tests/feature/dynamic_type_substitution_group/expected/default_optimized.rs", + config().with_optimizer_flags(OptimizerFlags::all()), + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod default_optmized { + #![allow(unused_imports)] + + include!("expected/default_optimized.rs"); +} + +/* quick_xml */ + +#[test] +fn generate_quick_xml() { + generate_test( + "tests/feature/dynamic_type_substitution_group/schema.xsd", + "tests/feature/dynamic_type_substitution_group/expected/quick_xml.rs", + config().with_quick_xml(), + ); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn read_quick_xml() { + use quick_xml::{BeagleType, CatType, DogType, LabradorType, List}; + + let obj = crate::utils::quick_xml_read_test::( + "tests/feature/dynamic_type_substitution_group/example/default.xml", + ); + + let mut items = obj.animal.iter(); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 1); + assert_eq!(item.breed, "Bengal"); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 2); + assert_eq!(item.name, "Buddy"); + assert_eq!(item.color, "black"); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 3); + assert_eq!(item.name, "Max"); + assert_eq!(item.age, 3); + + assert!(items.next().is_none()); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn write_quick_xml() { + use quick_xml::{Animal, BeagleType, CatType, DogType, LabradorType, List}; + + let obj = List { + animal: vec![ + Animal::new(CatType { + id: 1, + breed: "Bengal".into(), + }), + Animal::new(DogType::new(LabradorType { + id: 2, + name: "Buddy".into(), + color: "black".into(), + })), + Animal::new(DogType::new(BeagleType { + id: 3, + name: "Max".into(), + age: 3, + })), + ], + }; + + crate::utils::quick_xml_write_test( + &obj, + "list", + "tests/feature/dynamic_type_substitution_group/example/default.xml", + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod quick_xml { + #![allow(unused_imports)] + + include!("expected/quick_xml.rs"); +} + +/* quick_xml (optimized) */ + +#[test] +fn generate_quick_xml_optimized() { + generate_test( + "tests/feature/dynamic_type_substitution_group/schema.xsd", + "tests/feature/dynamic_type_substitution_group/expected/quick_xml_optimized.rs", + config() + .with_quick_xml() + .with_optimizer_flags(OptimizerFlags::all()), + ); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn read_quick_xml_optimized() { + use quick_xml_optimized::{Animal, DogType, List}; + + let obj = crate::utils::quick_xml_read_test::( + "tests/feature/dynamic_type_substitution_group/example/default.xml", + ); + + let mut items = obj.animal.into_iter(); + + let item = items.next().unwrap(); + let Animal::Cat(item) = item else { + panic!("Expected `Animal::Cat`"); + }; + assert_eq!(item.id, 1); + assert_eq!(item.breed, "Bengal"); + + let item = items.next().unwrap(); + let Animal::Dog(DogType::Labrador(item)) = item else { + panic!("Expected `Animal::Dog(DogType::Labrador)`"); + }; + assert_eq!(item.id, 2); + assert_eq!(item.name, "Buddy"); + assert_eq!(item.color, "black"); + + let item = items.next().unwrap(); + let Animal::Dog(DogType::Beagle(item)) = item else { + panic!("Expected `Animal::Dog(DogType::Beagle)`"); + }; + assert_eq!(item.id, 3); + assert_eq!(item.name, "Max"); + assert_eq!(item.age, 3); + + assert!(items.next().is_none()); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn write_quick_xml_optimized() { + use quick_xml_optimized::{Animal, BeagleType, CatType, DogType, LabradorType, List}; + + let obj = List { + animal: vec![ + Animal::Cat(CatType { + id: 1, + breed: "Bengal".into(), + }), + Animal::Dog(DogType::Labrador(LabradorType { + id: 2, + name: "Buddy".into(), + color: "black".into(), + })), + Animal::Dog(DogType::Beagle(BeagleType { + id: 3, + name: "Max".into(), + age: 3, + })), + ], + }; + + crate::utils::quick_xml_write_test( + &obj, + "list", + "tests/feature/dynamic_type_substitution_group/example/default.xml", + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod quick_xml_optimized { + #![allow(unused_imports)] + + include!("expected/quick_xml_optimized.rs"); +} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group/schema.xsd b/xsd-parser/tests/feature/dynamic_type_substitution_group/schema.xsd new file mode 100644 index 00000000..ee93c57a --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group/schema.xsd @@ -0,0 +1,54 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default.xml b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default.xml new file mode 100644 index 00000000..ad27fdd0 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default.xml @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default_flatten.xml b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default_flatten.xml new file mode 100644 index 00000000..2c33f1b6 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default_flatten.xml @@ -0,0 +1,7 @@ + + + + + + + diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default_optimized.xml b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default_optimized.xml new file mode 100644 index 00000000..2c33f1b6 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/example/default_optimized.xml @@ -0,0 +1,7 @@ + + + + + + + diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default.rs new file mode 100644 index 00000000..17e31cc0 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default.rs @@ -0,0 +1,44 @@ +use core::fmt::Debug; +use xsd_parser_types::AsAny; +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +#[derive(Debug)] +pub struct Animal(pub Box); +pub trait AnimalTrait: Debug + AsAny {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +#[derive(Debug)] +pub struct AnimalType(pub Box); +pub trait AnimalTypeTrait: Debug + AsAny {} +impl AnimalTrait for AnimalType {} +impl AnimalType { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +impl AnimalTypeTrait for DogType {} +impl AnimalTrait for DogType {} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl AnimalTypeTrait for LabradorType {} +impl AnimalTrait for LabradorType {} +#[derive(Debug)] +pub struct AnimalDyn { + pub id: i32, +} +impl AnimalTypeTrait for AnimalDyn {} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default_flatten.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default_flatten.rs new file mode 100644 index 00000000..8a508324 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default_flatten.rs @@ -0,0 +1,33 @@ +use core::fmt::Debug; +use xsd_parser_types::AsAny; +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +#[derive(Debug)] +pub struct Animal(pub Box); +pub trait AnimalTrait: Debug + AsAny {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +#[derive(Debug)] +pub struct AnimalDyn { + pub id: i32, +} +impl AnimalTrait for AnimalDyn {} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +impl AnimalTrait for DogType {} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl AnimalTrait for LabradorType {} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default_optimized.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default_optimized.rs new file mode 100644 index 00000000..2e85d42a --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/default_optimized.rs @@ -0,0 +1,26 @@ +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +#[derive(Debug)] +pub enum Animal { + Animal(AnimalDyn), + Dog(DogType), + Labrador(LabradorType), +} +#[derive(Debug)] +pub struct AnimalDyn { + pub id: i32, +} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml.rs new file mode 100644 index 00000000..2880bbb3 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml.rs @@ -0,0 +1,1073 @@ +use core::fmt::Debug; +use xsd_parser_types::{ + misc::{Namespace, NamespacePrefix}, + quick_xml::{ + BoxedSerializer, Error, WithBoxedSerializer, WithDeserializer, WithSerializer, + XsiTypeSerializer, + }, + AsAny, +}; +pub const NS_XS: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema"); +pub const NS_XML: Namespace = Namespace::new_const(b"http://www.w3.org/XML/1998/namespace"); +pub const NS_XSI: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema-instance"); +pub const NS_TNS: Namespace = Namespace::new_const(b"http://example.com"); +pub const PREFIX_XS: NamespacePrefix = NamespacePrefix::new_const(b"xs"); +pub const PREFIX_XML: NamespacePrefix = NamespacePrefix::new_const(b"xml"); +pub const PREFIX_XSI: NamespacePrefix = NamespacePrefix::new_const(b"xsi"); +pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns"); +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +impl WithSerializer for ListType { + type Serializer<'x> = quick_xml_serialize::ListTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::ListTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::ListTypeSerializerState::Init__), + name: name.unwrap_or("list"), + is_root, + }) + } +} +impl WithDeserializer for ListType { + type Deserializer = quick_xml_deserialize::ListTypeDeserializer; +} +#[derive(Debug)] +pub struct Animal(pub Box); +pub trait AnimalTrait: Debug + AsAny + WithBoxedSerializer {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +impl WithSerializer for Animal { + type Serializer<'x> = BoxedSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + if (*self.0).as_any().is::() { + return self.0.serializer(Some("animal"), is_root); + } + if (*self.0).as_any().is::() { + return self.0.serializer(Some("dog"), is_root); + } + if (*self.0).as_any().is::() { + return self.0.serializer(Some("labrador"), is_root); + } + self.0.serializer(None, is_root) + } +} +impl WithDeserializer for Animal { + type Deserializer = quick_xml_deserialize::AnimalDeserializer; +} +#[derive(Debug)] +pub struct AnimalType(pub Box); +pub trait AnimalTypeTrait: Debug + AsAny + WithBoxedSerializer {} +impl AnimalTrait for AnimalType {} +impl AnimalType { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +impl WithSerializer for AnimalType { + type Serializer<'x> = BoxedSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + if (*self.0).as_any().is::() || (*self.0).as_any().is::() { + return Ok(Box::new(XsiTypeSerializer::new( + self.0.serializer(None, is_root)?, + name.unwrap_or("animal"), + is_root, + ))); + } + self.0.serializer(None, is_root) + } +} +impl WithDeserializer for AnimalType { + type Deserializer = quick_xml_deserialize::AnimalTypeDeserializer; +} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +impl AnimalTypeTrait for DogType {} +impl AnimalTrait for DogType {} +impl WithSerializer for DogType { + type Serializer<'x> = quick_xml_serialize::DogTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::DogTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::DogTypeSerializerState::Init__), + name: name.unwrap_or("dog"), + is_root, + }) + } +} +impl WithDeserializer for DogType { + type Deserializer = quick_xml_deserialize::DogTypeDeserializer; +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl AnimalTypeTrait for LabradorType {} +impl AnimalTrait for LabradorType {} +impl WithSerializer for LabradorType { + type Serializer<'x> = quick_xml_serialize::LabradorTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::LabradorTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::LabradorTypeSerializerState::Init__), + name: name.unwrap_or("labrador"), + is_root, + }) + } +} +impl WithDeserializer for LabradorType { + type Deserializer = quick_xml_deserialize::LabradorTypeDeserializer; +} +#[derive(Debug)] +pub struct AnimalDyn { + pub id: i32, +} +impl AnimalTypeTrait for AnimalDyn {} +impl WithSerializer for AnimalDyn { + type Serializer<'x> = quick_xml_serialize::AnimalDynSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::AnimalDynSerializer { + value: self, + state: Box::new(quick_xml_serialize::AnimalDynSerializerState::Init__), + name: name.unwrap_or("animal"), + is_root, + }) + } +} +impl WithDeserializer for AnimalDyn { + type Deserializer = quick_xml_deserialize::AnimalDynDeserializer; +} +pub mod quick_xml_deserialize { + use core::mem::replace; + use std::borrow::Cow; + use xsd_parser_types::quick_xml::{ + BytesStart, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent, + DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event, + QName, WithDeserializer, + }; + #[derive(Debug)] + pub struct ListTypeDeserializer { + animal: Vec, + state__: Box, + } + #[derive(Debug)] + enum ListTypeDeserializerState { + Init__, + Animal(Option<::Deserializer>), + Done__, + Unknown__, + } + impl ListTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + helper.raise_unexpected_attrib_checked(&attrib)?; + } + Ok(Self { + animal: Vec::new(), + state__: Box::new(ListTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: ListTypeDeserializerState, + ) -> Result<(), Error> { + use ListTypeDeserializerState as S; + match state { + S::Animal(Some(deserializer)) => self.store_animal(deserializer.finish(helper)?)?, + _ => (), + } + Ok(()) + } + fn store_animal(&mut self, value: super::Animal) -> Result<(), Error> { + self.animal.push(value); + Ok(()) + } + fn handle_animal<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::Animal>, + fallback: &mut Option, + ) -> Result, Error> { + use ListTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_animal(data)?; + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Animal(Some(deserializer))); + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::ListType> for ListTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + use ListTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Animal(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Animal(None); + event + } + (S::Animal(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = ::init(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, ListTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::ListType { + animal: self.animal, + }) + } + } + #[derive(Debug)] + pub enum AnimalDeserializer { + Animal(::Deserializer), + Dog(::Deserializer), + Labrador(::Deserializer), + } + impl<'de> Deserializer<'de, super::Animal> for AnimalDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Animal> { + let Some(type_name) = helper.get_dynamic_type_from_tag(&event) else { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::None, + allow_any: false, + }); + }; + let type_name = type_name.into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"animal") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"dog") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Dog(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"labrador") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Labrador(x)), + event, + allow_any, + }); + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + fn next( + self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Animal> { + match self { + Self::Animal(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }) + } + Self::Dog(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Dog(x)), + event, + allow_any, + }) + } + Self::Labrador(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::Animal(Box::new(x)), |x| Self::Labrador(x)), + event, + allow_any, + }) + } + } + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + match self { + Self::Animal(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + Self::Dog(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + Self::Labrador(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + } + } + } + #[derive(Debug)] + pub enum AnimalTypeDeserializer { + Animal(::Deserializer), + Dog(::Deserializer), + Labrador(::Deserializer), + } + impl<'de> Deserializer<'de, super::AnimalType> for AnimalTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalType> { + let Some(type_name) = helper.get_dynamic_type_from_tag(&event) else { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::None, + allow_any: false, + }); + }; + let type_name = type_name.into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"animal") + ) { + let type_name = helper + .get_dynamic_type_from_attrib(&event)? + .unwrap_or(Cow::Borrowed(b"animal")) + .into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"animal") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"dog") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Dog(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"labrador") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Labrador(x)), + event, + allow_any, + }); + } + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + fn next( + self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalType> { + match self { + Self::Animal(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }) + } + Self::Dog(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Dog(x)), + event, + allow_any, + }) + } + Self::Labrador(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::AnimalType(Box::new(x)), |x| Self::Labrador(x)), + event, + allow_any, + }) + } + } + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + match self { + Self::Animal(x) => Ok(super::AnimalType(Box::new(x.finish(helper)?))), + Self::Dog(x) => Ok(super::AnimalType(Box::new(x.finish(helper)?))), + Self::Labrador(x) => Ok(super::AnimalType(Box::new(x.finish(helper)?))), + } + } + } + #[derive(Debug)] + pub struct DogTypeDeserializer { + id: i32, + name: String, + state__: Box, + } + #[derive(Debug)] + enum DogTypeDeserializerState { + Init__, + Unknown__, + } + impl DogTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + state__: Box::new(DogTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: DogTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::DogType> for DogTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, DogTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::DogType { + id: self.id, + name: self.name, + }) + } + } + #[derive(Debug)] + pub struct LabradorTypeDeserializer { + id: i32, + name: String, + color: String, + state__: Box, + } + #[derive(Debug)] + enum LabradorTypeDeserializerState { + Init__, + Unknown__, + } + impl LabradorTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + let mut color: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"color") + ) { + helper.read_attrib(&mut color, b"color", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + color: color.ok_or_else(|| ErrorKind::MissingAttribute("color".into()))?, + state__: Box::new(LabradorTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: LabradorTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::LabradorType> for LabradorTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, LabradorTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::LabradorType { + id: self.id, + name: self.name, + color: self.color, + }) + } + } + #[derive(Debug)] + pub struct AnimalDynDeserializer { + id: i32, + state__: Box, + } + #[derive(Debug)] + enum AnimalDynDeserializerState { + Init__, + Unknown__, + } + impl AnimalDynDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + state__: Box::new(AnimalDynDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: AnimalDynDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::AnimalDyn> for AnimalDynDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalDyn> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalDyn> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, AnimalDynDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::AnimalDyn { id: self.id }) + } + } +} +pub mod quick_xml_serialize { + use xsd_parser_types::quick_xml::{ + BytesEnd, BytesStart, Error, Event, IterSerializer, SerializeHelper, Serializer, + }; + #[derive(Debug)] + pub struct ListTypeSerializer<'ser> { + pub(super) value: &'ser super::ListType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum ListTypeSerializerState<'ser> { + Init__, + Animal(IterSerializer<'ser, &'ser [super::Animal], super::Animal>), + End__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> ListTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + ListTypeSerializerState::Init__ => { + *self.state = ListTypeSerializerState::Animal(IterSerializer::new( + &self.value.animal[..], + Some("animal"), + false, + )); + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + helper.write_xmlns( + &mut bytes, + Some(&super::PREFIX_XSI), + &super::NS_XSI, + ); + } + return Ok(Some(Event::Start(bytes))); + } + ListTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = ListTypeSerializerState::End__, + }, + ListTypeSerializerState::End__ => { + *self.state = ListTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); + } + ListTypeSerializerState::Done__ => return Ok(None), + ListTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for ListTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = ListTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct DogTypeSerializer<'ser> { + pub(super) value: &'ser super::DogType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum DogTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> DogTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + DogTypeSerializerState::Init__ => { + *self.state = DogTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + DogTypeSerializerState::Done__ => return Ok(None), + DogTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for DogTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = DogTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct LabradorTypeSerializer<'ser> { + pub(super) value: &'ser super::LabradorType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum LabradorTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> LabradorTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + LabradorTypeSerializerState::Init__ => { + *self.state = LabradorTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "color", &self.value.color)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + LabradorTypeSerializerState::Done__ => return Ok(None), + LabradorTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for LabradorTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = LabradorTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct AnimalDynSerializer<'ser> { + pub(super) value: &'ser super::AnimalDyn, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum AnimalDynSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> AnimalDynSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + AnimalDynSerializerState::Init__ => { + *self.state = AnimalDynSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + AnimalDynSerializerState::Done__ => return Ok(None), + AnimalDynSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for AnimalDynSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = AnimalDynSerializerState::Done__; + Some(Err(error)) + } + } + } + } +} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml_flatten.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml_flatten.rs new file mode 100644 index 00000000..63dbc532 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml_flatten.rs @@ -0,0 +1,934 @@ +use core::fmt::Debug; +use xsd_parser_types::{ + misc::{Namespace, NamespacePrefix}, + quick_xml::{BoxedSerializer, Error, WithBoxedSerializer, WithDeserializer, WithSerializer}, + AsAny, +}; +pub const NS_XS: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema"); +pub const NS_XML: Namespace = Namespace::new_const(b"http://www.w3.org/XML/1998/namespace"); +pub const NS_XSI: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema-instance"); +pub const NS_TNS: Namespace = Namespace::new_const(b"http://example.com"); +pub const PREFIX_XS: NamespacePrefix = NamespacePrefix::new_const(b"xs"); +pub const PREFIX_XML: NamespacePrefix = NamespacePrefix::new_const(b"xml"); +pub const PREFIX_XSI: NamespacePrefix = NamespacePrefix::new_const(b"xsi"); +pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns"); +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +impl WithSerializer for ListType { + type Serializer<'x> = quick_xml_serialize::ListTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::ListTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::ListTypeSerializerState::Init__), + name: name.unwrap_or("list"), + is_root, + }) + } +} +impl WithDeserializer for ListType { + type Deserializer = quick_xml_deserialize::ListTypeDeserializer; +} +#[derive(Debug)] +pub struct Animal(pub Box); +pub trait AnimalTrait: Debug + AsAny + WithBoxedSerializer {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +impl WithSerializer for Animal { + type Serializer<'x> = BoxedSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + if (*self.0).as_any().is::() { + return self.0.serializer(Some("dog"), is_root); + } + if (*self.0).as_any().is::() { + return self.0.serializer(Some("labrador"), is_root); + } + self.0.serializer(None, is_root) + } +} +impl WithDeserializer for Animal { + type Deserializer = quick_xml_deserialize::AnimalDeserializer; +} +#[derive(Debug)] +pub struct AnimalDyn { + pub id: i32, +} +impl AnimalTrait for AnimalDyn {} +impl WithSerializer for AnimalDyn { + type Serializer<'x> = quick_xml_serialize::AnimalDynSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::AnimalDynSerializer { + value: self, + state: Box::new(quick_xml_serialize::AnimalDynSerializerState::Init__), + name: name.unwrap_or("animal"), + is_root, + }) + } +} +impl WithDeserializer for AnimalDyn { + type Deserializer = quick_xml_deserialize::AnimalDynDeserializer; +} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +impl AnimalTrait for DogType {} +impl WithSerializer for DogType { + type Serializer<'x> = quick_xml_serialize::DogTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::DogTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::DogTypeSerializerState::Init__), + name: name.unwrap_or("dog"), + is_root, + }) + } +} +impl WithDeserializer for DogType { + type Deserializer = quick_xml_deserialize::DogTypeDeserializer; +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl AnimalTrait for LabradorType {} +impl WithSerializer for LabradorType { + type Serializer<'x> = quick_xml_serialize::LabradorTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::LabradorTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::LabradorTypeSerializerState::Init__), + name: name.unwrap_or("labrador"), + is_root, + }) + } +} +impl WithDeserializer for LabradorType { + type Deserializer = quick_xml_deserialize::LabradorTypeDeserializer; +} +pub mod quick_xml_deserialize { + use core::mem::replace; + use std::borrow::Cow; + use xsd_parser_types::quick_xml::{ + BytesStart, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent, + DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event, + QName, WithDeserializer, + }; + #[derive(Debug)] + pub struct ListTypeDeserializer { + animal: Vec, + state__: Box, + } + #[derive(Debug)] + enum ListTypeDeserializerState { + Init__, + Animal(Option<::Deserializer>), + Done__, + Unknown__, + } + impl ListTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + helper.raise_unexpected_attrib_checked(&attrib)?; + } + Ok(Self { + animal: Vec::new(), + state__: Box::new(ListTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: ListTypeDeserializerState, + ) -> Result<(), Error> { + use ListTypeDeserializerState as S; + match state { + S::Animal(Some(deserializer)) => self.store_animal(deserializer.finish(helper)?)?, + _ => (), + } + Ok(()) + } + fn store_animal(&mut self, value: super::Animal) -> Result<(), Error> { + self.animal.push(value); + Ok(()) + } + fn handle_animal<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::Animal>, + fallback: &mut Option, + ) -> Result, Error> { + use ListTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_animal(data)?; + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Animal(Some(deserializer))); + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::ListType> for ListTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + use ListTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Animal(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Animal(None); + event + } + (S::Animal(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = ::init(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, ListTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::ListType { + animal: self.animal, + }) + } + } + #[derive(Debug)] + pub enum AnimalDeserializer { + Animal(::Deserializer), + Dog(::Deserializer), + Labrador(::Deserializer), + } + impl<'de> Deserializer<'de, super::Animal> for AnimalDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Animal> { + let Some(type_name) = helper.get_dynamic_type_from_tag(&event) else { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::None, + allow_any: false, + }); + }; + let type_name = type_name.into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"animal") + ) { + let type_name = helper + .get_dynamic_type_from_attrib(&event)? + .unwrap_or(Cow::Borrowed(b"animal")) + .into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"animal") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"dog") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Dog(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"labrador") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::Animal(Box::new(x)), |x| Self::Labrador(x)), + event, + allow_any, + }); + } + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"dog") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Dog(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"labrador") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Labrador(x)), + event, + allow_any, + }); + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + fn next( + self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Animal> { + match self { + Self::Animal(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }) + } + Self::Dog(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Dog(x)), + event, + allow_any, + }) + } + Self::Labrador(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact + .map(|x| super::Animal(Box::new(x)), |x| Self::Labrador(x)), + event, + allow_any, + }) + } + } + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + match self { + Self::Animal(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + Self::Dog(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + Self::Labrador(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + } + } + } + #[derive(Debug)] + pub struct AnimalDynDeserializer { + id: i32, + state__: Box, + } + #[derive(Debug)] + enum AnimalDynDeserializerState { + Init__, + Unknown__, + } + impl AnimalDynDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + state__: Box::new(AnimalDynDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: AnimalDynDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::AnimalDyn> for AnimalDynDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalDyn> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalDyn> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, AnimalDynDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::AnimalDyn { id: self.id }) + } + } + #[derive(Debug)] + pub struct DogTypeDeserializer { + id: i32, + name: String, + state__: Box, + } + #[derive(Debug)] + enum DogTypeDeserializerState { + Init__, + Unknown__, + } + impl DogTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + state__: Box::new(DogTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: DogTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::DogType> for DogTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, DogTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::DogType { + id: self.id, + name: self.name, + }) + } + } + #[derive(Debug)] + pub struct LabradorTypeDeserializer { + id: i32, + name: String, + color: String, + state__: Box, + } + #[derive(Debug)] + enum LabradorTypeDeserializerState { + Init__, + Unknown__, + } + impl LabradorTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + let mut color: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"color") + ) { + helper.read_attrib(&mut color, b"color", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + color: color.ok_or_else(|| ErrorKind::MissingAttribute("color".into()))?, + state__: Box::new(LabradorTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: LabradorTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::LabradorType> for LabradorTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, LabradorTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::LabradorType { + id: self.id, + name: self.name, + color: self.color, + }) + } + } +} +pub mod quick_xml_serialize { + use xsd_parser_types::quick_xml::{ + BytesEnd, BytesStart, Error, Event, IterSerializer, SerializeHelper, Serializer, + }; + #[derive(Debug)] + pub struct ListTypeSerializer<'ser> { + pub(super) value: &'ser super::ListType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum ListTypeSerializerState<'ser> { + Init__, + Animal(IterSerializer<'ser, &'ser [super::Animal], super::Animal>), + End__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> ListTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + ListTypeSerializerState::Init__ => { + *self.state = ListTypeSerializerState::Animal(IterSerializer::new( + &self.value.animal[..], + Some("animal"), + false, + )); + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + return Ok(Some(Event::Start(bytes))); + } + ListTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = ListTypeSerializerState::End__, + }, + ListTypeSerializerState::End__ => { + *self.state = ListTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); + } + ListTypeSerializerState::Done__ => return Ok(None), + ListTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for ListTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = ListTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct AnimalDynSerializer<'ser> { + pub(super) value: &'ser super::AnimalDyn, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum AnimalDynSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> AnimalDynSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + AnimalDynSerializerState::Init__ => { + *self.state = AnimalDynSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + AnimalDynSerializerState::Done__ => return Ok(None), + AnimalDynSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for AnimalDynSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = AnimalDynSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct DogTypeSerializer<'ser> { + pub(super) value: &'ser super::DogType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum DogTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> DogTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + DogTypeSerializerState::Init__ => { + *self.state = DogTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + DogTypeSerializerState::Done__ => return Ok(None), + DogTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for DogTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = DogTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct LabradorTypeSerializer<'ser> { + pub(super) value: &'ser super::LabradorType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum LabradorTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> LabradorTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + LabradorTypeSerializerState::Init__ => { + *self.state = LabradorTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "color", &self.value.color)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + LabradorTypeSerializerState::Done__ => return Ok(None), + LabradorTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for LabradorTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = LabradorTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } +} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml_optimized.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml_optimized.rs new file mode 100644 index 00000000..dbf365e6 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml_optimized.rs @@ -0,0 +1,1237 @@ +use xsd_parser_types::{ + misc::{Namespace, NamespacePrefix}, + quick_xml::{Error, WithDeserializer, WithSerializer}, +}; +pub const NS_XS: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema"); +pub const NS_XML: Namespace = Namespace::new_const(b"http://www.w3.org/XML/1998/namespace"); +pub const NS_XSI: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema-instance"); +pub const NS_TNS: Namespace = Namespace::new_const(b"http://example.com"); +pub const PREFIX_XS: NamespacePrefix = NamespacePrefix::new_const(b"xs"); +pub const PREFIX_XML: NamespacePrefix = NamespacePrefix::new_const(b"xml"); +pub const PREFIX_XSI: NamespacePrefix = NamespacePrefix::new_const(b"xsi"); +pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns"); +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +impl WithSerializer for ListType { + type Serializer<'x> = quick_xml_serialize::ListTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::ListTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::ListTypeSerializerState::Init__), + name: name.unwrap_or("list"), + is_root, + }) + } +} +impl WithDeserializer for ListType { + type Deserializer = quick_xml_deserialize::ListTypeDeserializer; +} +#[derive(Debug)] +pub enum Animal { + Animal(AnimalDyn), + Dog(DogType), + Labrador(LabradorType), +} +impl WithSerializer for Animal { + type Serializer<'x> = quick_xml_serialize::AnimalSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + let _name = name; + Ok(quick_xml_serialize::AnimalSerializer { + value: self, + state: Box::new(quick_xml_serialize::AnimalSerializerState::Init__), + is_root, + }) + } +} +impl WithDeserializer for Animal { + type Deserializer = quick_xml_deserialize::AnimalDeserializer; +} +#[derive(Debug)] +pub struct AnimalDyn { + pub id: i32, +} +impl WithSerializer for AnimalDyn { + type Serializer<'x> = quick_xml_serialize::AnimalDynSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::AnimalDynSerializer { + value: self, + state: Box::new(quick_xml_serialize::AnimalDynSerializerState::Init__), + name: name.unwrap_or("animal"), + is_root, + }) + } +} +impl WithDeserializer for AnimalDyn { + type Deserializer = quick_xml_deserialize::AnimalDynDeserializer; +} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +impl WithSerializer for DogType { + type Serializer<'x> = quick_xml_serialize::DogTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::DogTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::DogTypeSerializerState::Init__), + name: name.unwrap_or("dog"), + is_root, + }) + } +} +impl WithDeserializer for DogType { + type Deserializer = quick_xml_deserialize::DogTypeDeserializer; +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl WithSerializer for LabradorType { + type Serializer<'x> = quick_xml_serialize::LabradorTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::LabradorTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::LabradorTypeSerializerState::Init__), + name: name.unwrap_or("labrador"), + is_root, + }) + } +} +impl WithDeserializer for LabradorType { + type Deserializer = quick_xml_deserialize::LabradorTypeDeserializer; +} +pub mod quick_xml_deserialize { + use core::mem::replace; + use std::borrow::Cow; + use xsd_parser_types::quick_xml::{ + BytesStart, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent, + DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event, + QName, RawByteStr, WithDeserializer, + }; + #[derive(Debug)] + pub struct ListTypeDeserializer { + animal: Vec, + state__: Box, + } + #[derive(Debug)] + enum ListTypeDeserializerState { + Init__, + Animal(Option<::Deserializer>), + Done__, + Unknown__, + } + impl ListTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + helper.raise_unexpected_attrib_checked(&attrib)?; + } + Ok(Self { + animal: Vec::new(), + state__: Box::new(ListTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: ListTypeDeserializerState, + ) -> Result<(), Error> { + use ListTypeDeserializerState as S; + match state { + S::Animal(Some(deserializer)) => self.store_animal(deserializer.finish(helper)?)?, + _ => (), + } + Ok(()) + } + fn store_animal(&mut self, value: super::Animal) -> Result<(), Error> { + self.animal.push(value); + Ok(()) + } + fn handle_animal<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::Animal>, + fallback: &mut Option, + ) -> Result, Error> { + use ListTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_animal(data)?; + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Animal(Some(deserializer))); + *self.state__ = S::Animal(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::ListType> for ListTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ListType> { + use ListTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Animal(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Animal(None); + event + } + (S::Animal(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = ::init(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, ListTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::ListType { + animal: self.animal, + }) + } + } + #[derive(Debug)] + pub struct AnimalDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum AnimalDeserializerState { + Init__, + Animal( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Dog( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Labrador( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::Animal), + Unknown__, + } + impl AnimalDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::NS_TNS), + Some(b"dog") + ) { + let output = ::init(helper, event)?; + return self.handle_dog(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_TNS), + Some(b"labrador") + ) { + let output = ::init(helper, event)?; + return self.handle_labrador(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_TNS), + Some(b"animal") + ) { + let type_name = helper + .get_dynamic_type_from_attrib_bytes(x)? + .unwrap_or(Cow::Borrowed(b"animal")) + .into_owned(); + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"animal") + ) { + let output = ::init(helper, event)?; + return self.handle_animal(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"dog") + ) { + let output = ::init(helper, event)?; + return self.handle_dog(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"labrador") + ) { + let output = + ::init(helper, event)?; + return self.handle_labrador(helper, Default::default(), None, output); + } + } + } + *self.state__ = AnimalDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: AnimalDeserializerState, + ) -> Result { + use AnimalDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Animal(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_animal(&mut values, value)?; + } + Ok(super::Animal::Animal( + helper.finish_element("animal", values)?, + )) + } + S::Dog(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_dog(&mut values, value)?; + } + Ok(super::Animal::Dog(helper.finish_element("dog", values)?)) + } + S::Labrador(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_labrador(&mut values, value)?; + } + Ok(super::Animal::Labrador( + helper.finish_element("labrador", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_animal( + values: &mut Option, + value: super::AnimalDyn, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"animal", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_dog( + values: &mut Option, + value: super::DogType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"dog")))?; + } + *values = Some(value); + Ok(()) + } + fn store_labrador( + values: &mut Option, + value: super::LabradorType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"labrador", + )))?; + } + *values = Some(value); + Ok(()) + } + fn handle_animal<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnimalDyn>, + ) -> Result, Error> { + use AnimalDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_animal(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_animal(&mut values, data)?; + let data = Self::finish_state(helper, S::Animal(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Animal(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_dog<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::DogType>, + ) -> Result, Error> { + use AnimalDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_dog(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_dog(&mut values, data)?; + let data = Self::finish_state(helper, S::Dog(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Dog(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_labrador<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LabradorType>, + ) -> Result, Error> { + use AnimalDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_labrador(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_labrador(&mut values, data)?; + let data = Self::finish_state(helper, S::Labrador(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Labrador(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::Animal> for AnimalDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Animal> { + let deserializer = Self { + state__: Box::new(AnimalDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, AnimalDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Animal> { + use AnimalDeserializerState as S; + let mut event = event; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Animal(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_animal(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Dog(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_dog(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Labrador(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_labrador(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state, event @ Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Animal(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_TNS), + b"animal", + false, + )?; + match self.handle_animal(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Dog(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_TNS), + b"dog", + false, + )?; + match self.handle_dog(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Labrador(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_TNS), + b"labrador", + false, + )?; + match self.handle_labrador(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + } + }; + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + Self::finish_state(helper, *self.state__) + } + } + #[derive(Debug)] + pub struct AnimalDynDeserializer { + id: i32, + state__: Box, + } + #[derive(Debug)] + enum AnimalDynDeserializerState { + Init__, + Unknown__, + } + impl AnimalDynDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + state__: Box::new(AnimalDynDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: AnimalDynDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::AnimalDyn> for AnimalDynDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalDyn> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalDyn> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, AnimalDynDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::AnimalDyn { id: self.id }) + } + } + #[derive(Debug)] + pub struct DogTypeDeserializer { + id: i32, + name: String, + state__: Box, + } + #[derive(Debug)] + enum DogTypeDeserializerState { + Init__, + Unknown__, + } + impl DogTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + state__: Box::new(DogTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: DogTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::DogType> for DogTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, DogTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::DogType { + id: self.id, + name: self.name, + }) + } + } + #[derive(Debug)] + pub struct LabradorTypeDeserializer { + id: i32, + name: String, + color: String, + state__: Box, + } + #[derive(Debug)] + enum LabradorTypeDeserializerState { + Init__, + Unknown__, + } + impl LabradorTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + let mut color: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"color") + ) { + helper.read_attrib(&mut color, b"color", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + color: color.ok_or_else(|| ErrorKind::MissingAttribute("color".into()))?, + state__: Box::new(LabradorTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: LabradorTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::LabradorType> for LabradorTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, LabradorTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::LabradorType { + id: self.id, + name: self.name, + color: self.color, + }) + } + } +} +pub mod quick_xml_serialize { + use xsd_parser_types::quick_xml::{ + BytesEnd, BytesStart, Error, Event, IterSerializer, SerializeHelper, Serializer, + WithSerializer, + }; + #[derive(Debug)] + pub struct ListTypeSerializer<'ser> { + pub(super) value: &'ser super::ListType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum ListTypeSerializerState<'ser> { + Init__, + Animal(IterSerializer<'ser, &'ser [super::Animal], super::Animal>), + End__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> ListTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + ListTypeSerializerState::Init__ => { + *self.state = ListTypeSerializerState::Animal(IterSerializer::new( + &self.value.animal[..], + Some("animal"), + false, + )); + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + return Ok(Some(Event::Start(bytes))); + } + ListTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = ListTypeSerializerState::End__, + }, + ListTypeSerializerState::End__ => { + *self.state = ListTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); + } + ListTypeSerializerState::Done__ => return Ok(None), + ListTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for ListTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = ListTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct AnimalSerializer<'ser> { + pub(super) value: &'ser super::Animal, + pub(super) state: Box>, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum AnimalSerializerState<'ser> { + Init__, + Animal(::Serializer<'ser>), + Dog(::Serializer<'ser>), + Labrador(::Serializer<'ser>), + Done__, + Phantom__(&'ser ()), + } + impl<'ser> AnimalSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + AnimalSerializerState::Init__ => { + match self.value { + super::Animal::Animal(x) => { + *self.state = AnimalSerializerState::Animal( + WithSerializer::serializer(x, Some("animal"), self.is_root)?, + ) + } + super::Animal::Dog(x) => { + *self.state = AnimalSerializerState::Dog( + WithSerializer::serializer(x, Some("dog"), self.is_root)?, + ) + } + super::Animal::Labrador(x) => { + *self.state = AnimalSerializerState::Labrador( + WithSerializer::serializer(x, Some("labrador"), self.is_root)?, + ) + } + } + } + AnimalSerializerState::Animal(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AnimalSerializerState::Done__, + }, + AnimalSerializerState::Dog(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AnimalSerializerState::Done__, + }, + AnimalSerializerState::Labrador(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AnimalSerializerState::Done__, + }, + AnimalSerializerState::Done__ => return Ok(None), + AnimalSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for AnimalSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = AnimalSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct AnimalDynSerializer<'ser> { + pub(super) value: &'ser super::AnimalDyn, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum AnimalDynSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> AnimalDynSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + AnimalDynSerializerState::Init__ => { + *self.state = AnimalDynSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + AnimalDynSerializerState::Done__ => return Ok(None), + AnimalDynSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for AnimalDynSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = AnimalDynSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct DogTypeSerializer<'ser> { + pub(super) value: &'ser super::DogType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum DogTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> DogTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + DogTypeSerializerState::Init__ => { + *self.state = DogTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + DogTypeSerializerState::Done__ => return Ok(None), + DogTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for DogTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = DogTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct LabradorTypeSerializer<'ser> { + pub(super) value: &'ser super::LabradorType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum LabradorTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> LabradorTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + LabradorTypeSerializerState::Init__ => { + *self.state = LabradorTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "color", &self.value.color)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + LabradorTypeSerializerState::Done__ => return Ok(None), + LabradorTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for LabradorTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = LabradorTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } +} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/mod.rs b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/mod.rs new file mode 100644 index 00000000..c505034b --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/mod.rs @@ -0,0 +1,367 @@ +use xsd_parser::{ + config::{GeneratorFlags, OptimizerFlags}, + Config, IdentType, +}; + +use crate::utils::{generate_test, ConfigEx}; + +fn config() -> Config { + Config::test_default() + .with_derive(["Debug"]) + .with_generator_flags(GeneratorFlags::FLATTEN_CONTENT) + .with_dynamic_type((IdentType::Type, "tns:animal")) + .with_generate([(IdentType::Element, "tns:list")]) +} + +/* default */ + +#[test] +fn generate_default() { + generate_test( + "tests/feature/dynamic_type_substitution_group_overlap/schema.xsd", + "tests/feature/dynamic_type_substitution_group_overlap/expected/default.rs", + config(), + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod default { + #![allow(unused_imports)] + + include!("expected/default.rs"); +} + +/* default (flatten) */ + +#[test] +fn generate_default_flatten() { + generate_test( + "tests/feature/dynamic_type_substitution_group_overlap/schema.xsd", + "tests/feature/dynamic_type_substitution_group_overlap/expected/default_flatten.rs", + config().with_optimizer_flags(OptimizerFlags::MERGE_DYNAMIC_TYPES), + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod default_flatten { + #![allow(unused_imports)] + + include!("expected/default_flatten.rs"); +} + +/* default (optimized) */ + +#[test] +fn generate_default_optimized() { + generate_test( + "tests/feature/dynamic_type_substitution_group_overlap/schema.xsd", + "tests/feature/dynamic_type_substitution_group_overlap/expected/default_optimized.rs", + config().with_optimizer_flags(OptimizerFlags::all()), + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod default_optmized { + #![allow(unused_imports)] + + include!("expected/default_optimized.rs"); +} + +/* quick_xml */ + +#[test] +fn generate_quick_xml() { + generate_test( + "tests/feature/dynamic_type_substitution_group_overlap/schema.xsd", + "tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml.rs", + config().with_quick_xml(), + ); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn read_quick_xml() { + use quick_xml::{AnimalDyn, AnimalType, DogType, LabradorType, List}; + + let obj = crate::utils::quick_xml_read_test::( + "tests/feature/dynamic_type_substitution_group_overlap/example/default.xml", + ); + + let mut items = obj.animal.iter(); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 1); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 2); + assert_eq!(item.name, "Max"); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 3); + assert_eq!(item.name, "Charlie"); + assert_eq!(item.color, "yellow"); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 4); + assert_eq!(item.name, "Rex"); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 5); + assert_eq!(item.name, "Buddy"); + assert_eq!(item.color, "black"); + + assert!(items.next().is_none()); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn write_quick_xml() { + use quick_xml::{Animal, AnimalDyn, AnimalType, DogType, LabradorType, List}; + + let obj = List { + animal: vec![ + Animal::new(AnimalType::new(AnimalDyn { id: 1 })), + Animal::new(AnimalType::new(DogType { + id: 2, + name: "Max".into(), + })), + Animal::new(AnimalType::new(LabradorType { + id: 3, + name: "Charlie".into(), + color: "yellow".into(), + })), + Animal::new(DogType { + id: 4, + name: "Rex".into(), + }), + Animal::new(LabradorType { + id: 5, + name: "Buddy".into(), + color: "black".into(), + }), + ], + }; + + crate::utils::quick_xml_write_test( + &obj, + "list", + "tests/feature/dynamic_type_substitution_group_overlap/example/default.xml", + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod quick_xml { + #![allow(unused_imports)] + + include!("expected/quick_xml.rs"); +} + +/* quick_xml (flatten) */ + +#[test] +fn generate_quick_xml_flatten() { + generate_test( + "tests/feature/dynamic_type_substitution_group_overlap/schema.xsd", + "tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml_flatten.rs", + config() + .with_quick_xml() + .with_optimizer_flags(OptimizerFlags::MERGE_DYNAMIC_TYPES), + ); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn read_quick_xml_flatten() { + use quick_xml_flatten::{AnimalDyn, DogType, LabradorType, List}; + + let obj = crate::utils::quick_xml_read_test::( + "tests/feature/dynamic_type_substitution_group_overlap/example/default.xml", + ); + + let mut items = obj.animal.into_iter(); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 1); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 2); + assert_eq!(item.name, "Max"); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 3); + assert_eq!(item.name, "Charlie"); + assert_eq!(item.color, "yellow"); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 4); + assert_eq!(item.name, "Rex"); + + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 5); + assert_eq!(item.name, "Buddy"); + assert_eq!(item.color, "black"); + + assert!(items.next().is_none()); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn write_quick_xml_flatten() { + use quick_xml_flatten::{Animal, AnimalDyn, DogType, LabradorType, List}; + + let obj = List { + animal: vec![ + Animal::new(AnimalDyn { id: 1 }), + Animal::new(DogType { + id: 2, + name: "Max".into(), + }), + Animal::new(LabradorType { + id: 3, + name: "Charlie".into(), + color: "yellow".into(), + }), + Animal::new(DogType { + id: 4, + name: "Rex".into(), + }), + Animal::new(LabradorType { + id: 5, + name: "Buddy".into(), + color: "black".into(), + }), + ], + }; + + crate::utils::quick_xml_write_test( + &obj, + "list", + "tests/feature/dynamic_type_substitution_group_overlap/example/default_flatten.xml", + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod quick_xml_flatten { + #![allow(unused_imports)] + + include!("expected/quick_xml_flatten.rs"); +} + +/* quick_xml (optimized) */ + +#[test] +fn generate_quick_xml_optimized() { + generate_test( + "tests/feature/dynamic_type_substitution_group_overlap/schema.xsd", + "tests/feature/dynamic_type_substitution_group_overlap/expected/quick_xml_optimized.rs", + config() + .with_quick_xml() + .with_optimizer_flags(OptimizerFlags::all()), + ); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn read_quick_xml_optimized() { + use quick_xml_optimized::{Animal, List}; + + let obj = crate::utils::quick_xml_read_test::( + "tests/feature/dynamic_type_substitution_group_overlap/example/default.xml", + ); + + let mut items = obj.animal.into_iter(); + + let item = items.next().unwrap(); + let Animal::Animal(item) = item else { + panic!("Expected `Animal::Animal`"); + }; + assert_eq!(item.id, 1); + + let item = items.next().unwrap(); + let Animal::Dog(item) = item else { + panic!("Expected `Animal::Dog`"); + }; + assert_eq!(item.id, 2); + assert_eq!(item.name, "Max"); + + let item = items.next().unwrap(); + let Animal::Labrador(item) = item else { + panic!("Expected `Animal::Labrador`"); + }; + assert_eq!(item.id, 3); + assert_eq!(item.name, "Charlie"); + assert_eq!(item.color, "yellow"); + + let item = items.next().unwrap(); + let Animal::Dog(item) = item else { + panic!("Expected `Animal::Dog`"); + }; + assert_eq!(item.id, 4); + assert_eq!(item.name, "Rex"); + + let item = items.next().unwrap(); + let Animal::Labrador(item) = item else { + panic!("Expected `Animal::Labrador`"); + }; + assert_eq!(item.id, 5); + assert_eq!(item.name, "Buddy"); + assert_eq!(item.color, "black"); + + assert!(items.next().is_none()); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn write_quick_xml_optimized() { + use quick_xml_optimized::{Animal, AnimalDyn, DogType, LabradorType, List}; + + let obj = List { + animal: vec![ + Animal::Animal(AnimalDyn { id: 1 }), + Animal::Dog(DogType { + id: 2, + name: "Max".into(), + }), + Animal::Labrador(LabradorType { + id: 3, + name: "Charlie".into(), + color: "yellow".into(), + }), + Animal::Dog(DogType { + id: 4, + name: "Rex".into(), + }), + Animal::Labrador(LabradorType { + id: 5, + name: "Buddy".into(), + color: "black".into(), + }), + ], + }; + + crate::utils::quick_xml_write_test( + &obj, + "list", + "tests/feature/dynamic_type_substitution_group_overlap/example/default_optimized.xml", + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod quick_xml_optimized { + #![allow(unused_imports)] + + include!("expected/quick_xml_optimized.rs"); +} diff --git a/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/schema.xsd b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/schema.xsd new file mode 100644 index 00000000..26d2cd73 --- /dev/null +++ b/xsd-parser/tests/feature/dynamic_type_substitution_group_overlap/schema.xsd @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/xsd-parser/tests/feature/dynamic_types/example/default.xml b/xsd-parser/tests/feature/dynamic_types/example/default.xml deleted file mode 100644 index 19ac407b..00000000 --- a/xsd-parser/tests/feature/dynamic_types/example/default.xml +++ /dev/null @@ -1,4 +0,0 @@ - - - - diff --git a/xsd-parser/tests/feature/dynamic_types/expected/default.rs b/xsd-parser/tests/feature/dynamic_types/expected/default.rs deleted file mode 100644 index 78ddf74c..00000000 --- a/xsd-parser/tests/feature/dynamic_types/expected/default.rs +++ /dev/null @@ -1,28 +0,0 @@ -use core::fmt::Debug; -use xsd_parser_types::AsAny; -pub type List = ListType; -#[derive(Debug)] -pub struct ListType { - pub base: Vec, -} -#[derive(Debug)] -pub struct Base(pub Box); -pub trait BaseTrait: Debug + AsAny {} -#[derive(Debug)] -pub struct IntermediateType { - pub base_value: Option, - pub intermediate_value: Option, -} -impl BaseTrait for IntermediateType {} -impl IntermediateTrait for IntermediateType {} -#[derive(Debug)] -pub struct FinalType { - pub base_value: Option, - pub intermediate_value: Option, - pub final_value: Option, -} -impl BaseTrait for FinalType {} -impl IntermediateTrait for FinalType {} -#[derive(Debug)] -pub struct Intermediate(pub Box); -pub trait IntermediateTrait: BaseTrait {} diff --git a/xsd-parser/tests/feature/dynamic_types/expected/default_optimized.rs b/xsd-parser/tests/feature/dynamic_types/expected/default_optimized.rs deleted file mode 100644 index e6d21b39..00000000 --- a/xsd-parser/tests/feature/dynamic_types/expected/default_optimized.rs +++ /dev/null @@ -1,21 +0,0 @@ -pub type List = ListType; -#[derive(Debug)] -pub struct ListType { - pub base: Vec, -} -#[derive(Debug)] -pub enum Base { - Intermediate(IntermediateType), - Final(FinalType), -} -#[derive(Debug)] -pub struct IntermediateType { - pub base_value: Option, - pub intermediate_value: Option, -} -#[derive(Debug)] -pub struct FinalType { - pub base_value: Option, - pub intermediate_value: Option, - pub final_value: Option, -} diff --git a/xsd-parser/tests/feature/dynamic_types/mod.rs b/xsd-parser/tests/feature/dynamic_types/mod.rs deleted file mode 100644 index 37a5a6c0..00000000 --- a/xsd-parser/tests/feature/dynamic_types/mod.rs +++ /dev/null @@ -1,191 +0,0 @@ -use xsd_parser::{ - config::{GeneratorFlags, OptimizerFlags}, - Config, IdentType, -}; - -use crate::utils::{generate_test, ConfigEx}; - -fn config() -> Config { - Config::test_default() - .with_derive(["Debug"]) - .with_generator_flags(GeneratorFlags::FLATTEN_CONTENT) - .with_generate([(IdentType::Element, "tns:list")]) -} - -/* default */ - -#[test] -fn generate_default() { - generate_test( - "tests/feature/dynamic_types/schema.xsd", - "tests/feature/dynamic_types/expected/default.rs", - config(), - ); -} - -#[cfg(not(feature = "update-expectations"))] -mod default { - #![allow(unused_imports)] - - include!("expected/default.rs"); -} - -/* default (optimized) */ - -#[test] -fn generate_default_optimized() { - generate_test( - "tests/feature/dynamic_types/schema.xsd", - "tests/feature/dynamic_types/expected/default_optimized.rs", - config().with_optimizer_flags(OptimizerFlags::all()), - ); -} - -#[cfg(not(feature = "update-expectations"))] -mod default_optmized { - #![allow(unused_imports)] - - include!("expected/default_optimized.rs"); -} - -/* quick_xml */ - -#[test] -fn generate_quick_xml() { - generate_test( - "tests/feature/dynamic_types/schema.xsd", - "tests/feature/dynamic_types/expected/quick_xml.rs", - config().with_quick_xml(), - ); -} - -#[test] -#[cfg(not(feature = "update-expectations"))] -fn read_quick_xml() { - use quick_xml::{FinalType, IntermediateType, List}; - - let obj = crate::utils::quick_xml_read_test::( - "tests/feature/dynamic_types/example/default.xml", - ); - - let mut items = obj.base.iter(); - let item = items.next().unwrap(); - let item = item.0.as_any().downcast_ref::().unwrap(); - assert_eq!(item.base_value, Some(10)); - assert_eq!(item.intermediate_value, Some(11)); - - let item = items.next().unwrap(); - let item = item.0.as_any().downcast_ref::().unwrap(); - assert_eq!(item.base_value, Some(20)); - assert_eq!(item.intermediate_value, Some(21)); - assert_eq!(item.final_value, Some(22)); - - assert!(items.next().is_none()); -} - -#[test] -#[cfg(not(feature = "update-expectations"))] -fn write_quick_xml() { - use quick_xml::{Base, FinalType, IntermediateType, List}; - - let obj = List { - base: vec![ - Base(Box::new(IntermediateType { - base_value: Some(10), - intermediate_value: Some(11), - })), - Base(Box::new(FinalType { - base_value: Some(20), - intermediate_value: Some(21), - final_value: Some(22), - })), - ], - }; - - crate::utils::quick_xml_write_test( - &obj, - "List", - "tests/feature/dynamic_types/example/default.xml", - ); -} - -#[cfg(not(feature = "update-expectations"))] -mod quick_xml { - #![allow(unused_imports)] - - include!("expected/quick_xml.rs"); -} - -/* quick_xml (optimized) */ - -#[test] -fn generate_quick_xml_optimized() { - generate_test( - "tests/feature/dynamic_types/schema.xsd", - "tests/feature/dynamic_types/expected/quick_xml_optimized.rs", - config() - .with_quick_xml() - .with_optimizer_flags(OptimizerFlags::all()), - ); -} - -#[test] -#[cfg(not(feature = "update-expectations"))] -fn read_quick_xml_optimized() { - use quick_xml_optimized::{Base, List}; - - let obj = crate::utils::quick_xml_read_test::( - "tests/feature/dynamic_types/example/default.xml", - ); - - let mut items = obj.base.into_iter(); - let item = items.next().unwrap(); - let Base::Intermediate(item) = item else { - panic!("Expected `Base::Intermediate`"); - }; - assert_eq!(item.base_value, Some(10)); - assert_eq!(item.intermediate_value, Some(11)); - - let item = items.next().unwrap(); - let Base::Final(item) = item else { - panic!("Expected `Base::Final`"); - }; - assert_eq!(item.base_value, Some(20)); - assert_eq!(item.intermediate_value, Some(21)); - assert_eq!(item.final_value, Some(22)); - - assert!(items.next().is_none()); -} - -#[test] -#[cfg(not(feature = "update-expectations"))] -fn write_quick_xml_optimized() { - use quick_xml_optimized::{Base, FinalType, IntermediateType, List}; - - let obj = List { - base: vec![ - Base::Intermediate(IntermediateType { - base_value: Some(10), - intermediate_value: Some(11), - }), - Base::Final(FinalType { - base_value: Some(20), - intermediate_value: Some(21), - final_value: Some(22), - }), - ], - }; - - crate::utils::quick_xml_write_test( - &obj, - "List", - "tests/feature/dynamic_types/example/default.xml", - ); -} - -#[cfg(not(feature = "update-expectations"))] -mod quick_xml_optimized { - #![allow(unused_imports)] - - include!("expected/quick_xml_optimized.rs"); -} diff --git a/xsd-parser/tests/feature/dynamic_types/schema.xsd b/xsd-parser/tests/feature/dynamic_types/schema.xsd deleted file mode 100644 index fc0f4201..00000000 --- a/xsd-parser/tests/feature/dynamic_types/schema.xsd +++ /dev/null @@ -1,58 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/xsd-parser/tests/feature/mod.rs b/xsd-parser/tests/feature/mod.rs index a62fe4f8..3dfe9862 100644 --- a/xsd-parser/tests/feature/mod.rs +++ b/xsd-parser/tests/feature/mod.rs @@ -22,7 +22,9 @@ mod defaultable_content; mod derive; mod documentation; mod duplicate_idents; -mod dynamic_types; +mod dynamic_type; +mod dynamic_type_substitution_group; +mod dynamic_type_substitution_group_overlap; mod element_refs_with_ns; mod element_without_type; mod empty_string; @@ -60,7 +62,6 @@ mod namespaces_qualified; mod namespaces_unqualified; mod nested_group_reuse; mod nillable; -mod nillable_dynamic_types; mod nonzero_int; mod num_big_int; mod numeric_fields; @@ -78,6 +79,8 @@ mod simple_type; mod simple_type_emptiable_complex_base; mod simple_type_max_length; mod static_list; +mod substitution_group; +mod substitution_group_nillable; mod trailing_underscore_group; mod tuple_with_integer; mod tuple_with_string; diff --git a/xsd-parser/tests/feature/nillable_dynamic_types/example/default.xml b/xsd-parser/tests/feature/nillable_dynamic_types/example/default.xml deleted file mode 100644 index a9413ed4..00000000 --- a/xsd-parser/tests/feature/nillable_dynamic_types/example/default.xml +++ /dev/null @@ -1,4 +0,0 @@ - - - - diff --git a/xsd-parser/tests/feature/nillable_dynamic_types/expected/default.rs b/xsd-parser/tests/feature/nillable_dynamic_types/expected/default.rs deleted file mode 100644 index b8e6e0d4..00000000 --- a/xsd-parser/tests/feature/nillable_dynamic_types/expected/default.rs +++ /dev/null @@ -1,30 +0,0 @@ -use core::fmt::Debug; -use xsd_parser_types::{xml::Nillable, AsAny}; -pub type List = ListType; -#[derive(Debug)] -pub struct ListType { - pub base: Vec, -} -#[derive(Debug)] -pub struct Base(pub Box); -pub trait BaseTrait: Debug + AsAny {} -pub type IntermediateDyn = Nillable; -impl BaseTrait for IntermediateDyn {} -impl IntermediateTrait for IntermediateDyn {} -pub type FinalDyn = Nillable; -impl BaseTrait for FinalDyn {} -impl IntermediateTrait for FinalDyn {} -#[derive(Debug)] -pub struct IntermediateType { - pub base_value: Option, - pub intermediate_value: Option, -} -#[derive(Debug)] -pub struct Intermediate(pub Box); -pub trait IntermediateTrait: BaseTrait {} -#[derive(Debug)] -pub struct FinalType { - pub base_value: Option, - pub intermediate_value: Option, - pub final_value: Option, -} diff --git a/xsd-parser/tests/feature/nillable_dynamic_types/expected/default_optimized.rs b/xsd-parser/tests/feature/nillable_dynamic_types/expected/default_optimized.rs deleted file mode 100644 index 12acc5eb..00000000 --- a/xsd-parser/tests/feature/nillable_dynamic_types/expected/default_optimized.rs +++ /dev/null @@ -1,24 +0,0 @@ -use xsd_parser_types::xml::Nillable; -pub type List = ListType; -#[derive(Debug)] -pub struct ListType { - pub base: Vec, -} -#[derive(Debug)] -pub enum Base { - Intermediate(IntermediateDyn), - Final(FinalDyn), -} -pub type IntermediateDyn = Nillable; -pub type FinalDyn = Nillable; -#[derive(Debug)] -pub struct IntermediateType { - pub base_value: Option, - pub intermediate_value: Option, -} -#[derive(Debug)] -pub struct FinalType { - pub base_value: Option, - pub intermediate_value: Option, - pub final_value: Option, -} diff --git a/xsd-parser/tests/feature/nillable_dynamic_types/mod.rs b/xsd-parser/tests/feature/nillable_dynamic_types/mod.rs deleted file mode 100644 index ca0efd57..00000000 --- a/xsd-parser/tests/feature/nillable_dynamic_types/mod.rs +++ /dev/null @@ -1,201 +0,0 @@ -use xsd_parser::{ - config::{GeneratorFlags, OptimizerFlags}, - Config, IdentType, -}; - -use crate::utils::{generate_test, ConfigEx}; - -fn config() -> Config { - Config::test_default() - .with_derive(["Debug"]) - .with_generate([(IdentType::Element, "tns:list")]) - .with_generator_flags(GeneratorFlags::FLATTEN_CONTENT) - .with_nillable_type_support() -} - -/* default */ - -#[test] -fn generate_default() { - generate_test( - "tests/feature/nillable_dynamic_types/schema.xsd", - "tests/feature/nillable_dynamic_types/expected/default.rs", - config(), - ); -} - -#[cfg(not(feature = "update-expectations"))] -mod default { - #![allow(unused_imports)] - - include!("expected/default.rs"); -} - -/* default (optimized) */ - -#[test] -fn generate_default_optimized() { - generate_test( - "tests/feature/nillable_dynamic_types/schema.xsd", - "tests/feature/nillable_dynamic_types/expected/default_optimized.rs", - config().with_optimizer_flags(OptimizerFlags::all()), - ); -} - -#[cfg(not(feature = "update-expectations"))] -mod default_optmized { - #![allow(unused_imports)] - - include!("expected/default_optimized.rs"); -} - -/* quick_xml */ - -#[test] -fn generate_quick_xml() { - generate_test( - "tests/feature/nillable_dynamic_types/schema.xsd", - "tests/feature/nillable_dynamic_types/expected/quick_xml.rs", - config().with_quick_xml(), - ); -} - -#[test] -#[cfg(not(feature = "update-expectations"))] -fn read_quick_xml() { - use quick_xml::{FinalDyn, IntermediateDyn, List}; - - let obj = crate::utils::quick_xml_read_test::( - "tests/feature/nillable_dynamic_types/example/default.xml", - ); - - let mut items = obj.base.into_iter(); - let item = items.next().unwrap(); - let item = item - .0 - .into_any() - .downcast::() - .unwrap() - .unwrap(); - assert_eq!(item.base_value, Some(10)); - assert_eq!(item.intermediate_value, Some(11)); - - let item = items.next().unwrap(); - let item = item.0.into_any().downcast::().unwrap().unwrap(); - assert_eq!(item.base_value, Some(20)); - assert_eq!(item.intermediate_value, Some(21)); - assert_eq!(item.final_value, Some(22)); - - assert!(items.next().is_none()); -} - -#[test] -#[cfg(not(feature = "update-expectations"))] -fn write_quick_xml() { - use quick_xml::{Base, FinalType, IntermediateType, List}; - use xsd_parser_types::xml::Nillable; - - let obj = List { - base: vec![ - Base(Box::new(Nillable::new(IntermediateType { - base_value: Some(10), - intermediate_value: Some(11), - }))), - Base(Box::new(Nillable::new(FinalType { - base_value: Some(20), - intermediate_value: Some(21), - final_value: Some(22), - }))), - ], - }; - - crate::utils::quick_xml_write_test( - &obj, - "List", - "tests/feature/nillable_dynamic_types/example/default.xml", - ); -} - -#[cfg(not(feature = "update-expectations"))] -mod quick_xml { - #![allow(unused_imports)] - - include!("expected/quick_xml.rs"); -} - -/* quick_xml (optimized) */ - -#[test] -fn generate_quick_xml_optimized() { - generate_test( - "tests/feature/nillable_dynamic_types/schema.xsd", - "tests/feature/nillable_dynamic_types/expected/quick_xml_optimized.rs", - config() - .with_quick_xml() - .with_optimizer_flags(OptimizerFlags::all()), - ); -} - -#[test] -#[cfg(not(feature = "update-expectations"))] -fn read_quick_xml_optimized() { - use quick_xml_optimized::{Base, List}; - - let obj = crate::utils::quick_xml_read_test::( - "tests/feature/nillable_dynamic_types/example/default.xml", - ); - - let mut items = obj.base.into_iter(); - let item = items.next().unwrap(); - let Base::Intermediate(item) = item else { - panic!("Expected `Base::Intermediate`"); - }; - let item = item.unwrap(); - assert_eq!(item.base_value, Some(10)); - assert_eq!(item.intermediate_value, Some(11)); - - let item = items.next().unwrap(); - let Base::Final(item) = item else { - panic!("Expected `Base::Final`"); - }; - let item = item.unwrap(); - assert_eq!(item.base_value, Some(20)); - assert_eq!(item.intermediate_value, Some(21)); - assert_eq!(item.final_value, Some(22)); - - assert!(items.next().is_none()); -} - -#[test] -#[cfg(not(feature = "update-expectations"))] -fn write_quick_xml_optimized() { - use quick_xml_optimized::{Base, FinalType, IntermediateType, List}; - use xsd_parser_types::xml::Nillable; - - let obj = List { - base: vec![ - Base::Intermediate(Nillable::new(IntermediateType { - base_value: Some(10), - intermediate_value: Some(11), - })), - Base::Final(Nillable::new(FinalType { - base_value: Some(20), - intermediate_value: Some(21), - final_value: Some(22), - })), - ], - }; - - crate::utils::quick_xml_write_test( - &obj, - "List", - "tests/feature/nillable_dynamic_types/example/default.xml", - ); -} - -#[cfg(not(feature = "update-expectations"))] -mod quick_xml_optimized { - #![allow(unused_imports)] - - include!("expected/quick_xml_optimized.rs"); -} diff --git a/xsd-parser/tests/feature/nillable_dynamic_types/schema.xsd b/xsd-parser/tests/feature/nillable_dynamic_types/schema.xsd deleted file mode 100644 index 3f0a809a..00000000 --- a/xsd-parser/tests/feature/nillable_dynamic_types/schema.xsd +++ /dev/null @@ -1,58 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/xsd-parser/tests/feature/substitution_group/example/default.xml b/xsd-parser/tests/feature/substitution_group/example/default.xml new file mode 100644 index 00000000..b4719ac0 --- /dev/null +++ b/xsd-parser/tests/feature/substitution_group/example/default.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/xsd-parser/tests/feature/substitution_group/expected/default.rs b/xsd-parser/tests/feature/substitution_group/expected/default.rs new file mode 100644 index 00000000..6d7a4b48 --- /dev/null +++ b/xsd-parser/tests/feature/substitution_group/expected/default.rs @@ -0,0 +1,33 @@ +use core::fmt::Debug; +use xsd_parser_types::AsAny; +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +#[derive(Debug)] +pub struct Animal(pub Box); +pub trait AnimalTrait: Debug + AsAny {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +#[derive(Debug)] +pub struct AnimalType { + pub id: i32, +} +impl AnimalTrait for AnimalType {} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +impl AnimalTrait for DogType {} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl AnimalTrait for LabradorType {} diff --git a/xsd-parser/tests/feature/substitution_group/expected/default_optimized.rs b/xsd-parser/tests/feature/substitution_group/expected/default_optimized.rs new file mode 100644 index 00000000..a2358b1d --- /dev/null +++ b/xsd-parser/tests/feature/substitution_group/expected/default_optimized.rs @@ -0,0 +1,26 @@ +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +#[derive(Debug)] +pub enum Animal { + Animal(AnimalType), + Dog(DogType), + Labrador(LabradorType), +} +#[derive(Debug)] +pub struct AnimalType { + pub id: i32, +} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} diff --git a/xsd-parser/tests/feature/dynamic_types/expected/quick_xml.rs b/xsd-parser/tests/feature/substitution_group/expected/quick_xml.rs similarity index 58% rename from xsd-parser/tests/feature/dynamic_types/expected/quick_xml.rs rename to xsd-parser/tests/feature/substitution_group/expected/quick_xml.rs index aed38f75..f99a798a 100644 --- a/xsd-parser/tests/feature/dynamic_types/expected/quick_xml.rs +++ b/xsd-parser/tests/feature/substitution_group/expected/quick_xml.rs @@ -15,7 +15,7 @@ pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns"); pub type List = ListType; #[derive(Debug)] pub struct ListType { - pub base: Vec, + pub animal: Vec, } impl WithSerializer for ListType { type Serializer<'x> = quick_xml_serialize::ListTypeSerializer<'x>; @@ -36,106 +36,123 @@ impl WithDeserializer for ListType { type Deserializer = quick_xml_deserialize::ListTypeDeserializer; } #[derive(Debug)] -pub struct Base(pub Box); -pub trait BaseTrait: Debug + AsAny + WithBoxedSerializer {} -impl WithSerializer for Base { +pub struct Animal(pub Box); +pub trait AnimalTrait: Debug + AsAny + WithBoxedSerializer {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +impl WithSerializer for Animal { type Serializer<'x> = BoxedSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - let _name = name; + if (*self.0).as_any().is::() { + return self.0.serializer(Some("animal"), is_root); + } + if (*self.0).as_any().is::() { + return self.0.serializer(Some("dog"), is_root); + } + if (*self.0).as_any().is::() { + return self.0.serializer(Some("labrador"), is_root); + } self.0.serializer(None, is_root) } } -impl WithDeserializer for Base { - type Deserializer = quick_xml_deserialize::BaseDeserializer; +impl WithDeserializer for Animal { + type Deserializer = quick_xml_deserialize::AnimalDeserializer; } #[derive(Debug)] -pub struct IntermediateType { - pub base_value: Option, - pub intermediate_value: Option, +pub struct AnimalType { + pub id: i32, } -impl BaseTrait for IntermediateType {} -impl IntermediateTrait for IntermediateType {} -impl WithSerializer for IntermediateType { - type Serializer<'x> = quick_xml_serialize::IntermediateTypeSerializer<'x>; +impl AnimalTrait for AnimalType {} +impl WithSerializer for AnimalType { + type Serializer<'x> = quick_xml_serialize::AnimalTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::IntermediateTypeSerializer { + Ok(quick_xml_serialize::AnimalTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::IntermediateTypeSerializerState::Init__), - name: name.unwrap_or("intermediate"), + state: Box::new(quick_xml_serialize::AnimalTypeSerializerState::Init__), + name: name.unwrap_or("animal"), is_root, }) } } -impl WithDeserializer for IntermediateType { - type Deserializer = quick_xml_deserialize::IntermediateTypeDeserializer; +impl WithDeserializer for AnimalType { + type Deserializer = quick_xml_deserialize::AnimalTypeDeserializer; } #[derive(Debug)] -pub struct FinalType { - pub base_value: Option, - pub intermediate_value: Option, - pub final_value: Option, +pub struct DogType { + pub id: i32, + pub name: String, } -impl BaseTrait for FinalType {} -impl IntermediateTrait for FinalType {} -impl WithSerializer for FinalType { - type Serializer<'x> = quick_xml_serialize::FinalTypeSerializer<'x>; +impl AnimalTrait for DogType {} +impl WithSerializer for DogType { + type Serializer<'x> = quick_xml_serialize::DogTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::FinalTypeSerializer { + Ok(quick_xml_serialize::DogTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::FinalTypeSerializerState::Init__), - name: name.unwrap_or("final"), + state: Box::new(quick_xml_serialize::DogTypeSerializerState::Init__), + name: name.unwrap_or("dog"), is_root, }) } } -impl WithDeserializer for FinalType { - type Deserializer = quick_xml_deserialize::FinalTypeDeserializer; +impl WithDeserializer for DogType { + type Deserializer = quick_xml_deserialize::DogTypeDeserializer; } #[derive(Debug)] -pub struct Intermediate(pub Box); -pub trait IntermediateTrait: BaseTrait {} -impl WithSerializer for Intermediate { - type Serializer<'x> = BoxedSerializer<'x>; +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl AnimalTrait for LabradorType {} +impl WithSerializer for LabradorType { + type Serializer<'x> = quick_xml_serialize::LabradorTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - let _name = name; - self.0.serializer(None, is_root) + Ok(quick_xml_serialize::LabradorTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::LabradorTypeSerializerState::Init__), + name: name.unwrap_or("labrador"), + is_root, + }) } } -impl WithDeserializer for Intermediate { - type Deserializer = quick_xml_deserialize::IntermediateDeserializer; +impl WithDeserializer for LabradorType { + type Deserializer = quick_xml_deserialize::LabradorTypeDeserializer; } pub mod quick_xml_deserialize { use core::mem::replace; use xsd_parser_types::quick_xml::{ BytesStart, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent, - DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, Event, QName, - WithDeserializer, + DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event, + QName, WithDeserializer, }; #[derive(Debug)] pub struct ListTypeDeserializer { - base: Vec, + animal: Vec, state__: Box, } #[derive(Debug)] enum ListTypeDeserializerState { Init__, - Base(Option<::Deserializer>), + Animal(Option<::Deserializer>), Done__, Unknown__, } @@ -149,7 +166,7 @@ pub mod quick_xml_deserialize { helper.raise_unexpected_attrib_checked(&attrib)?; } Ok(Self { - base: Vec::new(), + animal: Vec::new(), state__: Box::new(ListTypeDeserializerState::Init__), }) } @@ -160,19 +177,19 @@ pub mod quick_xml_deserialize { ) -> Result<(), Error> { use ListTypeDeserializerState as S; match state { - S::Base(Some(deserializer)) => self.store_base(deserializer.finish(helper)?)?, + S::Animal(Some(deserializer)) => self.store_animal(deserializer.finish(helper)?)?, _ => (), } Ok(()) } - fn store_base(&mut self, value: super::Base) -> Result<(), Error> { - self.base.push(value); + fn store_animal(&mut self, value: super::Animal) -> Result<(), Error> { + self.animal.push(value); Ok(()) } - fn handle_base<'de>( + fn handle_animal<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::Base>, + output: DeserializerOutput<'de, super::Animal>, fallback: &mut Option, ) -> Result, Error> { use ListTypeDeserializerState as S; @@ -191,13 +208,13 @@ pub mod quick_xml_deserialize { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_base(data)?; - *self.state__ = S::Base(None); + self.store_animal(data)?; + *self.state__ = S::Animal(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Base(Some(deserializer))); - *self.state__ = S::Base(None); + fallback.get_or_insert(S::Animal(Some(deserializer))); + *self.state__ = S::Animal(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } } @@ -223,9 +240,9 @@ pub mod quick_xml_deserialize { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Base(Some(deserializer)), event) => { + (S::Animal(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_base(helper, output, &mut fallback)? { + match self.handle_animal(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -247,12 +264,12 @@ pub mod quick_xml_deserialize { } (S::Init__, event) => { fallback.get_or_insert(S::Init__); - *self.state__ = S::Base(None); + *self.state__ = S::Animal(None); event } - (S::Base(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = ::init(helper, event)?; - match self.handle_base(helper, output, &mut fallback)? { + (S::Animal(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = ::init(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -284,20 +301,23 @@ pub mod quick_xml_deserialize { fn finish(mut self, helper: &mut DeserializeHelper) -> Result { let state = replace(&mut *self.state__, ListTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::ListType { base: self.base }) + Ok(super::ListType { + animal: self.animal, + }) } } #[derive(Debug)] - pub enum BaseDeserializer { - Intermediate(::Deserializer), - Final(::Deserializer), + pub enum AnimalDeserializer { + Animal(::Deserializer), + Dog(::Deserializer), + Labrador(::Deserializer), } - impl<'de> Deserializer<'de, super::Base> for BaseDeserializer { + impl<'de> Deserializer<'de, super::Animal> for AnimalDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Base> { - let Some(type_name) = helper.get_dynamic_type_name(&event)? else { + ) -> DeserializerResult<'de, super::Animal> { + let Some(type_name) = helper.get_dynamic_type_from_tag(&event) else { return Ok(DeserializerOutput { artifact: DeserializerArtifact::None, event: DeserializerEvent::None, @@ -307,30 +327,45 @@ pub mod quick_xml_deserialize { let type_name = type_name.into_owned(); if matches!( helper.resolve_local_name(QName(&type_name), &super::NS_TNS), - Some(b"intermediate") + Some(b"animal") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"dog") ) { let DeserializerOutput { artifact, event, allow_any, - } = ::init(helper, event)?; + } = ::init(helper, event)?; return Ok(DeserializerOutput { - artifact: artifact.map(|x| super::Base(Box::new(x)), |x| Self::Intermediate(x)), + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Dog(x)), event, allow_any, }); } if matches!( helper.resolve_local_name(QName(&type_name), &super::NS_TNS), - Some(b"final") + Some(b"labrador") ) { let DeserializerOutput { artifact, event, allow_any, - } = ::init(helper, event)?; + } = ::init(helper, event)?; return Ok(DeserializerOutput { - artifact: artifact.map(|x| super::Base(Box::new(x)), |x| Self::Final(x)), + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Labrador(x)), event, allow_any, }); @@ -345,106 +380,107 @@ pub mod quick_xml_deserialize { self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Base> { + ) -> DeserializerResult<'de, super::Animal> { match self { - Self::Intermediate(x) => { + Self::Animal(x) => { let DeserializerOutput { artifact, event, allow_any, } = x.next(helper, event)?; Ok(DeserializerOutput { - artifact: artifact - .map(|x| super::Base(Box::new(x)), |x| Self::Intermediate(x)), + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }) + } + Self::Dog(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Dog(x)), event, allow_any, }) } - Self::Final(x) => { + Self::Labrador(x) => { let DeserializerOutput { artifact, event, allow_any, } = x.next(helper, event)?; Ok(DeserializerOutput { - artifact: artifact.map(|x| super::Base(Box::new(x)), |x| Self::Final(x)), + artifact: artifact + .map(|x| super::Animal(Box::new(x)), |x| Self::Labrador(x)), event, allow_any, }) } } } - fn finish(self, helper: &mut DeserializeHelper) -> Result { + fn finish(self, helper: &mut DeserializeHelper) -> Result { match self { - Self::Intermediate(x) => Ok(super::Base(Box::new(x.finish(helper)?))), - Self::Final(x) => Ok(super::Base(Box::new(x.finish(helper)?))), + Self::Animal(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + Self::Dog(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + Self::Labrador(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), } } } #[derive(Debug)] - pub struct IntermediateTypeDeserializer { - base_value: Option, - intermediate_value: Option, - state__: Box, + pub struct AnimalTypeDeserializer { + id: i32, + state__: Box, } #[derive(Debug)] - enum IntermediateTypeDeserializerState { + enum AnimalTypeDeserializerState { Init__, Unknown__, } - impl IntermediateTypeDeserializer { + impl AnimalTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut base_value: Option = None; - let mut intermediate_value: Option = None; + let mut id: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"baseValue") + Some(b"id") ) { - helper.read_attrib(&mut base_value, b"baseValue", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"intermediateValue") - ) { - helper.read_attrib( - &mut intermediate_value, - b"intermediateValue", - &attrib.value, - )?; + helper.read_attrib(&mut id, b"id", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - base_value: base_value, - intermediate_value: intermediate_value, - state__: Box::new(IntermediateTypeDeserializerState::Init__), + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + state__: Box::new(AnimalTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: IntermediateTypeDeserializerState, + state: AnimalTypeDeserializerState, ) -> Result<(), Error> { Ok(()) } } - impl<'de> Deserializer<'de, super::IntermediateType> for IntermediateTypeDeserializer { + impl<'de> Deserializer<'de, super::AnimalType> for AnimalTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::IntermediateType> { + ) -> DeserializerResult<'de, super::AnimalType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::IntermediateType> { + ) -> DeserializerResult<'de, super::AnimalType> { if let Event::End(_) = &event { Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), @@ -459,93 +495,72 @@ pub mod quick_xml_deserialize { }) } } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - IntermediateTypeDeserializerState::Unknown__, - ); + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, AnimalTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::IntermediateType { - base_value: self.base_value, - intermediate_value: self.intermediate_value, - }) + Ok(super::AnimalType { id: self.id }) } } #[derive(Debug)] - pub struct FinalTypeDeserializer { - base_value: Option, - intermediate_value: Option, - final_value: Option, - state__: Box, + pub struct DogTypeDeserializer { + id: i32, + name: String, + state__: Box, } #[derive(Debug)] - enum FinalTypeDeserializerState { + enum DogTypeDeserializerState { Init__, Unknown__, } - impl FinalTypeDeserializer { + impl DogTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut base_value: Option = None; - let mut intermediate_value: Option = None; - let mut final_value: Option = None; + let mut id: Option = None; + let mut name: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"baseValue") + Some(b"id") ) { - helper.read_attrib(&mut base_value, b"baseValue", &attrib.value)?; + helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"intermediateValue") + Some(b"name") ) { - helper.read_attrib( - &mut intermediate_value, - b"intermediateValue", - &attrib.value, - )?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"finalValue") - ) { - helper.read_attrib(&mut final_value, b"finalValue", &attrib.value)?; + helper.read_attrib(&mut name, b"name", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - base_value: base_value, - intermediate_value: intermediate_value, - final_value: final_value, - state__: Box::new(FinalTypeDeserializerState::Init__), + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + state__: Box::new(DogTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: FinalTypeDeserializerState, + state: DogTypeDeserializerState, ) -> Result<(), Error> { Ok(()) } } - impl<'de> Deserializer<'de, super::FinalType> for FinalTypeDeserializer { + impl<'de> Deserializer<'de, super::DogType> for DogTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::FinalType> { + ) -> DeserializerResult<'de, super::DogType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::FinalType> { + ) -> DeserializerResult<'de, super::DogType> { if let Event::End(_) = &event { Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), @@ -560,115 +575,105 @@ pub mod quick_xml_deserialize { }) } } - fn finish(mut self, helper: &mut DeserializeHelper) -> Result { - let state = replace(&mut *self.state__, FinalTypeDeserializerState::Unknown__); + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, DogTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::FinalType { - base_value: self.base_value, - intermediate_value: self.intermediate_value, - final_value: self.final_value, + Ok(super::DogType { + id: self.id, + name: self.name, }) } } #[derive(Debug)] - pub enum IntermediateDeserializer { - Intermediate(::Deserializer), - Final(::Deserializer), + pub struct LabradorTypeDeserializer { + id: i32, + name: String, + color: String, + state__: Box, } - impl<'de> Deserializer<'de, super::Intermediate> for IntermediateDeserializer { - fn init( + #[derive(Debug)] + enum LabradorTypeDeserializerState { + Init__, + Unknown__, + } + impl LabradorTypeDeserializer { + fn from_bytes_start( helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::Intermediate> { - let Some(type_name) = helper.get_dynamic_type_name(&event)? else { - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::None, - event: DeserializerEvent::None, - allow_any: false, - }); - }; - let type_name = type_name.into_owned(); - if matches!( - helper.resolve_local_name(QName(&type_name), &super::NS_TNS), - Some(b"intermediate") - ) { - let DeserializerOutput { - artifact, - event, - allow_any, - } = ::init(helper, event)?; - return Ok(DeserializerOutput { - artifact: artifact.map( - |x| super::Intermediate(Box::new(x)), - |x| Self::Intermediate(x), - ), - event, - allow_any, - }); - } - if matches!( - helper.resolve_local_name(QName(&type_name), &super::NS_TNS), - Some(b"final") - ) { - let DeserializerOutput { - artifact, - event, - allow_any, - } = ::init(helper, event)?; - return Ok(DeserializerOutput { - artifact: artifact - .map(|x| super::Intermediate(Box::new(x)), |x| Self::Final(x)), - event, - allow_any, - }); + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + let mut color: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"color") + ) { + helper.read_attrib(&mut color, b"color", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } } - Ok(DeserializerOutput { - artifact: DeserializerArtifact::None, - event: DeserializerEvent::Break(event), - allow_any: false, + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + color: color.ok_or_else(|| ErrorKind::MissingAttribute("color".into()))?, + state__: Box::new(LabradorTypeDeserializerState::Init__), }) } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: LabradorTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::LabradorType> for LabradorTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LabradorType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } fn next( - self, + mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Intermediate> { - match self { - Self::Intermediate(x) => { - let DeserializerOutput { - artifact, - event, - allow_any, - } = x.next(helper, event)?; - Ok(DeserializerOutput { - artifact: artifact.map( - |x| super::Intermediate(Box::new(x)), - |x| Self::Intermediate(x), - ), - event, - allow_any, - }) - } - Self::Final(x) => { - let DeserializerOutput { - artifact, - event, - allow_any, - } = x.next(helper, event)?; - Ok(DeserializerOutput { - artifact: artifact - .map(|x| super::Intermediate(Box::new(x)), |x| Self::Final(x)), - event, - allow_any, - }) - } + ) -> DeserializerResult<'de, super::LabradorType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) } } - fn finish(self, helper: &mut DeserializeHelper) -> Result { - match self { - Self::Intermediate(x) => Ok(super::Intermediate(Box::new(x.finish(helper)?))), - Self::Final(x) => Ok(super::Intermediate(Box::new(x.finish(helper)?))), - } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, LabradorTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::LabradorType { + id: self.id, + name: self.name, + color: self.color, + }) } } } @@ -686,7 +691,7 @@ pub mod quick_xml_serialize { #[derive(Debug)] pub(super) enum ListTypeSerializerState<'ser> { Init__, - Base(IterSerializer<'ser, &'ser [super::Base], super::Base>), + Animal(IterSerializer<'ser, &'ser [super::Animal], super::Animal>), End__, Done__, Phantom__(&'ser ()), @@ -699,9 +704,9 @@ pub mod quick_xml_serialize { loop { match &mut *self.state { ListTypeSerializerState::Init__ => { - *self.state = ListTypeSerializerState::Base(IterSerializer::new( - &self.value.base[..], - Some("base"), + *self.state = ListTypeSerializerState::Animal(IterSerializer::new( + &self.value.animal[..], + Some("animal"), false, )); let mut bytes = BytesStart::new(self.name); @@ -711,7 +716,7 @@ pub mod quick_xml_serialize { } return Ok(Some(Event::Start(bytes))); } - ListTypeSerializerState::Base(x) => match x.next(helper).transpose()? { + ListTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = ListTypeSerializerState::End__, }, @@ -739,113 +744,150 @@ pub mod quick_xml_serialize { } } #[derive(Debug)] - pub struct IntermediateTypeSerializer<'ser> { - pub(super) value: &'ser super::IntermediateType, - pub(super) state: Box>, + pub struct AnimalTypeSerializer<'ser> { + pub(super) value: &'ser super::AnimalType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum AnimalTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> AnimalTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + AnimalTypeSerializerState::Init__ => { + *self.state = AnimalTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + AnimalTypeSerializerState::Done__ => return Ok(None), + AnimalTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for AnimalTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = AnimalTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct DogTypeSerializer<'ser> { + pub(super) value: &'ser super::DogType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum IntermediateTypeSerializerState<'ser> { + pub(super) enum DogTypeSerializerState<'ser> { Init__, Done__, Phantom__(&'ser ()), } - impl<'ser> IntermediateTypeSerializer<'ser> { + impl<'ser> DogTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - IntermediateTypeSerializerState::Init__ => { - *self.state = IntermediateTypeSerializerState::Done__; + DogTypeSerializerState::Init__ => { + *self.state = DogTypeSerializerState::Done__; let mut bytes = BytesStart::new(self.name); helper.begin_ns_scope(); if self.is_root { helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); } - helper.write_attrib_opt(&mut bytes, "baseValue", &self.value.base_value)?; - helper.write_attrib_opt( - &mut bytes, - "intermediateValue", - &self.value.intermediate_value, - )?; + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; helper.end_ns_scope(); return Ok(Some(Event::Empty(bytes))); } - IntermediateTypeSerializerState::Done__ => return Ok(None), - IntermediateTypeSerializerState::Phantom__(_) => unreachable!(), + DogTypeSerializerState::Done__ => return Ok(None), + DogTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for IntermediateTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for DogTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = IntermediateTypeSerializerState::Done__; + *self.state = DogTypeSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct FinalTypeSerializer<'ser> { - pub(super) value: &'ser super::FinalType, - pub(super) state: Box>, + pub struct LabradorTypeSerializer<'ser> { + pub(super) value: &'ser super::LabradorType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum FinalTypeSerializerState<'ser> { + pub(super) enum LabradorTypeSerializerState<'ser> { Init__, Done__, Phantom__(&'ser ()), } - impl<'ser> FinalTypeSerializer<'ser> { + impl<'ser> LabradorTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - FinalTypeSerializerState::Init__ => { - *self.state = FinalTypeSerializerState::Done__; + LabradorTypeSerializerState::Init__ => { + *self.state = LabradorTypeSerializerState::Done__; let mut bytes = BytesStart::new(self.name); helper.begin_ns_scope(); if self.is_root { helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); } - helper.write_attrib_opt(&mut bytes, "baseValue", &self.value.base_value)?; - helper.write_attrib_opt( - &mut bytes, - "intermediateValue", - &self.value.intermediate_value, - )?; - helper.write_attrib_opt( - &mut bytes, - "finalValue", - &self.value.final_value, - )?; + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "color", &self.value.color)?; helper.end_ns_scope(); return Ok(Some(Event::Empty(bytes))); } - FinalTypeSerializerState::Done__ => return Ok(None), - FinalTypeSerializerState::Phantom__(_) => unreachable!(), + LabradorTypeSerializerState::Done__ => return Ok(None), + LabradorTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for FinalTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for LabradorTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = FinalTypeSerializerState::Done__; + *self.state = LabradorTypeSerializerState::Done__; Some(Err(error)) } } diff --git a/xsd-parser/tests/feature/dynamic_types/expected/quick_xml_optimized.rs b/xsd-parser/tests/feature/substitution_group/expected/quick_xml_optimized.rs similarity index 53% rename from xsd-parser/tests/feature/dynamic_types/expected/quick_xml_optimized.rs rename to xsd-parser/tests/feature/substitution_group/expected/quick_xml_optimized.rs index 66d444e2..888b8809 100644 --- a/xsd-parser/tests/feature/dynamic_types/expected/quick_xml_optimized.rs +++ b/xsd-parser/tests/feature/substitution_group/expected/quick_xml_optimized.rs @@ -13,7 +13,7 @@ pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns"); pub type List = ListType; #[derive(Debug)] pub struct ListType { - pub base: Vec, + pub animal: Vec, } impl WithSerializer for ListType { type Serializer<'x> = quick_xml_serialize::ListTypeSerializer<'x>; @@ -34,74 +34,97 @@ impl WithDeserializer for ListType { type Deserializer = quick_xml_deserialize::ListTypeDeserializer; } #[derive(Debug)] -pub enum Base { - Intermediate(IntermediateType), - Final(FinalType), +pub enum Animal { + Animal(AnimalType), + Dog(DogType), + Labrador(LabradorType), } -impl WithSerializer for Base { - type Serializer<'x> = quick_xml_serialize::BaseSerializer<'x>; +impl WithSerializer for Animal { + type Serializer<'x> = quick_xml_serialize::AnimalSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { let _name = name; - Ok(quick_xml_serialize::BaseSerializer { + Ok(quick_xml_serialize::AnimalSerializer { value: self, - state: Box::new(quick_xml_serialize::BaseSerializerState::Init__), + state: Box::new(quick_xml_serialize::AnimalSerializerState::Init__), is_root, }) } } -impl WithDeserializer for Base { - type Deserializer = quick_xml_deserialize::BaseDeserializer; +impl WithDeserializer for Animal { + type Deserializer = quick_xml_deserialize::AnimalDeserializer; } #[derive(Debug)] -pub struct IntermediateType { - pub base_value: Option, - pub intermediate_value: Option, +pub struct AnimalType { + pub id: i32, } -impl WithSerializer for IntermediateType { - type Serializer<'x> = quick_xml_serialize::IntermediateTypeSerializer<'x>; +impl WithSerializer for AnimalType { + type Serializer<'x> = quick_xml_serialize::AnimalTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::IntermediateTypeSerializer { + Ok(quick_xml_serialize::AnimalTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::IntermediateTypeSerializerState::Init__), - name: name.unwrap_or("intermediate"), + state: Box::new(quick_xml_serialize::AnimalTypeSerializerState::Init__), + name: name.unwrap_or("animal"), is_root, }) } } -impl WithDeserializer for IntermediateType { - type Deserializer = quick_xml_deserialize::IntermediateTypeDeserializer; +impl WithDeserializer for AnimalType { + type Deserializer = quick_xml_deserialize::AnimalTypeDeserializer; } #[derive(Debug)] -pub struct FinalType { - pub base_value: Option, - pub intermediate_value: Option, - pub final_value: Option, +pub struct DogType { + pub id: i32, + pub name: String, } -impl WithSerializer for FinalType { - type Serializer<'x> = quick_xml_serialize::FinalTypeSerializer<'x>; +impl WithSerializer for DogType { + type Serializer<'x> = quick_xml_serialize::DogTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::FinalTypeSerializer { + Ok(quick_xml_serialize::DogTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::FinalTypeSerializerState::Init__), - name: name.unwrap_or("final"), + state: Box::new(quick_xml_serialize::DogTypeSerializerState::Init__), + name: name.unwrap_or("dog"), is_root, }) } } -impl WithDeserializer for FinalType { - type Deserializer = quick_xml_deserialize::FinalTypeDeserializer; +impl WithDeserializer for DogType { + type Deserializer = quick_xml_deserialize::DogTypeDeserializer; +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl WithSerializer for LabradorType { + type Serializer<'x> = quick_xml_serialize::LabradorTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::LabradorTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::LabradorTypeSerializerState::Init__), + name: name.unwrap_or("labrador"), + is_root, + }) + } +} +impl WithDeserializer for LabradorType { + type Deserializer = quick_xml_deserialize::LabradorTypeDeserializer; } pub mod quick_xml_deserialize { use core::mem::replace; @@ -112,13 +135,13 @@ pub mod quick_xml_deserialize { }; #[derive(Debug)] pub struct ListTypeDeserializer { - base: Vec, + animal: Vec, state__: Box, } #[derive(Debug)] enum ListTypeDeserializerState { Init__, - Base(Option<::Deserializer>), + Animal(Option<::Deserializer>), Done__, Unknown__, } @@ -132,7 +155,7 @@ pub mod quick_xml_deserialize { helper.raise_unexpected_attrib_checked(&attrib)?; } Ok(Self { - base: Vec::new(), + animal: Vec::new(), state__: Box::new(ListTypeDeserializerState::Init__), }) } @@ -143,19 +166,19 @@ pub mod quick_xml_deserialize { ) -> Result<(), Error> { use ListTypeDeserializerState as S; match state { - S::Base(Some(deserializer)) => self.store_base(deserializer.finish(helper)?)?, + S::Animal(Some(deserializer)) => self.store_animal(deserializer.finish(helper)?)?, _ => (), } Ok(()) } - fn store_base(&mut self, value: super::Base) -> Result<(), Error> { - self.base.push(value); + fn store_animal(&mut self, value: super::Animal) -> Result<(), Error> { + self.animal.push(value); Ok(()) } - fn handle_base<'de>( + fn handle_animal<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::Base>, + output: DeserializerOutput<'de, super::Animal>, fallback: &mut Option, ) -> Result, Error> { use ListTypeDeserializerState as S; @@ -174,13 +197,13 @@ pub mod quick_xml_deserialize { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_base(data)?; - *self.state__ = S::Base(None); + self.store_animal(data)?; + *self.state__ = S::Animal(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Base(Some(deserializer))); - *self.state__ = S::Base(None); + fallback.get_or_insert(S::Animal(Some(deserializer))); + *self.state__ = S::Animal(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } } @@ -206,9 +229,9 @@ pub mod quick_xml_deserialize { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Base(Some(deserializer)), event) => { + (S::Animal(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_base(helper, output, &mut fallback)? { + match self.handle_animal(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -230,12 +253,12 @@ pub mod quick_xml_deserialize { } (S::Init__, event) => { fallback.get_or_insert(S::Init__); - *self.state__ = S::Base(None); + *self.state__ = S::Animal(None); event } - (S::Base(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = ::init(helper, event)?; - match self.handle_base(helper, output, &mut fallback)? { + (S::Animal(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = ::init(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -267,30 +290,37 @@ pub mod quick_xml_deserialize { fn finish(mut self, helper: &mut DeserializeHelper) -> Result { let state = replace(&mut *self.state__, ListTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::ListType { base: self.base }) + Ok(super::ListType { + animal: self.animal, + }) } } #[derive(Debug)] - pub struct BaseDeserializer { - state__: Box, + pub struct AnimalDeserializer { + state__: Box, } #[derive(Debug)] - pub enum BaseDeserializerState { + pub enum AnimalDeserializerState { Init__, - Intermediate( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Animal( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Dog( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Final( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Labrador( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Done__(super::Base), + Done__(super::Animal), Unknown__, } - impl BaseDeserializer { + impl AnimalDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, @@ -299,82 +329,141 @@ pub mod quick_xml_deserialize { if let Event::Start(x) | Event::Empty(x) = &event { if matches!( helper.resolve_local_name(x.name(), &super::NS_TNS), - Some(b"intermediate") + Some(b"animal") ) { - let output = - ::init(helper, event)?; - return self.handle_intermediate(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_animal(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_TNS), - Some(b"final") + Some(b"dog") ) { - let output = ::init(helper, event)?; - return self.handle_final_(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_dog(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_TNS), + Some(b"labrador") + ) { + let output = ::init(helper, event)?; + return self.handle_labrador(helper, Default::default(), None, output); } } - *self.state__ = BaseDeserializerState::Init__; + *self.state__ = AnimalDeserializerState::Init__; Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( helper: &mut DeserializeHelper, - state: BaseDeserializerState, - ) -> Result { - use BaseDeserializerState as S; + state: AnimalDeserializerState, + ) -> Result { + use AnimalDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Intermediate(mut values, None, deserializer) => { + S::Animal(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_intermediate(&mut values, value)?; + Self::store_animal(&mut values, value)?; } - Ok(super::Base::Intermediate( - helper.finish_element("intermediate", values)?, + Ok(super::Animal::Animal( + helper.finish_element("animal", values)?, )) } - S::Final(mut values, None, deserializer) => { + S::Dog(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_final_(&mut values, value)?; + Self::store_dog(&mut values, value)?; } - Ok(super::Base::Final(helper.finish_element("final", values)?)) + Ok(super::Animal::Dog(helper.finish_element("dog", values)?)) + } + S::Labrador(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_labrador(&mut values, value)?; + } + Ok(super::Animal::Labrador( + helper.finish_element("labrador", values)?, + )) } S::Done__(data) => Ok(data), _ => unreachable!(), } } - fn store_intermediate( - values: &mut Option, - value: super::IntermediateType, + fn store_animal( + values: &mut Option, + value: super::AnimalType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"intermediate", + b"animal", )))?; } *values = Some(value); Ok(()) } - fn store_final_( - values: &mut Option, - value: super::FinalType, + fn store_dog( + values: &mut Option, + value: super::DogType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"dog")))?; + } + *values = Some(value); + Ok(()) + } + fn store_labrador( + values: &mut Option, + value: super::LabradorType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"final", + b"labrador", )))?; } *values = Some(value); Ok(()) } - fn handle_intermediate<'de>( + fn handle_animal<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnimalType>, + ) -> Result, Error> { + use AnimalDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_animal(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_animal(&mut values, data)?; + let data = Self::finish_state(helper, S::Animal(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Animal(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_dog<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::IntermediateType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::DogType>, ) -> Result, Error> { - use BaseDeserializerState as S; + use AnimalDeserializerState as S; let DeserializerOutput { artifact, event, @@ -385,30 +474,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_intermediate(&mut values, data)?; + Self::store_dog(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_intermediate(&mut values, data)?; - let data = Self::finish_state(helper, S::Intermediate(values, None, None))?; + Self::store_dog(&mut values, data)?; + let data = Self::finish_state(helper, S::Dog(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Intermediate(values, None, Some(deserializer)); + *self.state__ = S::Dog(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_final_<'de>( + fn handle_labrador<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FinalType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LabradorType>, ) -> Result, Error> { - use BaseDeserializerState as S; + use AnimalDeserializerState as S; let DeserializerOutput { artifact, event, @@ -419,35 +508,35 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_final_(&mut values, data)?; + Self::store_labrador(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_final_(&mut values, data)?; - let data = Self::finish_state(helper, S::Final(values, None, None))?; + Self::store_labrador(&mut values, data)?; + let data = Self::finish_state(helper, S::Labrador(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Final(values, None, Some(deserializer)); + *self.state__ = S::Labrador(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::Base> for BaseDeserializer { + impl<'de> Deserializer<'de, super::Animal> for AnimalDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Base> { + ) -> DeserializerResult<'de, super::Animal> { let deserializer = Self { - state__: Box::new(BaseDeserializerState::Init__), + state__: Box::new(AnimalDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, BaseDeserializerState::Init__) => + if matches!(&*x.state__, AnimalDeserializerState::Init__) => { DeserializerArtifact::None } @@ -459,25 +548,34 @@ pub mod quick_xml_deserialize { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Base> { - use BaseDeserializerState as S; + ) -> DeserializerResult<'de, super::Animal> { + use AnimalDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Intermediate(values, fallback, Some(deserializer)), event) => { + (S::Animal(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_intermediate(helper, values, fallback, output)? { + match self.handle_animal(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Final(values, fallback, Some(deserializer)), event) => { + (S::Dog(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_final_(helper, values, fallback, output)? { + match self.handle_dog(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Labrador(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_labrador(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -500,16 +598,16 @@ pub mod quick_xml_deserialize { ElementHandlerOutput::Continue { event, .. } => event, }, ( - S::Intermediate(values, fallback, None), + S::Animal(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_TNS), - b"intermediate", + b"animal", false, )?; - match self.handle_intermediate(helper, values, fallback, output)? { + match self.handle_animal(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -517,16 +615,33 @@ pub mod quick_xml_deserialize { } } ( - S::Final(values, fallback, None), + S::Dog(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_TNS), - b"final", + b"dog", false, )?; - match self.handle_final_(helper, values, fallback, output)? { + match self.handle_dog(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Labrador(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_TNS), + b"labrador", + false, + )?; + match self.handle_labrador(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -554,74 +669,142 @@ pub mod quick_xml_deserialize { allow_any, }) } - fn finish(self, helper: &mut DeserializeHelper) -> Result { + fn finish(self, helper: &mut DeserializeHelper) -> Result { Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct IntermediateTypeDeserializer { - base_value: Option, - intermediate_value: Option, - state__: Box, + pub struct AnimalTypeDeserializer { + id: i32, + state__: Box, } #[derive(Debug)] - enum IntermediateTypeDeserializerState { + enum AnimalTypeDeserializerState { Init__, Unknown__, } - impl IntermediateTypeDeserializer { + impl AnimalTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut base_value: Option = None; - let mut intermediate_value: Option = None; + let mut id: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"baseValue") + Some(b"id") ) { - helper.read_attrib(&mut base_value, b"baseValue", &attrib.value)?; + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + state__: Box::new(AnimalTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: AnimalTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::AnimalType> for AnimalTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, AnimalTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::AnimalType { id: self.id }) + } + } + #[derive(Debug)] + pub struct DogTypeDeserializer { + id: i32, + name: String, + state__: Box, + } + #[derive(Debug)] + enum DogTypeDeserializerState { + Init__, + Unknown__, + } + impl DogTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"intermediateValue") + Some(b"name") ) { - helper.read_attrib( - &mut intermediate_value, - b"intermediateValue", - &attrib.value, - )?; + helper.read_attrib(&mut name, b"name", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - base_value: base_value, - intermediate_value: intermediate_value, - state__: Box::new(IntermediateTypeDeserializerState::Init__), + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + state__: Box::new(DogTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: IntermediateTypeDeserializerState, + state: DogTypeDeserializerState, ) -> Result<(), Error> { Ok(()) } } - impl<'de> Deserializer<'de, super::IntermediateType> for IntermediateTypeDeserializer { + impl<'de> Deserializer<'de, super::DogType> for DogTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::IntermediateType> { + ) -> DeserializerResult<'de, super::DogType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::IntermediateType> { + ) -> DeserializerResult<'de, super::DogType> { if let Event::End(_) = &event { Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), @@ -636,93 +819,83 @@ pub mod quick_xml_deserialize { }) } } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - IntermediateTypeDeserializerState::Unknown__, - ); + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, DogTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::IntermediateType { - base_value: self.base_value, - intermediate_value: self.intermediate_value, + Ok(super::DogType { + id: self.id, + name: self.name, }) } } #[derive(Debug)] - pub struct FinalTypeDeserializer { - base_value: Option, - intermediate_value: Option, - final_value: Option, - state__: Box, + pub struct LabradorTypeDeserializer { + id: i32, + name: String, + color: String, + state__: Box, } #[derive(Debug)] - enum FinalTypeDeserializerState { + enum LabradorTypeDeserializerState { Init__, Unknown__, } - impl FinalTypeDeserializer { + impl LabradorTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut base_value: Option = None; - let mut intermediate_value: Option = None; - let mut final_value: Option = None; + let mut id: Option = None; + let mut name: Option = None; + let mut color: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"baseValue") + Some(b"id") ) { - helper.read_attrib(&mut base_value, b"baseValue", &attrib.value)?; + helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"intermediateValue") + Some(b"name") ) { - helper.read_attrib( - &mut intermediate_value, - b"intermediateValue", - &attrib.value, - )?; + helper.read_attrib(&mut name, b"name", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"finalValue") + Some(b"color") ) { - helper.read_attrib(&mut final_value, b"finalValue", &attrib.value)?; + helper.read_attrib(&mut color, b"color", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - base_value: base_value, - intermediate_value: intermediate_value, - final_value: final_value, - state__: Box::new(FinalTypeDeserializerState::Init__), + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + color: color.ok_or_else(|| ErrorKind::MissingAttribute("color".into()))?, + state__: Box::new(LabradorTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: FinalTypeDeserializerState, + state: LabradorTypeDeserializerState, ) -> Result<(), Error> { Ok(()) } } - impl<'de> Deserializer<'de, super::FinalType> for FinalTypeDeserializer { + impl<'de> Deserializer<'de, super::LabradorType> for LabradorTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::FinalType> { + ) -> DeserializerResult<'de, super::LabradorType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::FinalType> { + ) -> DeserializerResult<'de, super::LabradorType> { if let Event::End(_) = &event { Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), @@ -737,13 +910,13 @@ pub mod quick_xml_deserialize { }) } } - fn finish(mut self, helper: &mut DeserializeHelper) -> Result { - let state = replace(&mut *self.state__, FinalTypeDeserializerState::Unknown__); + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, LabradorTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::FinalType { - base_value: self.base_value, - intermediate_value: self.intermediate_value, - final_value: self.final_value, + Ok(super::LabradorType { + id: self.id, + name: self.name, + color: self.color, }) } } @@ -763,7 +936,7 @@ pub mod quick_xml_serialize { #[derive(Debug)] pub(super) enum ListTypeSerializerState<'ser> { Init__, - Base(IterSerializer<'ser, &'ser [super::Base], super::Base>), + Animal(IterSerializer<'ser, &'ser [super::Animal], super::Animal>), End__, Done__, Phantom__(&'ser ()), @@ -776,9 +949,9 @@ pub mod quick_xml_serialize { loop { match &mut *self.state { ListTypeSerializerState::Init__ => { - *self.state = ListTypeSerializerState::Base(IterSerializer::new( - &self.value.base[..], - Some("base"), + *self.state = ListTypeSerializerState::Animal(IterSerializer::new( + &self.value.animal[..], + Some("animal"), false, )); let mut bytes = BytesStart::new(self.name); @@ -788,7 +961,7 @@ pub mod quick_xml_serialize { } return Ok(Some(Event::Start(bytes))); } - ListTypeSerializerState::Base(x) => match x.next(helper).transpose()? { + ListTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = ListTypeSerializerState::End__, }, @@ -816,174 +989,221 @@ pub mod quick_xml_serialize { } } #[derive(Debug)] - pub struct BaseSerializer<'ser> { - pub(super) value: &'ser super::Base, - pub(super) state: Box>, + pub struct AnimalSerializer<'ser> { + pub(super) value: &'ser super::Animal, + pub(super) state: Box>, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum BaseSerializerState<'ser> { + pub(super) enum AnimalSerializerState<'ser> { Init__, - Intermediate(::Serializer<'ser>), - Final(::Serializer<'ser>), + Animal(::Serializer<'ser>), + Dog(::Serializer<'ser>), + Labrador(::Serializer<'ser>), Done__, Phantom__(&'ser ()), } - impl<'ser> BaseSerializer<'ser> { + impl<'ser> AnimalSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - BaseSerializerState::Init__ => match self.value { - super::Base::Intermediate(x) => { - *self.state = BaseSerializerState::Intermediate( - WithSerializer::serializer(x, Some("intermediate"), self.is_root)?, - ) - } - super::Base::Final(x) => { - *self.state = BaseSerializerState::Final(WithSerializer::serializer( - x, - Some("final"), - self.is_root, - )?) + AnimalSerializerState::Init__ => { + match self.value { + super::Animal::Animal(x) => { + *self.state = AnimalSerializerState::Animal( + WithSerializer::serializer(x, Some("animal"), self.is_root)?, + ) + } + super::Animal::Dog(x) => { + *self.state = AnimalSerializerState::Dog( + WithSerializer::serializer(x, Some("dog"), self.is_root)?, + ) + } + super::Animal::Labrador(x) => { + *self.state = AnimalSerializerState::Labrador( + WithSerializer::serializer(x, Some("labrador"), self.is_root)?, + ) + } } + } + AnimalSerializerState::Animal(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AnimalSerializerState::Done__, }, - BaseSerializerState::Intermediate(x) => match x.next(helper).transpose()? { + AnimalSerializerState::Dog(x) => match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = BaseSerializerState::Done__, + None => *self.state = AnimalSerializerState::Done__, }, - BaseSerializerState::Final(x) => match x.next(helper).transpose()? { + AnimalSerializerState::Labrador(x) => match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = BaseSerializerState::Done__, + None => *self.state = AnimalSerializerState::Done__, }, - BaseSerializerState::Done__ => return Ok(None), - BaseSerializerState::Phantom__(_) => unreachable!(), + AnimalSerializerState::Done__ => return Ok(None), + AnimalSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for BaseSerializer<'ser> { + impl<'ser> Serializer<'ser> for AnimalSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = BaseSerializerState::Done__; + *self.state = AnimalSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct IntermediateTypeSerializer<'ser> { - pub(super) value: &'ser super::IntermediateType, - pub(super) state: Box>, + pub struct AnimalTypeSerializer<'ser> { + pub(super) value: &'ser super::AnimalType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum IntermediateTypeSerializerState<'ser> { + pub(super) enum AnimalTypeSerializerState<'ser> { Init__, Done__, Phantom__(&'ser ()), } - impl<'ser> IntermediateTypeSerializer<'ser> { + impl<'ser> AnimalTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - IntermediateTypeSerializerState::Init__ => { - *self.state = IntermediateTypeSerializerState::Done__; + AnimalTypeSerializerState::Init__ => { + *self.state = AnimalTypeSerializerState::Done__; let mut bytes = BytesStart::new(self.name); helper.begin_ns_scope(); if self.is_root { helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); } - helper.write_attrib_opt(&mut bytes, "baseValue", &self.value.base_value)?; - helper.write_attrib_opt( - &mut bytes, - "intermediateValue", - &self.value.intermediate_value, - )?; + helper.write_attrib(&mut bytes, "id", &self.value.id)?; helper.end_ns_scope(); return Ok(Some(Event::Empty(bytes))); } - IntermediateTypeSerializerState::Done__ => return Ok(None), - IntermediateTypeSerializerState::Phantom__(_) => unreachable!(), + AnimalTypeSerializerState::Done__ => return Ok(None), + AnimalTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for IntermediateTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for AnimalTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = IntermediateTypeSerializerState::Done__; + *self.state = AnimalTypeSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct FinalTypeSerializer<'ser> { - pub(super) value: &'ser super::FinalType, - pub(super) state: Box>, + pub struct DogTypeSerializer<'ser> { + pub(super) value: &'ser super::DogType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum FinalTypeSerializerState<'ser> { + pub(super) enum DogTypeSerializerState<'ser> { Init__, Done__, Phantom__(&'ser ()), } - impl<'ser> FinalTypeSerializer<'ser> { + impl<'ser> DogTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - FinalTypeSerializerState::Init__ => { - *self.state = FinalTypeSerializerState::Done__; + DogTypeSerializerState::Init__ => { + *self.state = DogTypeSerializerState::Done__; let mut bytes = BytesStart::new(self.name); helper.begin_ns_scope(); if self.is_root { helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); } - helper.write_attrib_opt(&mut bytes, "baseValue", &self.value.base_value)?; - helper.write_attrib_opt( - &mut bytes, - "intermediateValue", - &self.value.intermediate_value, - )?; - helper.write_attrib_opt( - &mut bytes, - "finalValue", - &self.value.final_value, - )?; + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + DogTypeSerializerState::Done__ => return Ok(None), + DogTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for DogTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = DogTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct LabradorTypeSerializer<'ser> { + pub(super) value: &'ser super::LabradorType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum LabradorTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> LabradorTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + LabradorTypeSerializerState::Init__ => { + *self.state = LabradorTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "color", &self.value.color)?; helper.end_ns_scope(); return Ok(Some(Event::Empty(bytes))); } - FinalTypeSerializerState::Done__ => return Ok(None), - FinalTypeSerializerState::Phantom__(_) => unreachable!(), + LabradorTypeSerializerState::Done__ => return Ok(None), + LabradorTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for FinalTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for LabradorTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = FinalTypeSerializerState::Done__; + *self.state = LabradorTypeSerializerState::Done__; Some(Err(error)) } } diff --git a/xsd-parser/tests/feature/substitution_group/mod.rs b/xsd-parser/tests/feature/substitution_group/mod.rs new file mode 100644 index 00000000..65ae577f --- /dev/null +++ b/xsd-parser/tests/feature/substitution_group/mod.rs @@ -0,0 +1,208 @@ +use xsd_parser::{ + config::{GeneratorFlags, OptimizerFlags}, + Config, IdentType, +}; + +use crate::utils::{generate_test, ConfigEx}; + +fn config() -> Config { + Config::test_default() + .with_derive(["Debug"]) + .with_generator_flags(GeneratorFlags::FLATTEN_CONTENT) + .with_generate([(IdentType::Element, "tns:list")]) +} + +/* default */ + +#[test] +fn generate_default() { + generate_test( + "tests/feature/substitution_group/schema.xsd", + "tests/feature/substitution_group/expected/default.rs", + config(), + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod default { + #![allow(unused_imports)] + + include!("expected/default.rs"); +} + +/* default (optimized) */ + +#[test] +fn generate_default_optimized() { + generate_test( + "tests/feature/substitution_group/schema.xsd", + "tests/feature/substitution_group/expected/default_optimized.rs", + config().with_optimizer_flags(OptimizerFlags::all()), + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod default_optmized { + #![allow(unused_imports)] + + include!("expected/default_optimized.rs"); +} + +/* quick_xml */ + +#[test] +fn generate_quick_xml() { + generate_test( + "tests/feature/substitution_group/schema.xsd", + "tests/feature/substitution_group/expected/quick_xml.rs", + config().with_quick_xml(), + ); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn read_quick_xml() { + use quick_xml::{AnimalType, DogType, LabradorType, List}; + + let obj = crate::utils::quick_xml_read_test::( + "tests/feature/substitution_group/example/default.xml", + ); + + let mut items = obj.animal.iter(); + + // The head element `animal` may appear directly. + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 1); + + // `` substitutes `` and is selected by its element name. + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 2); + assert_eq!(item.name, "Rex"); + + // `` (transitively) substitutes `` via ``. + let item = items.next().unwrap(); + let item = item.0.as_any().downcast_ref::().unwrap(); + assert_eq!(item.id, 3); + assert_eq!(item.name, "Buddy"); + assert_eq!(item.color, "black"); + + assert!(items.next().is_none()); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn write_quick_xml() { + use quick_xml::{Animal, AnimalType, DogType, LabradorType, List}; + + let obj = List { + animal: vec![ + Animal(Box::new(AnimalType { id: 1 })), + Animal(Box::new(DogType { + id: 2, + name: "Rex".into(), + })), + Animal(Box::new(LabradorType { + id: 3, + name: "Buddy".into(), + color: "black".into(), + })), + ], + }; + + crate::utils::quick_xml_write_test( + &obj, + "list", + "tests/feature/substitution_group/example/default.xml", + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod quick_xml { + #![allow(unused_imports)] + + include!("expected/quick_xml.rs"); +} + +/* quick_xml (optimized) */ + +#[test] +fn generate_quick_xml_optimized() { + generate_test( + "tests/feature/substitution_group/schema.xsd", + "tests/feature/substitution_group/expected/quick_xml_optimized.rs", + config() + .with_quick_xml() + .with_optimizer_flags(OptimizerFlags::all()), + ); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn read_quick_xml_optimized() { + use quick_xml_optimized::{Animal, List}; + + let obj = crate::utils::quick_xml_read_test::( + "tests/feature/substitution_group/example/default.xml", + ); + + let mut items = obj.animal.into_iter(); + + let item = items.next().unwrap(); + let Animal::Animal(item) = item else { + panic!("Expected `Animal::Animal`"); + }; + assert_eq!(item.id, 1); + + let item = items.next().unwrap(); + let Animal::Dog(item) = item else { + panic!("Expected `Animal::Dog`"); + }; + assert_eq!(item.id, 2); + assert_eq!(item.name, "Rex"); + + let item = items.next().unwrap(); + let Animal::Labrador(item) = item else { + panic!("Expected `Animal::Labrador`"); + }; + assert_eq!(item.id, 3); + assert_eq!(item.name, "Buddy"); + assert_eq!(item.color, "black"); + + assert!(items.next().is_none()); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn write_quick_xml_optimized() { + use quick_xml_optimized::{Animal, AnimalType, DogType, LabradorType, List}; + + let obj = List { + animal: vec![ + Animal::Animal(AnimalType { id: 1 }), + Animal::Dog(DogType { + id: 2, + name: "Rex".into(), + }), + Animal::Labrador(LabradorType { + id: 3, + name: "Buddy".into(), + color: "black".into(), + }), + ], + }; + + crate::utils::quick_xml_write_test( + &obj, + "list", + "tests/feature/substitution_group/example/default.xml", + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod quick_xml_optimized { + #![allow(unused_imports)] + + include!("expected/quick_xml_optimized.rs"); +} diff --git a/xsd-parser/tests/feature/substitution_group/schema.xsd b/xsd-parser/tests/feature/substitution_group/schema.xsd new file mode 100644 index 00000000..26d2cd73 --- /dev/null +++ b/xsd-parser/tests/feature/substitution_group/schema.xsd @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/xsd-parser/tests/feature/substitution_group_nillable/example/default.xml b/xsd-parser/tests/feature/substitution_group_nillable/example/default.xml new file mode 100644 index 00000000..30f37b98 --- /dev/null +++ b/xsd-parser/tests/feature/substitution_group_nillable/example/default.xml @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/xsd-parser/tests/feature/substitution_group_nillable/expected/default.rs b/xsd-parser/tests/feature/substitution_group_nillable/expected/default.rs new file mode 100644 index 00000000..6ace6f91 --- /dev/null +++ b/xsd-parser/tests/feature/substitution_group_nillable/expected/default.rs @@ -0,0 +1,36 @@ +use core::fmt::Debug; +use xsd_parser_types::{xml::Nillable, AsAny}; +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +#[derive(Debug)] +pub struct Animal(pub Box); +pub trait AnimalTrait: Debug + AsAny {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +pub type AnimalDyn = Nillable; +impl AnimalTrait for AnimalDyn {} +pub type DogDyn = Nillable; +impl AnimalTrait for DogDyn {} +pub type LabradorDyn = Nillable; +impl AnimalTrait for LabradorDyn {} +#[derive(Debug)] +pub struct AnimalType { + pub id: i32, +} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} diff --git a/xsd-parser/tests/feature/substitution_group_nillable/expected/default_optimized.rs b/xsd-parser/tests/feature/substitution_group_nillable/expected/default_optimized.rs new file mode 100644 index 00000000..43b71a9d --- /dev/null +++ b/xsd-parser/tests/feature/substitution_group_nillable/expected/default_optimized.rs @@ -0,0 +1,30 @@ +use xsd_parser_types::xml::Nillable; +pub type List = ListType; +#[derive(Debug)] +pub struct ListType { + pub animal: Vec, +} +#[derive(Debug)] +pub enum Animal { + Animal(AnimalDyn), + Dog(DogDyn), + Labrador(LabradorDyn), +} +pub type AnimalDyn = Nillable; +pub type DogDyn = Nillable; +pub type LabradorDyn = Nillable; +#[derive(Debug)] +pub struct AnimalType { + pub id: i32, +} +#[derive(Debug)] +pub struct DogType { + pub id: i32, + pub name: String, +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} diff --git a/xsd-parser/tests/feature/nillable_dynamic_types/expected/quick_xml.rs b/xsd-parser/tests/feature/substitution_group_nillable/expected/quick_xml.rs similarity index 58% rename from xsd-parser/tests/feature/nillable_dynamic_types/expected/quick_xml.rs rename to xsd-parser/tests/feature/substitution_group_nillable/expected/quick_xml.rs index 17a60477..c7c57719 100644 --- a/xsd-parser/tests/feature/nillable_dynamic_types/expected/quick_xml.rs +++ b/xsd-parser/tests/feature/substitution_group_nillable/expected/quick_xml.rs @@ -16,7 +16,7 @@ pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns"); pub type List = ListType; #[derive(Debug)] pub struct ListType { - pub base: Vec, + pub animal: Vec, } impl WithSerializer for ListType { type Serializer<'x> = quick_xml_serialize::ListTypeSerializer<'x>; @@ -37,108 +37,126 @@ impl WithDeserializer for ListType { type Deserializer = quick_xml_deserialize::ListTypeDeserializer; } #[derive(Debug)] -pub struct Base(pub Box); -pub trait BaseTrait: Debug + AsAny + WithBoxedSerializer {} -impl WithSerializer for Base { +pub struct Animal(pub Box); +pub trait AnimalTrait: Debug + AsAny + WithBoxedSerializer {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +impl WithSerializer for Animal { type Serializer<'x> = BoxedSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - let _name = name; + if (*self.0).as_any().is::() { + return self.0.serializer(Some("animal"), is_root); + } + if (*self.0).as_any().is::() { + return self.0.serializer(Some("dog"), is_root); + } + if (*self.0).as_any().is::() { + return self.0.serializer(Some("labrador"), is_root); + } self.0.serializer(None, is_root) } } -impl WithDeserializer for Base { - type Deserializer = quick_xml_deserialize::BaseDeserializer; +impl WithDeserializer for Animal { + type Deserializer = quick_xml_deserialize::AnimalDeserializer; } -pub type IntermediateDyn = Nillable; -impl BaseTrait for IntermediateDyn {} -impl IntermediateTrait for IntermediateDyn {} -pub type FinalDyn = Nillable; -impl BaseTrait for FinalDyn {} -impl IntermediateTrait for FinalDyn {} +pub type AnimalDyn = Nillable; +impl AnimalTrait for AnimalDyn {} +pub type DogDyn = Nillable; +impl AnimalTrait for DogDyn {} +pub type LabradorDyn = Nillable; +impl AnimalTrait for LabradorDyn {} #[derive(Debug)] -pub struct IntermediateType { - pub base_value: Option, - pub intermediate_value: Option, +pub struct AnimalType { + pub id: i32, } -impl WithSerializer for IntermediateType { - type Serializer<'x> = quick_xml_serialize::IntermediateTypeSerializer<'x>; +impl WithSerializer for AnimalType { + type Serializer<'x> = quick_xml_serialize::AnimalTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::IntermediateTypeSerializer { + Ok(quick_xml_serialize::AnimalTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::IntermediateTypeSerializerState::Init__), - name: name.unwrap_or("intermediate"), + state: Box::new(quick_xml_serialize::AnimalTypeSerializerState::Init__), + name: name.unwrap_or("animal"), is_root, }) } } -impl WithDeserializer for IntermediateType { - type Deserializer = quick_xml_deserialize::IntermediateTypeDeserializer; +impl WithDeserializer for AnimalType { + type Deserializer = quick_xml_deserialize::AnimalTypeDeserializer; } #[derive(Debug)] -pub struct Intermediate(pub Box); -pub trait IntermediateTrait: BaseTrait {} -impl WithSerializer for Intermediate { - type Serializer<'x> = BoxedSerializer<'x>; +pub struct DogType { + pub id: i32, + pub name: String, +} +impl WithSerializer for DogType { + type Serializer<'x> = quick_xml_serialize::DogTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - let _name = name; - self.0.serializer(None, is_root) + Ok(quick_xml_serialize::DogTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::DogTypeSerializerState::Init__), + name: name.unwrap_or("dog"), + is_root, + }) } } -impl WithDeserializer for Intermediate { - type Deserializer = quick_xml_deserialize::IntermediateDeserializer; +impl WithDeserializer for DogType { + type Deserializer = quick_xml_deserialize::DogTypeDeserializer; } #[derive(Debug)] -pub struct FinalType { - pub base_value: Option, - pub intermediate_value: Option, - pub final_value: Option, +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, } -impl WithSerializer for FinalType { - type Serializer<'x> = quick_xml_serialize::FinalTypeSerializer<'x>; +impl WithSerializer for LabradorType { + type Serializer<'x> = quick_xml_serialize::LabradorTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::FinalTypeSerializer { + Ok(quick_xml_serialize::LabradorTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::FinalTypeSerializerState::Init__), - name: name.unwrap_or("final"), + state: Box::new(quick_xml_serialize::LabradorTypeSerializerState::Init__), + name: name.unwrap_or("labrador"), is_root, }) } } -impl WithDeserializer for FinalType { - type Deserializer = quick_xml_deserialize::FinalTypeDeserializer; +impl WithDeserializer for LabradorType { + type Deserializer = quick_xml_deserialize::LabradorTypeDeserializer; } pub mod quick_xml_deserialize { use core::mem::replace; use xsd_parser_types::quick_xml::{ BytesStart, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent, - DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, Event, QName, - WithDeserializer, + DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event, + QName, WithDeserializer, }; #[derive(Debug)] pub struct ListTypeDeserializer { - base: Vec, + animal: Vec, state__: Box, } #[derive(Debug)] enum ListTypeDeserializerState { Init__, - Base(Option<::Deserializer>), + Animal(Option<::Deserializer>), Done__, Unknown__, } @@ -152,7 +170,7 @@ pub mod quick_xml_deserialize { helper.raise_unexpected_attrib_checked(&attrib)?; } Ok(Self { - base: Vec::new(), + animal: Vec::new(), state__: Box::new(ListTypeDeserializerState::Init__), }) } @@ -163,19 +181,19 @@ pub mod quick_xml_deserialize { ) -> Result<(), Error> { use ListTypeDeserializerState as S; match state { - S::Base(Some(deserializer)) => self.store_base(deserializer.finish(helper)?)?, + S::Animal(Some(deserializer)) => self.store_animal(deserializer.finish(helper)?)?, _ => (), } Ok(()) } - fn store_base(&mut self, value: super::Base) -> Result<(), Error> { - self.base.push(value); + fn store_animal(&mut self, value: super::Animal) -> Result<(), Error> { + self.animal.push(value); Ok(()) } - fn handle_base<'de>( + fn handle_animal<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::Base>, + output: DeserializerOutput<'de, super::Animal>, fallback: &mut Option, ) -> Result, Error> { use ListTypeDeserializerState as S; @@ -194,13 +212,13 @@ pub mod quick_xml_deserialize { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_base(data)?; - *self.state__ = S::Base(None); + self.store_animal(data)?; + *self.state__ = S::Animal(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Base(Some(deserializer))); - *self.state__ = S::Base(None); + fallback.get_or_insert(S::Animal(Some(deserializer))); + *self.state__ = S::Animal(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } } @@ -226,9 +244,9 @@ pub mod quick_xml_deserialize { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Base(Some(deserializer)), event) => { + (S::Animal(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_base(helper, output, &mut fallback)? { + match self.handle_animal(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -250,12 +268,12 @@ pub mod quick_xml_deserialize { } (S::Init__, event) => { fallback.get_or_insert(S::Init__); - *self.state__ = S::Base(None); + *self.state__ = S::Animal(None); event } - (S::Base(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = ::init(helper, event)?; - match self.handle_base(helper, output, &mut fallback)? { + (S::Animal(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = ::init(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -287,20 +305,23 @@ pub mod quick_xml_deserialize { fn finish(mut self, helper: &mut DeserializeHelper) -> Result { let state = replace(&mut *self.state__, ListTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::ListType { base: self.base }) + Ok(super::ListType { + animal: self.animal, + }) } } #[derive(Debug)] - pub enum BaseDeserializer { - Intermediate(::Deserializer), - Final(::Deserializer), + pub enum AnimalDeserializer { + Animal(::Deserializer), + Dog(::Deserializer), + Labrador(::Deserializer), } - impl<'de> Deserializer<'de, super::Base> for BaseDeserializer { + impl<'de> Deserializer<'de, super::Animal> for AnimalDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Base> { - let Some(type_name) = helper.get_dynamic_type_name(&event)? else { + ) -> DeserializerResult<'de, super::Animal> { + let Some(type_name) = helper.get_dynamic_type_from_tag(&event) else { return Ok(DeserializerOutput { artifact: DeserializerArtifact::None, event: DeserializerEvent::None, @@ -310,30 +331,45 @@ pub mod quick_xml_deserialize { let type_name = type_name.into_owned(); if matches!( helper.resolve_local_name(QName(&type_name), &super::NS_TNS), - Some(b"intermediate") + Some(b"animal") + ) { + let DeserializerOutput { + artifact, + event, + allow_any, + } = ::init(helper, event)?; + return Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }); + } + if matches!( + helper.resolve_local_name(QName(&type_name), &super::NS_TNS), + Some(b"dog") ) { let DeserializerOutput { artifact, event, allow_any, - } = ::init(helper, event)?; + } = ::init(helper, event)?; return Ok(DeserializerOutput { - artifact: artifact.map(|x| super::Base(Box::new(x)), |x| Self::Intermediate(x)), + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Dog(x)), event, allow_any, }); } if matches!( helper.resolve_local_name(QName(&type_name), &super::NS_TNS), - Some(b"final") + Some(b"labrador") ) { let DeserializerOutput { artifact, event, allow_any, - } = ::init(helper, event)?; + } = ::init(helper, event)?; return Ok(DeserializerOutput { - artifact: artifact.map(|x| super::Base(Box::new(x)), |x| Self::Final(x)), + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Labrador(x)), event, allow_any, }); @@ -348,106 +384,107 @@ pub mod quick_xml_deserialize { self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Base> { + ) -> DeserializerResult<'de, super::Animal> { match self { - Self::Intermediate(x) => { + Self::Animal(x) => { let DeserializerOutput { artifact, event, allow_any, } = x.next(helper, event)?; Ok(DeserializerOutput { - artifact: artifact - .map(|x| super::Base(Box::new(x)), |x| Self::Intermediate(x)), + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Animal(x)), + event, + allow_any, + }) + } + Self::Dog(x) => { + let DeserializerOutput { + artifact, + event, + allow_any, + } = x.next(helper, event)?; + Ok(DeserializerOutput { + artifact: artifact.map(|x| super::Animal(Box::new(x)), |x| Self::Dog(x)), event, allow_any, }) } - Self::Final(x) => { + Self::Labrador(x) => { let DeserializerOutput { artifact, event, allow_any, } = x.next(helper, event)?; Ok(DeserializerOutput { - artifact: artifact.map(|x| super::Base(Box::new(x)), |x| Self::Final(x)), + artifact: artifact + .map(|x| super::Animal(Box::new(x)), |x| Self::Labrador(x)), event, allow_any, }) } } } - fn finish(self, helper: &mut DeserializeHelper) -> Result { + fn finish(self, helper: &mut DeserializeHelper) -> Result { match self { - Self::Intermediate(x) => Ok(super::Base(Box::new(x.finish(helper)?))), - Self::Final(x) => Ok(super::Base(Box::new(x.finish(helper)?))), + Self::Animal(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + Self::Dog(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), + Self::Labrador(x) => Ok(super::Animal(Box::new(x.finish(helper)?))), } } } #[derive(Debug)] - pub struct IntermediateTypeDeserializer { - base_value: Option, - intermediate_value: Option, - state__: Box, + pub struct AnimalTypeDeserializer { + id: i32, + state__: Box, } #[derive(Debug)] - enum IntermediateTypeDeserializerState { + enum AnimalTypeDeserializerState { Init__, Unknown__, } - impl IntermediateTypeDeserializer { + impl AnimalTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut base_value: Option = None; - let mut intermediate_value: Option = None; + let mut id: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"baseValue") + Some(b"id") ) { - helper.read_attrib(&mut base_value, b"baseValue", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"intermediateValue") - ) { - helper.read_attrib( - &mut intermediate_value, - b"intermediateValue", - &attrib.value, - )?; + helper.read_attrib(&mut id, b"id", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - base_value: base_value, - intermediate_value: intermediate_value, - state__: Box::new(IntermediateTypeDeserializerState::Init__), + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + state__: Box::new(AnimalTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: IntermediateTypeDeserializerState, + state: AnimalTypeDeserializerState, ) -> Result<(), Error> { Ok(()) } } - impl<'de> Deserializer<'de, super::IntermediateType> for IntermediateTypeDeserializer { + impl<'de> Deserializer<'de, super::AnimalType> for AnimalTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::IntermediateType> { + ) -> DeserializerResult<'de, super::AnimalType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::IntermediateType> { + ) -> DeserializerResult<'de, super::AnimalType> { if let Event::End(_) = &event { Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), @@ -462,194 +499,163 @@ pub mod quick_xml_deserialize { }) } } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - IntermediateTypeDeserializerState::Unknown__, - ); + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, AnimalTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::IntermediateType { - base_value: self.base_value, - intermediate_value: self.intermediate_value, - }) + Ok(super::AnimalType { id: self.id }) } } #[derive(Debug)] - pub enum IntermediateDeserializer { - Intermediate(::Deserializer), - Final(::Deserializer), + pub struct DogTypeDeserializer { + id: i32, + name: String, + state__: Box, } - impl<'de> Deserializer<'de, super::Intermediate> for IntermediateDeserializer { - fn init( + #[derive(Debug)] + enum DogTypeDeserializerState { + Init__, + Unknown__, + } + impl DogTypeDeserializer { + fn from_bytes_start( helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::Intermediate> { - let Some(type_name) = helper.get_dynamic_type_name(&event)? else { - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::None, - event: DeserializerEvent::None, - allow_any: false, - }); - }; - let type_name = type_name.into_owned(); - if matches!( - helper.resolve_local_name(QName(&type_name), &super::NS_TNS), - Some(b"intermediate") - ) { - let DeserializerOutput { - artifact, - event, - allow_any, - } = ::init(helper, event)?; - return Ok(DeserializerOutput { - artifact: artifact.map( - |x| super::Intermediate(Box::new(x)), - |x| Self::Intermediate(x), - ), - event, - allow_any, - }); - } - if matches!( - helper.resolve_local_name(QName(&type_name), &super::NS_TNS), - Some(b"final") - ) { - let DeserializerOutput { - artifact, - event, - allow_any, - } = ::init(helper, event)?; - return Ok(DeserializerOutput { - artifact: artifact - .map(|x| super::Intermediate(Box::new(x)), |x| Self::Final(x)), - event, - allow_any, - }); + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } } - Ok(DeserializerOutput { - artifact: DeserializerArtifact::None, - event: DeserializerEvent::Break(event), - allow_any: false, + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + state__: Box::new(DogTypeDeserializerState::Init__), }) } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: DogTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::DogType> for DogTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DogType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } fn next( - self, + mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Intermediate> { - match self { - Self::Intermediate(x) => { - let DeserializerOutput { - artifact, - event, - allow_any, - } = x.next(helper, event)?; - Ok(DeserializerOutput { - artifact: artifact.map( - |x| super::Intermediate(Box::new(x)), - |x| Self::Intermediate(x), - ), - event, - allow_any, - }) - } - Self::Final(x) => { - let DeserializerOutput { - artifact, - event, - allow_any, - } = x.next(helper, event)?; - Ok(DeserializerOutput { - artifact: artifact - .map(|x| super::Intermediate(Box::new(x)), |x| Self::Final(x)), - event, - allow_any, - }) - } + ) -> DeserializerResult<'de, super::DogType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) } } - fn finish(self, helper: &mut DeserializeHelper) -> Result { - match self { - Self::Intermediate(x) => Ok(super::Intermediate(Box::new(x.finish(helper)?))), - Self::Final(x) => Ok(super::Intermediate(Box::new(x.finish(helper)?))), - } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, DogTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::DogType { + id: self.id, + name: self.name, + }) } } #[derive(Debug)] - pub struct FinalTypeDeserializer { - base_value: Option, - intermediate_value: Option, - final_value: Option, - state__: Box, + pub struct LabradorTypeDeserializer { + id: i32, + name: String, + color: String, + state__: Box, } #[derive(Debug)] - enum FinalTypeDeserializerState { + enum LabradorTypeDeserializerState { Init__, Unknown__, } - impl FinalTypeDeserializer { + impl LabradorTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut base_value: Option = None; - let mut intermediate_value: Option = None; - let mut final_value: Option = None; + let mut id: Option = None; + let mut name: Option = None; + let mut color: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"baseValue") + Some(b"id") ) { - helper.read_attrib(&mut base_value, b"baseValue", &attrib.value)?; + helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"intermediateValue") + Some(b"name") ) { - helper.read_attrib( - &mut intermediate_value, - b"intermediateValue", - &attrib.value, - )?; + helper.read_attrib(&mut name, b"name", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"finalValue") + Some(b"color") ) { - helper.read_attrib(&mut final_value, b"finalValue", &attrib.value)?; + helper.read_attrib(&mut color, b"color", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - base_value: base_value, - intermediate_value: intermediate_value, - final_value: final_value, - state__: Box::new(FinalTypeDeserializerState::Init__), + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + color: color.ok_or_else(|| ErrorKind::MissingAttribute("color".into()))?, + state__: Box::new(LabradorTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: FinalTypeDeserializerState, + state: LabradorTypeDeserializerState, ) -> Result<(), Error> { Ok(()) } } - impl<'de> Deserializer<'de, super::FinalType> for FinalTypeDeserializer { + impl<'de> Deserializer<'de, super::LabradorType> for LabradorTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::FinalType> { + ) -> DeserializerResult<'de, super::LabradorType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::FinalType> { + ) -> DeserializerResult<'de, super::LabradorType> { if let Event::End(_) = &event { Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), @@ -664,13 +670,13 @@ pub mod quick_xml_deserialize { }) } } - fn finish(mut self, helper: &mut DeserializeHelper) -> Result { - let state = replace(&mut *self.state__, FinalTypeDeserializerState::Unknown__); + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, LabradorTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::FinalType { - base_value: self.base_value, - intermediate_value: self.intermediate_value, - final_value: self.final_value, + Ok(super::LabradorType { + id: self.id, + name: self.name, + color: self.color, }) } } @@ -689,7 +695,7 @@ pub mod quick_xml_serialize { #[derive(Debug)] pub(super) enum ListTypeSerializerState<'ser> { Init__, - Base(IterSerializer<'ser, &'ser [super::Base], super::Base>), + Animal(IterSerializer<'ser, &'ser [super::Animal], super::Animal>), End__, Done__, Phantom__(&'ser ()), @@ -702,9 +708,9 @@ pub mod quick_xml_serialize { loop { match &mut *self.state { ListTypeSerializerState::Init__ => { - *self.state = ListTypeSerializerState::Base(IterSerializer::new( - &self.value.base[..], - Some("base"), + *self.state = ListTypeSerializerState::Animal(IterSerializer::new( + &self.value.animal[..], + Some("animal"), false, )); let mut bytes = BytesStart::new(self.name); @@ -719,7 +725,7 @@ pub mod quick_xml_serialize { } return Ok(Some(Event::Start(bytes))); } - ListTypeSerializerState::Base(x) => match x.next(helper).transpose()? { + ListTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = ListTypeSerializerState::End__, }, @@ -747,113 +753,150 @@ pub mod quick_xml_serialize { } } #[derive(Debug)] - pub struct IntermediateTypeSerializer<'ser> { - pub(super) value: &'ser super::IntermediateType, - pub(super) state: Box>, + pub struct AnimalTypeSerializer<'ser> { + pub(super) value: &'ser super::AnimalType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum AnimalTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> AnimalTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + AnimalTypeSerializerState::Init__ => { + *self.state = AnimalTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + AnimalTypeSerializerState::Done__ => return Ok(None), + AnimalTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for AnimalTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = AnimalTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct DogTypeSerializer<'ser> { + pub(super) value: &'ser super::DogType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum IntermediateTypeSerializerState<'ser> { + pub(super) enum DogTypeSerializerState<'ser> { Init__, Done__, Phantom__(&'ser ()), } - impl<'ser> IntermediateTypeSerializer<'ser> { + impl<'ser> DogTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - IntermediateTypeSerializerState::Init__ => { - *self.state = IntermediateTypeSerializerState::Done__; + DogTypeSerializerState::Init__ => { + *self.state = DogTypeSerializerState::Done__; let mut bytes = BytesStart::new(self.name); helper.begin_ns_scope(); if self.is_root { helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); } - helper.write_attrib_opt(&mut bytes, "baseValue", &self.value.base_value)?; - helper.write_attrib_opt( - &mut bytes, - "intermediateValue", - &self.value.intermediate_value, - )?; + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; helper.end_ns_scope(); return Ok(Some(Event::Empty(bytes))); } - IntermediateTypeSerializerState::Done__ => return Ok(None), - IntermediateTypeSerializerState::Phantom__(_) => unreachable!(), + DogTypeSerializerState::Done__ => return Ok(None), + DogTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for IntermediateTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for DogTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = IntermediateTypeSerializerState::Done__; + *self.state = DogTypeSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct FinalTypeSerializer<'ser> { - pub(super) value: &'ser super::FinalType, - pub(super) state: Box>, + pub struct LabradorTypeSerializer<'ser> { + pub(super) value: &'ser super::LabradorType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum FinalTypeSerializerState<'ser> { + pub(super) enum LabradorTypeSerializerState<'ser> { Init__, Done__, Phantom__(&'ser ()), } - impl<'ser> FinalTypeSerializer<'ser> { + impl<'ser> LabradorTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - FinalTypeSerializerState::Init__ => { - *self.state = FinalTypeSerializerState::Done__; + LabradorTypeSerializerState::Init__ => { + *self.state = LabradorTypeSerializerState::Done__; let mut bytes = BytesStart::new(self.name); helper.begin_ns_scope(); if self.is_root { helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); } - helper.write_attrib_opt(&mut bytes, "baseValue", &self.value.base_value)?; - helper.write_attrib_opt( - &mut bytes, - "intermediateValue", - &self.value.intermediate_value, - )?; - helper.write_attrib_opt( - &mut bytes, - "finalValue", - &self.value.final_value, - )?; + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "color", &self.value.color)?; helper.end_ns_scope(); return Ok(Some(Event::Empty(bytes))); } - FinalTypeSerializerState::Done__ => return Ok(None), - FinalTypeSerializerState::Phantom__(_) => unreachable!(), + LabradorTypeSerializerState::Done__ => return Ok(None), + LabradorTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for FinalTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for LabradorTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = FinalTypeSerializerState::Done__; + *self.state = LabradorTypeSerializerState::Done__; Some(Err(error)) } } diff --git a/xsd-parser/tests/feature/nillable_dynamic_types/expected/quick_xml_optimized.rs b/xsd-parser/tests/feature/substitution_group_nillable/expected/quick_xml_optimized.rs similarity index 53% rename from xsd-parser/tests/feature/nillable_dynamic_types/expected/quick_xml_optimized.rs rename to xsd-parser/tests/feature/substitution_group_nillable/expected/quick_xml_optimized.rs index 73677310..e1ec898f 100644 --- a/xsd-parser/tests/feature/nillable_dynamic_types/expected/quick_xml_optimized.rs +++ b/xsd-parser/tests/feature/substitution_group_nillable/expected/quick_xml_optimized.rs @@ -14,7 +14,7 @@ pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns"); pub type List = ListType; #[derive(Debug)] pub struct ListType { - pub base: Vec, + pub animal: Vec, } impl WithSerializer for ListType { type Serializer<'x> = quick_xml_serialize::ListTypeSerializer<'x>; @@ -35,76 +35,100 @@ impl WithDeserializer for ListType { type Deserializer = quick_xml_deserialize::ListTypeDeserializer; } #[derive(Debug)] -pub enum Base { - Intermediate(IntermediateDyn), - Final(FinalDyn), +pub enum Animal { + Animal(AnimalDyn), + Dog(DogDyn), + Labrador(LabradorDyn), } -impl WithSerializer for Base { - type Serializer<'x> = quick_xml_serialize::BaseSerializer<'x>; +impl WithSerializer for Animal { + type Serializer<'x> = quick_xml_serialize::AnimalSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { let _name = name; - Ok(quick_xml_serialize::BaseSerializer { + Ok(quick_xml_serialize::AnimalSerializer { value: self, - state: Box::new(quick_xml_serialize::BaseSerializerState::Init__), + state: Box::new(quick_xml_serialize::AnimalSerializerState::Init__), is_root, }) } } -impl WithDeserializer for Base { - type Deserializer = quick_xml_deserialize::BaseDeserializer; +impl WithDeserializer for Animal { + type Deserializer = quick_xml_deserialize::AnimalDeserializer; } -pub type IntermediateDyn = Nillable; -pub type FinalDyn = Nillable; +pub type AnimalDyn = Nillable; +pub type DogDyn = Nillable; +pub type LabradorDyn = Nillable; #[derive(Debug)] -pub struct IntermediateType { - pub base_value: Option, - pub intermediate_value: Option, +pub struct AnimalType { + pub id: i32, } -impl WithSerializer for IntermediateType { - type Serializer<'x> = quick_xml_serialize::IntermediateTypeSerializer<'x>; +impl WithSerializer for AnimalType { + type Serializer<'x> = quick_xml_serialize::AnimalTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::IntermediateTypeSerializer { + Ok(quick_xml_serialize::AnimalTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::IntermediateTypeSerializerState::Init__), - name: name.unwrap_or("intermediate"), + state: Box::new(quick_xml_serialize::AnimalTypeSerializerState::Init__), + name: name.unwrap_or("animal"), is_root, }) } } -impl WithDeserializer for IntermediateType { - type Deserializer = quick_xml_deserialize::IntermediateTypeDeserializer; +impl WithDeserializer for AnimalType { + type Deserializer = quick_xml_deserialize::AnimalTypeDeserializer; } #[derive(Debug)] -pub struct FinalType { - pub base_value: Option, - pub intermediate_value: Option, - pub final_value: Option, +pub struct DogType { + pub id: i32, + pub name: String, } -impl WithSerializer for FinalType { - type Serializer<'x> = quick_xml_serialize::FinalTypeSerializer<'x>; +impl WithSerializer for DogType { + type Serializer<'x> = quick_xml_serialize::DogTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::FinalTypeSerializer { + Ok(quick_xml_serialize::DogTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::FinalTypeSerializerState::Init__), - name: name.unwrap_or("final"), + state: Box::new(quick_xml_serialize::DogTypeSerializerState::Init__), + name: name.unwrap_or("dog"), is_root, }) } } -impl WithDeserializer for FinalType { - type Deserializer = quick_xml_deserialize::FinalTypeDeserializer; +impl WithDeserializer for DogType { + type Deserializer = quick_xml_deserialize::DogTypeDeserializer; +} +#[derive(Debug)] +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl WithSerializer for LabradorType { + type Serializer<'x> = quick_xml_serialize::LabradorTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::LabradorTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::LabradorTypeSerializerState::Init__), + name: name.unwrap_or("labrador"), + is_root, + }) + } +} +impl WithDeserializer for LabradorType { + type Deserializer = quick_xml_deserialize::LabradorTypeDeserializer; } pub mod quick_xml_deserialize { use core::mem::replace; @@ -115,13 +139,13 @@ pub mod quick_xml_deserialize { }; #[derive(Debug)] pub struct ListTypeDeserializer { - base: Vec, + animal: Vec, state__: Box, } #[derive(Debug)] enum ListTypeDeserializerState { Init__, - Base(Option<::Deserializer>), + Animal(Option<::Deserializer>), Done__, Unknown__, } @@ -135,7 +159,7 @@ pub mod quick_xml_deserialize { helper.raise_unexpected_attrib_checked(&attrib)?; } Ok(Self { - base: Vec::new(), + animal: Vec::new(), state__: Box::new(ListTypeDeserializerState::Init__), }) } @@ -146,19 +170,19 @@ pub mod quick_xml_deserialize { ) -> Result<(), Error> { use ListTypeDeserializerState as S; match state { - S::Base(Some(deserializer)) => self.store_base(deserializer.finish(helper)?)?, + S::Animal(Some(deserializer)) => self.store_animal(deserializer.finish(helper)?)?, _ => (), } Ok(()) } - fn store_base(&mut self, value: super::Base) -> Result<(), Error> { - self.base.push(value); + fn store_animal(&mut self, value: super::Animal) -> Result<(), Error> { + self.animal.push(value); Ok(()) } - fn handle_base<'de>( + fn handle_animal<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::Base>, + output: DeserializerOutput<'de, super::Animal>, fallback: &mut Option, ) -> Result, Error> { use ListTypeDeserializerState as S; @@ -177,13 +201,13 @@ pub mod quick_xml_deserialize { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_base(data)?; - *self.state__ = S::Base(None); + self.store_animal(data)?; + *self.state__ = S::Animal(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Base(Some(deserializer))); - *self.state__ = S::Base(None); + fallback.get_or_insert(S::Animal(Some(deserializer))); + *self.state__ = S::Animal(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } } @@ -209,9 +233,9 @@ pub mod quick_xml_deserialize { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Base(Some(deserializer)), event) => { + (S::Animal(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_base(helper, output, &mut fallback)? { + match self.handle_animal(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -233,12 +257,12 @@ pub mod quick_xml_deserialize { } (S::Init__, event) => { fallback.get_or_insert(S::Init__); - *self.state__ = S::Base(None); + *self.state__ = S::Animal(None); event } - (S::Base(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = ::init(helper, event)?; - match self.handle_base(helper, output, &mut fallback)? { + (S::Animal(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = ::init(helper, event)?; + match self.handle_animal(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -270,30 +294,37 @@ pub mod quick_xml_deserialize { fn finish(mut self, helper: &mut DeserializeHelper) -> Result { let state = replace(&mut *self.state__, ListTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::ListType { base: self.base }) + Ok(super::ListType { + animal: self.animal, + }) } } #[derive(Debug)] - pub struct BaseDeserializer { - state__: Box, + pub struct AnimalDeserializer { + state__: Box, } #[derive(Debug)] - pub enum BaseDeserializerState { + pub enum AnimalDeserializerState { Init__, - Intermediate( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Animal( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Dog( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Final( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Labrador( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Done__(super::Base), + Done__(super::Animal), Unknown__, } - impl BaseDeserializer { + impl AnimalDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, @@ -302,81 +333,141 @@ pub mod quick_xml_deserialize { if let Event::Start(x) | Event::Empty(x) = &event { if matches!( helper.resolve_local_name(x.name(), &super::NS_TNS), - Some(b"intermediate") + Some(b"animal") ) { - let output = ::init(helper, event)?; - return self.handle_intermediate(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_animal(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_TNS), - Some(b"final") + Some(b"dog") ) { - let output = ::init(helper, event)?; - return self.handle_final_(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_dog(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_TNS), + Some(b"labrador") + ) { + let output = ::init(helper, event)?; + return self.handle_labrador(helper, Default::default(), None, output); } } - *self.state__ = BaseDeserializerState::Init__; + *self.state__ = AnimalDeserializerState::Init__; Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( helper: &mut DeserializeHelper, - state: BaseDeserializerState, - ) -> Result { - use BaseDeserializerState as S; + state: AnimalDeserializerState, + ) -> Result { + use AnimalDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Intermediate(mut values, None, deserializer) => { + S::Animal(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_intermediate(&mut values, value)?; + Self::store_animal(&mut values, value)?; } - Ok(super::Base::Intermediate( - helper.finish_element("intermediate", values)?, + Ok(super::Animal::Animal( + helper.finish_element("animal", values)?, )) } - S::Final(mut values, None, deserializer) => { + S::Dog(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_final_(&mut values, value)?; + Self::store_dog(&mut values, value)?; } - Ok(super::Base::Final(helper.finish_element("final", values)?)) + Ok(super::Animal::Dog(helper.finish_element("dog", values)?)) + } + S::Labrador(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_labrador(&mut values, value)?; + } + Ok(super::Animal::Labrador( + helper.finish_element("labrador", values)?, + )) } S::Done__(data) => Ok(data), _ => unreachable!(), } } - fn store_intermediate( - values: &mut Option, - value: super::IntermediateDyn, + fn store_animal( + values: &mut Option, + value: super::AnimalDyn, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"intermediate", + b"animal", )))?; } *values = Some(value); Ok(()) } - fn store_final_( - values: &mut Option, - value: super::FinalDyn, + fn store_dog( + values: &mut Option, + value: super::DogDyn, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"dog")))?; + } + *values = Some(value); + Ok(()) + } + fn store_labrador( + values: &mut Option, + value: super::LabradorDyn, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"final", + b"labrador", )))?; } *values = Some(value); Ok(()) } - fn handle_intermediate<'de>( + fn handle_animal<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnimalDyn>, + ) -> Result, Error> { + use AnimalDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_animal(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_animal(&mut values, data)?; + let data = Self::finish_state(helper, S::Animal(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Animal(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_dog<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::IntermediateDyn>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::DogDyn>, ) -> Result, Error> { - use BaseDeserializerState as S; + use AnimalDeserializerState as S; let DeserializerOutput { artifact, event, @@ -387,30 +478,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_intermediate(&mut values, data)?; + Self::store_dog(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_intermediate(&mut values, data)?; - let data = Self::finish_state(helper, S::Intermediate(values, None, None))?; + Self::store_dog(&mut values, data)?; + let data = Self::finish_state(helper, S::Dog(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Intermediate(values, None, Some(deserializer)); + *self.state__ = S::Dog(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_final_<'de>( + fn handle_labrador<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FinalDyn>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LabradorDyn>, ) -> Result, Error> { - use BaseDeserializerState as S; + use AnimalDeserializerState as S; let DeserializerOutput { artifact, event, @@ -421,35 +512,35 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_final_(&mut values, data)?; + Self::store_labrador(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_final_(&mut values, data)?; - let data = Self::finish_state(helper, S::Final(values, None, None))?; + Self::store_labrador(&mut values, data)?; + let data = Self::finish_state(helper, S::Labrador(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Final(values, None, Some(deserializer)); + *self.state__ = S::Labrador(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::Base> for BaseDeserializer { + impl<'de> Deserializer<'de, super::Animal> for AnimalDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Base> { + ) -> DeserializerResult<'de, super::Animal> { let deserializer = Self { - state__: Box::new(BaseDeserializerState::Init__), + state__: Box::new(AnimalDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, BaseDeserializerState::Init__) => + if matches!(&*x.state__, AnimalDeserializerState::Init__) => { DeserializerArtifact::None } @@ -461,25 +552,34 @@ pub mod quick_xml_deserialize { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Base> { - use BaseDeserializerState as S; + ) -> DeserializerResult<'de, super::Animal> { + use AnimalDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Intermediate(values, fallback, Some(deserializer)), event) => { + (S::Animal(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_intermediate(helper, values, fallback, output)? { + match self.handle_animal(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Final(values, fallback, Some(deserializer)), event) => { + (S::Dog(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_final_(helper, values, fallback, output)? { + match self.handle_dog(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Labrador(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_labrador(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -502,16 +602,16 @@ pub mod quick_xml_deserialize { ElementHandlerOutput::Continue { event, .. } => event, }, ( - S::Intermediate(values, fallback, None), + S::Animal(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_TNS), - b"intermediate", + b"animal", false, )?; - match self.handle_intermediate(helper, values, fallback, output)? { + match self.handle_animal(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -519,16 +619,33 @@ pub mod quick_xml_deserialize { } } ( - S::Final(values, fallback, None), + S::Dog(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_TNS), - b"final", + b"dog", false, )?; - match self.handle_final_(helper, values, fallback, output)? { + match self.handle_dog(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Labrador(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_TNS), + b"labrador", + false, + )?; + match self.handle_labrador(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -556,74 +673,142 @@ pub mod quick_xml_deserialize { allow_any, }) } - fn finish(self, helper: &mut DeserializeHelper) -> Result { + fn finish(self, helper: &mut DeserializeHelper) -> Result { Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct IntermediateTypeDeserializer { - base_value: Option, - intermediate_value: Option, - state__: Box, + pub struct AnimalTypeDeserializer { + id: i32, + state__: Box, } #[derive(Debug)] - enum IntermediateTypeDeserializerState { + enum AnimalTypeDeserializerState { Init__, Unknown__, } - impl IntermediateTypeDeserializer { + impl AnimalTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut base_value: Option = None; - let mut intermediate_value: Option = None; + let mut id: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"baseValue") + Some(b"id") ) { - helper.read_attrib(&mut base_value, b"baseValue", &attrib.value)?; + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + state__: Box::new(AnimalTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: AnimalTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::AnimalType> for AnimalTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnimalType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, AnimalTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::AnimalType { id: self.id }) + } + } + #[derive(Debug)] + pub struct DogTypeDeserializer { + id: i32, + name: String, + state__: Box, + } + #[derive(Debug)] + enum DogTypeDeserializerState { + Init__, + Unknown__, + } + impl DogTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut name: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_TNS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"intermediateValue") + Some(b"name") ) { - helper.read_attrib( - &mut intermediate_value, - b"intermediateValue", - &attrib.value, - )?; + helper.read_attrib(&mut name, b"name", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - base_value: base_value, - intermediate_value: intermediate_value, - state__: Box::new(IntermediateTypeDeserializerState::Init__), + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + state__: Box::new(DogTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: IntermediateTypeDeserializerState, + state: DogTypeDeserializerState, ) -> Result<(), Error> { Ok(()) } } - impl<'de> Deserializer<'de, super::IntermediateType> for IntermediateTypeDeserializer { + impl<'de> Deserializer<'de, super::DogType> for DogTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::IntermediateType> { + ) -> DeserializerResult<'de, super::DogType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::IntermediateType> { + ) -> DeserializerResult<'de, super::DogType> { if let Event::End(_) = &event { Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), @@ -638,93 +823,83 @@ pub mod quick_xml_deserialize { }) } } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - IntermediateTypeDeserializerState::Unknown__, - ); + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, DogTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::IntermediateType { - base_value: self.base_value, - intermediate_value: self.intermediate_value, + Ok(super::DogType { + id: self.id, + name: self.name, }) } } #[derive(Debug)] - pub struct FinalTypeDeserializer { - base_value: Option, - intermediate_value: Option, - final_value: Option, - state__: Box, + pub struct LabradorTypeDeserializer { + id: i32, + name: String, + color: String, + state__: Box, } #[derive(Debug)] - enum FinalTypeDeserializerState { + enum LabradorTypeDeserializerState { Init__, Unknown__, } - impl FinalTypeDeserializer { + impl LabradorTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut base_value: Option = None; - let mut intermediate_value: Option = None; - let mut final_value: Option = None; + let mut id: Option = None; + let mut name: Option = None; + let mut color: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"baseValue") + Some(b"id") ) { - helper.read_attrib(&mut base_value, b"baseValue", &attrib.value)?; + helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"intermediateValue") + Some(b"name") ) { - helper.read_attrib( - &mut intermediate_value, - b"intermediateValue", - &attrib.value, - )?; + helper.read_attrib(&mut name, b"name", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_TNS), - Some(b"finalValue") + Some(b"color") ) { - helper.read_attrib(&mut final_value, b"finalValue", &attrib.value)?; + helper.read_attrib(&mut color, b"color", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - base_value: base_value, - intermediate_value: intermediate_value, - final_value: final_value, - state__: Box::new(FinalTypeDeserializerState::Init__), + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, + color: color.ok_or_else(|| ErrorKind::MissingAttribute("color".into()))?, + state__: Box::new(LabradorTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: FinalTypeDeserializerState, + state: LabradorTypeDeserializerState, ) -> Result<(), Error> { Ok(()) } } - impl<'de> Deserializer<'de, super::FinalType> for FinalTypeDeserializer { + impl<'de> Deserializer<'de, super::LabradorType> for LabradorTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::FinalType> { + ) -> DeserializerResult<'de, super::LabradorType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::FinalType> { + ) -> DeserializerResult<'de, super::LabradorType> { if let Event::End(_) = &event { Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), @@ -739,13 +914,13 @@ pub mod quick_xml_deserialize { }) } } - fn finish(mut self, helper: &mut DeserializeHelper) -> Result { - let state = replace(&mut *self.state__, FinalTypeDeserializerState::Unknown__); + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, LabradorTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::FinalType { - base_value: self.base_value, - intermediate_value: self.intermediate_value, - final_value: self.final_value, + Ok(super::LabradorType { + id: self.id, + name: self.name, + color: self.color, }) } } @@ -765,7 +940,7 @@ pub mod quick_xml_serialize { #[derive(Debug)] pub(super) enum ListTypeSerializerState<'ser> { Init__, - Base(IterSerializer<'ser, &'ser [super::Base], super::Base>), + Animal(IterSerializer<'ser, &'ser [super::Animal], super::Animal>), End__, Done__, Phantom__(&'ser ()), @@ -778,9 +953,9 @@ pub mod quick_xml_serialize { loop { match &mut *self.state { ListTypeSerializerState::Init__ => { - *self.state = ListTypeSerializerState::Base(IterSerializer::new( - &self.value.base[..], - Some("base"), + *self.state = ListTypeSerializerState::Animal(IterSerializer::new( + &self.value.animal[..], + Some("animal"), false, )); let mut bytes = BytesStart::new(self.name); @@ -795,7 +970,7 @@ pub mod quick_xml_serialize { } return Ok(Some(Event::Start(bytes))); } - ListTypeSerializerState::Base(x) => match x.next(helper).transpose()? { + ListTypeSerializerState::Animal(x) => match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = ListTypeSerializerState::End__, }, @@ -823,174 +998,221 @@ pub mod quick_xml_serialize { } } #[derive(Debug)] - pub struct BaseSerializer<'ser> { - pub(super) value: &'ser super::Base, - pub(super) state: Box>, + pub struct AnimalSerializer<'ser> { + pub(super) value: &'ser super::Animal, + pub(super) state: Box>, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum BaseSerializerState<'ser> { + pub(super) enum AnimalSerializerState<'ser> { Init__, - Intermediate(::Serializer<'ser>), - Final(::Serializer<'ser>), + Animal(::Serializer<'ser>), + Dog(::Serializer<'ser>), + Labrador(::Serializer<'ser>), Done__, Phantom__(&'ser ()), } - impl<'ser> BaseSerializer<'ser> { + impl<'ser> AnimalSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - BaseSerializerState::Init__ => match self.value { - super::Base::Intermediate(x) => { - *self.state = BaseSerializerState::Intermediate( - WithSerializer::serializer(x, Some("intermediate"), self.is_root)?, - ) - } - super::Base::Final(x) => { - *self.state = BaseSerializerState::Final(WithSerializer::serializer( - x, - Some("final"), - self.is_root, - )?) + AnimalSerializerState::Init__ => { + match self.value { + super::Animal::Animal(x) => { + *self.state = AnimalSerializerState::Animal( + WithSerializer::serializer(x, Some("animal"), self.is_root)?, + ) + } + super::Animal::Dog(x) => { + *self.state = AnimalSerializerState::Dog( + WithSerializer::serializer(x, Some("dog"), self.is_root)?, + ) + } + super::Animal::Labrador(x) => { + *self.state = AnimalSerializerState::Labrador( + WithSerializer::serializer(x, Some("labrador"), self.is_root)?, + ) + } } + } + AnimalSerializerState::Animal(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AnimalSerializerState::Done__, }, - BaseSerializerState::Intermediate(x) => match x.next(helper).transpose()? { + AnimalSerializerState::Dog(x) => match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = BaseSerializerState::Done__, + None => *self.state = AnimalSerializerState::Done__, }, - BaseSerializerState::Final(x) => match x.next(helper).transpose()? { + AnimalSerializerState::Labrador(x) => match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = BaseSerializerState::Done__, + None => *self.state = AnimalSerializerState::Done__, }, - BaseSerializerState::Done__ => return Ok(None), - BaseSerializerState::Phantom__(_) => unreachable!(), + AnimalSerializerState::Done__ => return Ok(None), + AnimalSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for BaseSerializer<'ser> { + impl<'ser> Serializer<'ser> for AnimalSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = BaseSerializerState::Done__; + *self.state = AnimalSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct IntermediateTypeSerializer<'ser> { - pub(super) value: &'ser super::IntermediateType, - pub(super) state: Box>, + pub struct AnimalTypeSerializer<'ser> { + pub(super) value: &'ser super::AnimalType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum IntermediateTypeSerializerState<'ser> { + pub(super) enum AnimalTypeSerializerState<'ser> { Init__, Done__, Phantom__(&'ser ()), } - impl<'ser> IntermediateTypeSerializer<'ser> { + impl<'ser> AnimalTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - IntermediateTypeSerializerState::Init__ => { - *self.state = IntermediateTypeSerializerState::Done__; + AnimalTypeSerializerState::Init__ => { + *self.state = AnimalTypeSerializerState::Done__; let mut bytes = BytesStart::new(self.name); helper.begin_ns_scope(); if self.is_root { helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); } - helper.write_attrib_opt(&mut bytes, "baseValue", &self.value.base_value)?; - helper.write_attrib_opt( - &mut bytes, - "intermediateValue", - &self.value.intermediate_value, - )?; + helper.write_attrib(&mut bytes, "id", &self.value.id)?; helper.end_ns_scope(); return Ok(Some(Event::Empty(bytes))); } - IntermediateTypeSerializerState::Done__ => return Ok(None), - IntermediateTypeSerializerState::Phantom__(_) => unreachable!(), + AnimalTypeSerializerState::Done__ => return Ok(None), + AnimalTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for IntermediateTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for AnimalTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = IntermediateTypeSerializerState::Done__; + *self.state = AnimalTypeSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct FinalTypeSerializer<'ser> { - pub(super) value: &'ser super::FinalType, - pub(super) state: Box>, + pub struct DogTypeSerializer<'ser> { + pub(super) value: &'ser super::DogType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum FinalTypeSerializerState<'ser> { + pub(super) enum DogTypeSerializerState<'ser> { Init__, Done__, Phantom__(&'ser ()), } - impl<'ser> FinalTypeSerializer<'ser> { + impl<'ser> DogTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - FinalTypeSerializerState::Init__ => { - *self.state = FinalTypeSerializerState::Done__; + DogTypeSerializerState::Init__ => { + *self.state = DogTypeSerializerState::Done__; let mut bytes = BytesStart::new(self.name); helper.begin_ns_scope(); if self.is_root { helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); } - helper.write_attrib_opt(&mut bytes, "baseValue", &self.value.base_value)?; - helper.write_attrib_opt( - &mut bytes, - "intermediateValue", - &self.value.intermediate_value, - )?; - helper.write_attrib_opt( - &mut bytes, - "finalValue", - &self.value.final_value, - )?; + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + DogTypeSerializerState::Done__ => return Ok(None), + DogTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for DogTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = DogTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct LabradorTypeSerializer<'ser> { + pub(super) value: &'ser super::LabradorType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum LabradorTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> LabradorTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + LabradorTypeSerializerState::Init__ => { + *self.state = LabradorTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns_for_tag(&mut bytes, self.name, &super::NS_TNS); + } + helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib(&mut bytes, "name", &self.value.name)?; + helper.write_attrib(&mut bytes, "color", &self.value.color)?; helper.end_ns_scope(); return Ok(Some(Event::Empty(bytes))); } - FinalTypeSerializerState::Done__ => return Ok(None), - FinalTypeSerializerState::Phantom__(_) => unreachable!(), + LabradorTypeSerializerState::Done__ => return Ok(None), + LabradorTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for FinalTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for LabradorTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = FinalTypeSerializerState::Done__; + *self.state = LabradorTypeSerializerState::Done__; Some(Err(error)) } } diff --git a/xsd-parser/tests/feature/substitution_group_nillable/mod.rs b/xsd-parser/tests/feature/substitution_group_nillable/mod.rs new file mode 100644 index 00000000..8cc181ac --- /dev/null +++ b/xsd-parser/tests/feature/substitution_group_nillable/mod.rs @@ -0,0 +1,252 @@ +use xsd_parser::{ + config::{GeneratorFlags, OptimizerFlags}, + Config, IdentType, +}; + +use crate::utils::{generate_test, ConfigEx}; + +fn config() -> Config { + Config::test_default() + .with_derive(["Debug"]) + .with_generate([(IdentType::Element, "tns:list")]) + .with_generator_flags(GeneratorFlags::FLATTEN_CONTENT) + .with_nillable_type_support() +} + +/* default */ + +#[test] +fn generate_default() { + generate_test( + "tests/feature/substitution_group_nillable/schema.xsd", + "tests/feature/substitution_group_nillable/expected/default.rs", + config(), + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod default { + #![allow(unused_imports)] + + include!("expected/default.rs"); +} + +/* default (optimized) */ + +#[test] +fn generate_default_optimized() { + generate_test( + "tests/feature/substitution_group_nillable/schema.xsd", + "tests/feature/substitution_group_nillable/expected/default_optimized.rs", + config().with_optimizer_flags(OptimizerFlags::all()), + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod default_optmized { + #![allow(unused_imports)] + + include!("expected/default_optimized.rs"); +} + +/* quick_xml */ + +#[test] +fn generate_quick_xml() { + generate_test( + "tests/feature/substitution_group_nillable/schema.xsd", + "tests/feature/substitution_group_nillable/expected/quick_xml.rs", + config().with_quick_xml(), + ); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn read_quick_xml() { + use quick_xml::{AnimalDyn, DogDyn, LabradorDyn, List}; + + let obj = crate::utils::quick_xml_read_test::( + "tests/feature/substitution_group_nillable/example/default.xml", + ); + + let mut items = obj.animal.into_iter(); + + let item = items.next().unwrap(); + let item = item.0.into_any().downcast::().unwrap().unwrap(); + assert_eq!(item.id, 1); + + let item = items.next().unwrap(); + let item = item.0.into_any().downcast::().unwrap().unwrap(); + assert_eq!(item.id, 2); + assert_eq!(item.name, "Rex"); + + let item = items.next().unwrap(); + let item = item + .0 + .into_any() + .downcast::() + .unwrap() + .unwrap(); + assert_eq!(item.id, 3); + assert_eq!(item.name, "Buddy"); + assert_eq!(item.color, "black"); + + let item = items.next().unwrap(); + let item = item.0.into_any().downcast::().unwrap(); + assert!(item.is_none()); + + let item = items.next().unwrap(); + let item = item.0.into_any().downcast::().unwrap(); + assert!(item.is_none()); + + let item = items.next().unwrap(); + let item = item.0.into_any().downcast::().unwrap(); + assert!(item.is_none()); + + assert!(items.next().is_none()); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn write_quick_xml() { + use quick_xml::{Animal, AnimalType, DogType, LabradorType, List}; + use xsd_parser_types::xml::Nillable; + + let obj = List { + animal: vec![ + Animal::new(Nillable::new(AnimalType { id: 1 })), + Animal::new(Nillable::new(DogType { + id: 2, + name: "Rex".into(), + })), + Animal::new(Nillable::new(LabradorType { + id: 3, + name: "Buddy".into(), + color: "black".into(), + })), + Animal::new(Nillable::::nil()), + Animal::new(Nillable::::nil()), + Animal::new(Nillable::::nil()), + ], + }; + + crate::utils::quick_xml_write_test( + &obj, + "list", + "tests/feature/substitution_group_nillable/example/default.xml", + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod quick_xml { + #![allow(unused_imports)] + + include!("expected/quick_xml.rs"); +} + +/* quick_xml (optimized) */ + +#[test] +fn generate_quick_xml_optimized() { + generate_test( + "tests/feature/substitution_group_nillable/schema.xsd", + "tests/feature/substitution_group_nillable/expected/quick_xml_optimized.rs", + config() + .with_quick_xml() + .with_optimizer_flags(OptimizerFlags::all()), + ); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn read_quick_xml_optimized() { + use quick_xml_optimized::{Animal, List}; + + let obj = crate::utils::quick_xml_read_test::( + "tests/feature/substitution_group_nillable/example/default.xml", + ); + + let mut items = obj.animal.into_iter(); + + let item = items.next().unwrap(); + let Animal::Animal(item) = item else { + panic!("Expected `Animal::Animal`"); + }; + let item = item.unwrap(); + assert_eq!(item.id, 1); + + let item = items.next().unwrap(); + let Animal::Dog(item) = item else { + panic!("Expected `Animal::Dog`"); + }; + let item = item.unwrap(); + assert_eq!(item.id, 2); + assert_eq!(item.name, "Rex"); + + let item = items.next().unwrap(); + let Animal::Labrador(item) = item else { + panic!("Expected `Animal::Labrador`"); + }; + let item = item.unwrap(); + assert_eq!(item.id, 3); + assert_eq!(item.name, "Buddy"); + assert_eq!(item.color, "black"); + + let item = items.next().unwrap(); + let Animal::Animal(item) = item else { + panic!("Expected `Animal::Animal`"); + }; + assert!(item.is_none()); + + let item = items.next().unwrap(); + let Animal::Dog(item) = item else { + panic!("Expected `Animal::Dog`"); + }; + assert!(item.is_none()); + + let item = items.next().unwrap(); + let Animal::Labrador(item) = item else { + panic!("Expected `Animal::Labrador`"); + }; + assert!(item.is_none()); + + assert!(items.next().is_none()); +} + +#[test] +#[cfg(not(feature = "update-expectations"))] +fn write_quick_xml_optimized() { + use quick_xml_optimized::{Animal, AnimalType, DogType, LabradorType, List}; + use xsd_parser_types::xml::Nillable; + + let obj = List { + animal: vec![ + Animal::Animal(Nillable::new(AnimalType { id: 1 })), + Animal::Dog(Nillable::new(DogType { + id: 2, + name: "Rex".into(), + })), + Animal::Labrador(Nillable::new(LabradorType { + id: 3, + name: "Buddy".into(), + color: "black".into(), + })), + Animal::Animal(Nillable::::nil()), + Animal::Dog(Nillable::::nil()), + Animal::Labrador(Nillable::::nil()), + ], + }; + + crate::utils::quick_xml_write_test( + &obj, + "list", + "tests/feature/substitution_group_nillable/example/default.xml", + ); +} + +#[cfg(not(feature = "update-expectations"))] +mod quick_xml_optimized { + #![allow(unused_imports)] + + include!("expected/quick_xml_optimized.rs"); +} diff --git a/xsd-parser/tests/feature/substitution_group_nillable/schema.xsd b/xsd-parser/tests/feature/substitution_group_nillable/schema.xsd new file mode 100644 index 00000000..06e5fccb --- /dev/null +++ b/xsd-parser/tests/feature/substitution_group_nillable/schema.xsd @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/xsd-parser/tests/optimizer/expected0/convert_dynamic_to_choice.rs b/xsd-parser/tests/optimizer/expected0/convert_dynamic_to_choice.rs index 6aebbb7f..bb132d81 100644 --- a/xsd-parser/tests/optimizer/expected0/convert_dynamic_to_choice.rs +++ b/xsd-parser/tests/optimizer/expected0/convert_dynamic_to_choice.rs @@ -1,6 +1,11 @@ use xsd_parser_types::AsAny; pub struct Abstract(pub Box); pub trait AbstractTrait: AsAny {} +impl Abstract { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} pub struct FirstType { pub a: String, } diff --git a/xsd-parser/tests/optimizer/expected0/merge_dynamic_types.rs b/xsd-parser/tests/optimizer/expected0/merge_dynamic_types.rs new file mode 100644 index 00000000..5c8803c1 --- /dev/null +++ b/xsd-parser/tests/optimizer/expected0/merge_dynamic_types.rs @@ -0,0 +1,33 @@ +use xsd_parser_types::AsAny; +pub struct Animal(pub Box); +pub trait AnimalTrait: AsAny {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +pub struct AnimalType(pub Box); +pub trait AnimalTypeTrait: AsAny {} +impl AnimalTrait for AnimalType {} +impl AnimalType { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +pub struct DogType { + pub id: i32, + pub name: String, +} +impl AnimalTypeTrait for DogType {} +impl AnimalTrait for DogType {} +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl AnimalTypeTrait for LabradorType {} +impl AnimalTrait for LabradorType {} +pub struct AnimalDyn { + pub id: i32, +} +impl AnimalTypeTrait for AnimalDyn {} diff --git a/xsd-parser/tests/optimizer/expected1/merge_dynamic_types.rs b/xsd-parser/tests/optimizer/expected1/merge_dynamic_types.rs new file mode 100644 index 00000000..0f65b049 --- /dev/null +++ b/xsd-parser/tests/optimizer/expected1/merge_dynamic_types.rs @@ -0,0 +1,23 @@ +use xsd_parser_types::AsAny; +pub struct Animal(pub Box); +pub trait AnimalTrait: AsAny {} +impl Animal { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +pub struct AnimalDyn { + pub id: i32, +} +impl AnimalTrait for AnimalDyn {} +pub struct DogType { + pub id: i32, + pub name: String, +} +impl AnimalTrait for DogType {} +pub struct LabradorType { + pub id: i32, + pub name: String, + pub color: String, +} +impl AnimalTrait for LabradorType {} diff --git a/xsd-parser/tests/optimizer/merge_dynamic_types.xsd b/xsd-parser/tests/optimizer/merge_dynamic_types.xsd new file mode 100644 index 00000000..fffabbbf --- /dev/null +++ b/xsd-parser/tests/optimizer/merge_dynamic_types.xsd @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/xsd-parser/tests/optimizer/mod.rs b/xsd-parser/tests/optimizer/mod.rs index 9626576d..a854ab04 100644 --- a/xsd-parser/tests/optimizer/mod.rs +++ b/xsd-parser/tests/optimizer/mod.rs @@ -174,3 +174,17 @@ fn replace_xs_any_type_with_any_element() { .with_generator_flags(GeneratorFlags::MIXED_TYPE_SUPPORT), ); } + +#[test] +fn merge_dynamic_types() { + optimizer_test_with_config( + "tests/optimizer/merge_dynamic_types.xsd", + "tests/optimizer/expected0/merge_dynamic_types.rs", + "tests/optimizer/expected1/merge_dynamic_types.rs", + [(IdentType::Element, "tns:animal")], + OptimizerFlags::MERGE_DYNAMIC_TYPES, + Config::test_default() + .with_dynamic_type((IdentType::Type, "tns:animal")) + .with_generator_flags(GeneratorFlags::FLATTEN_CONTENT), + ); +} diff --git a/xsd-parser/tests/schema/ofd/expected/default.rs b/xsd-parser/tests/schema/ofd/expected/default.rs index f35550c4..1089345b 100644 --- a/xsd-parser/tests/schema/ofd/expected/default.rs +++ b/xsd-parser/tests/schema/ofd/expected/default.rs @@ -511,7 +511,18 @@ pub mod page { pub back_color: Option>, } #[derive(Debug)] - pub struct CtGraphicUnitXType { + pub enum CtGraphicUnitXType { + CtText(CtTextXType), + CtPageBlockTextObject(CtPageBlockTextObjectXElementType), + CtPath(CtPathXType), + CtPageBlockPathObject(CtPageBlockPathObjectXElementType), + CtImage(CtImageXType), + CtPageBlockImageObject(CtPageBlockImageObjectXElementType), + CtComposite(CtCompositeXType), + CtPageBlockCompositeObject(CtPageBlockCompositeObjectXElementType), + } + #[derive(Debug)] + pub struct CtGraphicUnitDyn { pub boundary: String, pub name: Option, pub visible: bool, @@ -728,28 +739,6 @@ pub mod page { pub color: Box, } #[derive(Debug)] - pub struct CtImageBorderXElementType { - pub line_width: f64, - pub horizonal_corner_radius: f64, - pub vertical_corner_radius: f64, - pub dash_offset: f64, - pub dash_pattern: Option, - pub border_color: Option, - } - #[derive(Debug)] - pub struct CtLaGouraudShdPointXElementType { - pub x: Option, - pub y: Option, - pub color: Box, - } - #[derive(Debug)] - pub enum CtLayerTypeXType { - Body, - Background, - Foreground, - Custom, - } - #[derive(Debug)] pub struct CtPageBlockTextObjectXElementType { pub boundary: String, pub name: Option, @@ -850,6 +839,28 @@ pub mod page { pub clips: Option, } #[derive(Debug)] + pub struct CtImageBorderXElementType { + pub line_width: f64, + pub horizonal_corner_radius: f64, + pub vertical_corner_radius: f64, + pub dash_offset: f64, + pub dash_pattern: Option, + pub border_color: Option, + } + #[derive(Debug)] + pub struct CtLaGouraudShdPointXElementType { + pub x: Option, + pub y: Option, + pub color: Box, + } + #[derive(Debug)] + pub enum CtLayerTypeXType { + Body, + Background, + Foreground, + Custom, + } + #[derive(Debug)] pub struct CtPageBlockPageBlockXElementType { pub id: u32, pub content: Vec, diff --git a/xsd-parser/tests/schema/ofd/expected/quick_xml.rs b/xsd-parser/tests/schema/ofd/expected/quick_xml.rs index 5bd933d8..22ab1da1 100644 --- a/xsd-parser/tests/schema/ofd/expected/quick_xml.rs +++ b/xsd-parser/tests/schema/ofd/expected/quick_xml.rs @@ -21494,7 +21494,36 @@ pub mod page { type Deserializer = quick_xml_deserialize::CtGouraudShdXTypeDeserializer; } #[derive(Debug)] - pub struct CtGraphicUnitXType { + pub enum CtGraphicUnitXType { + CtText(CtTextXType), + CtPageBlockTextObject(CtPageBlockTextObjectXElementType), + CtPath(CtPathXType), + CtPageBlockPathObject(CtPageBlockPathObjectXElementType), + CtImage(CtImageXType), + CtPageBlockImageObject(CtPageBlockImageObjectXElementType), + CtComposite(CtCompositeXType), + CtPageBlockCompositeObject(CtPageBlockCompositeObjectXElementType), + } + impl WithSerializer for CtGraphicUnitXType { + type Serializer<'x> = quick_xml_serialize::CtGraphicUnitXTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + let _name = name; + Ok(quick_xml_serialize::CtGraphicUnitXTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::CtGraphicUnitXTypeSerializerState::Init__), + is_root, + }) + } + } + impl WithDeserializer for CtGraphicUnitXType { + type Deserializer = quick_xml_deserialize::CtGraphicUnitXTypeDeserializer; + } + #[derive(Debug)] + pub struct CtGraphicUnitDyn { pub boundary: String, pub name: Option, pub visible: bool, @@ -21510,7 +21539,7 @@ pub mod page { pub actions: Option, pub clips: Option, } - impl CtGraphicUnitXType { + impl CtGraphicUnitDyn { #[must_use] pub fn default_visible() -> bool { true @@ -21540,23 +21569,23 @@ pub mod page { 255i32 } } - impl WithSerializer for CtGraphicUnitXType { - type Serializer<'x> = quick_xml_serialize::CtGraphicUnitXTypeSerializer<'x>; + impl WithSerializer for CtGraphicUnitDyn { + type Serializer<'x> = quick_xml_serialize::CtGraphicUnitDynSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::CtGraphicUnitXTypeSerializer { + Ok(quick_xml_serialize::CtGraphicUnitDynSerializer { value: self, - state: Box::new(quick_xml_serialize::CtGraphicUnitXTypeSerializerState::Init__), + state: Box::new(quick_xml_serialize::CtGraphicUnitDynSerializerState::Init__), name: name.unwrap_or("CT_GraphicUnit"), is_root, }) } } - impl WithDeserializer for CtGraphicUnitXType { - type Deserializer = quick_xml_deserialize::CtGraphicUnitXTypeDeserializer; + impl WithDeserializer for CtGraphicUnitDyn { + type Deserializer = quick_xml_deserialize::CtGraphicUnitDynDeserializer; } #[derive(Debug)] pub struct CtImageXType { @@ -22370,116 +22399,6 @@ pub mod page { type Deserializer = quick_xml_deserialize::CtGouraudShdPointXElementTypeDeserializer; } #[derive(Debug)] - pub struct CtImageBorderXElementType { - pub line_width: f64, - pub horizonal_corner_radius: f64, - pub vertical_corner_radius: f64, - pub dash_offset: f64, - pub dash_pattern: Option, - pub border_color: Option, - } - impl CtImageBorderXElementType { - #[must_use] - pub fn default_line_width() -> f64 { - 0.353f64 - } - #[must_use] - pub fn default_horizonal_corner_radius() -> f64 { - 0f64 - } - #[must_use] - pub fn default_vertical_corner_radius() -> f64 { - 0f64 - } - #[must_use] - pub fn default_dash_offset() -> f64 { - 0f64 - } - } - impl WithSerializer for CtImageBorderXElementType { - type Serializer<'x> = quick_xml_serialize::CtImageBorderXElementTypeSerializer<'x>; - fn serializer<'ser>( - &'ser self, - name: Option<&'ser str>, - is_root: bool, - ) -> Result, Error> { - Ok(quick_xml_serialize::CtImageBorderXElementTypeSerializer { - value: self, - state: Box::new( - quick_xml_serialize::CtImageBorderXElementTypeSerializerState::Init__, - ), - name: name.unwrap_or("CtImageBorder"), - is_root, - }) - } - } - impl WithDeserializer for CtImageBorderXElementType { - type Deserializer = quick_xml_deserialize::CtImageBorderXElementTypeDeserializer; - } - #[derive(Debug)] - pub struct CtLaGouraudShdPointXElementType { - pub x: Option, - pub y: Option, - pub color: Box, - } - impl WithSerializer for CtLaGouraudShdPointXElementType { - type Serializer<'x> = quick_xml_serialize::CtLaGouraudShdPointXElementTypeSerializer<'x>; - fn serializer<'ser>( - &'ser self, - name: Option<&'ser str>, - is_root: bool, - ) -> Result, Error> { - Ok( - quick_xml_serialize::CtLaGouraudShdPointXElementTypeSerializer { - value: self, - state: Box::new( - quick_xml_serialize::CtLaGouraudShdPointXElementTypeSerializerState::Init__, - ), - name: name.unwrap_or("CtLaGouraudShdPoint"), - is_root, - }, - ) - } - } - impl WithDeserializer for CtLaGouraudShdPointXElementType { - type Deserializer = quick_xml_deserialize::CtLaGouraudShdPointXElementTypeDeserializer; - } - #[derive(Debug)] - pub enum CtLayerTypeXType { - Body, - Background, - Foreground, - Custom, - } - impl SerializeBytes for CtLayerTypeXType { - fn serialize_bytes( - &self, - helper: &mut SerializeHelper, - ) -> Result>, Error> { - match self { - Self::Body => Ok(Some(Cow::Borrowed("Body"))), - Self::Background => Ok(Some(Cow::Borrowed("Background"))), - Self::Foreground => Ok(Some(Cow::Borrowed("Foreground"))), - Self::Custom => Ok(Some(Cow::Borrowed("Custom"))), - } - } - } - impl WithSerializeToBytes for CtLayerTypeXType {} - impl DeserializeBytes for CtLayerTypeXType { - fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result { - match bytes { - b"Body" => Ok(Self::Body), - b"Background" => Ok(Self::Background), - b"Foreground" => Ok(Self::Foreground), - b"Custom" => Ok(Self::Custom), - x => Err(Error::from(ErrorKind::UnknownOrInvalidValue( - RawByteStr::from_slice(x), - ))), - } - } - } - impl WithDeserializerFromBytes for CtLayerTypeXType {} - #[derive(Debug)] pub struct CtPageBlockTextObjectXElementType { pub boundary: String, pub name: Option, @@ -22811,6 +22730,116 @@ pub mod page { quick_xml_deserialize::CtPageBlockCompositeObjectXElementTypeDeserializer; } #[derive(Debug)] + pub struct CtImageBorderXElementType { + pub line_width: f64, + pub horizonal_corner_radius: f64, + pub vertical_corner_radius: f64, + pub dash_offset: f64, + pub dash_pattern: Option, + pub border_color: Option, + } + impl CtImageBorderXElementType { + #[must_use] + pub fn default_line_width() -> f64 { + 0.353f64 + } + #[must_use] + pub fn default_horizonal_corner_radius() -> f64 { + 0f64 + } + #[must_use] + pub fn default_vertical_corner_radius() -> f64 { + 0f64 + } + #[must_use] + pub fn default_dash_offset() -> f64 { + 0f64 + } + } + impl WithSerializer for CtImageBorderXElementType { + type Serializer<'x> = quick_xml_serialize::CtImageBorderXElementTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::CtImageBorderXElementTypeSerializer { + value: self, + state: Box::new( + quick_xml_serialize::CtImageBorderXElementTypeSerializerState::Init__, + ), + name: name.unwrap_or("CtImageBorder"), + is_root, + }) + } + } + impl WithDeserializer for CtImageBorderXElementType { + type Deserializer = quick_xml_deserialize::CtImageBorderXElementTypeDeserializer; + } + #[derive(Debug)] + pub struct CtLaGouraudShdPointXElementType { + pub x: Option, + pub y: Option, + pub color: Box, + } + impl WithSerializer for CtLaGouraudShdPointXElementType { + type Serializer<'x> = quick_xml_serialize::CtLaGouraudShdPointXElementTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok( + quick_xml_serialize::CtLaGouraudShdPointXElementTypeSerializer { + value: self, + state: Box::new( + quick_xml_serialize::CtLaGouraudShdPointXElementTypeSerializerState::Init__, + ), + name: name.unwrap_or("CtLaGouraudShdPoint"), + is_root, + }, + ) + } + } + impl WithDeserializer for CtLaGouraudShdPointXElementType { + type Deserializer = quick_xml_deserialize::CtLaGouraudShdPointXElementTypeDeserializer; + } + #[derive(Debug)] + pub enum CtLayerTypeXType { + Body, + Background, + Foreground, + Custom, + } + impl SerializeBytes for CtLayerTypeXType { + fn serialize_bytes( + &self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + match self { + Self::Body => Ok(Some(Cow::Borrowed("Body"))), + Self::Background => Ok(Some(Cow::Borrowed("Background"))), + Self::Foreground => Ok(Some(Cow::Borrowed("Foreground"))), + Self::Custom => Ok(Some(Cow::Borrowed("Custom"))), + } + } + } + impl WithSerializeToBytes for CtLayerTypeXType {} + impl DeserializeBytes for CtLayerTypeXType { + fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result { + match bytes { + b"Body" => Ok(Self::Body), + b"Background" => Ok(Self::Background), + b"Foreground" => Ok(Self::Foreground), + b"Custom" => Ok(Self::Custom), + x => Err(Error::from(ErrorKind::UnknownOrInvalidValue( + RawByteStr::from_slice(x), + ))), + } + } + } + impl WithDeserializerFromBytes for CtLayerTypeXType {} + #[derive(Debug)] pub struct CtPageBlockPageBlockXElementType { pub id: u32, pub content: Vec, @@ -23253,7 +23282,7 @@ pub mod page { use xsd_parser_types::quick_xml::{ BytesStart, ContentDeserializer, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent, DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, - ErrorKind, Event, RawByteStr, WithDeserializer, + ErrorKind, Event, QName, RawByteStr, WithDeserializer, }; #[derive(Debug)] pub struct CtAxialShdXTypeDeserializer { @@ -25325,219 +25354,281 @@ pub mod page { } #[derive(Debug)] pub struct CtGraphicUnitXTypeDeserializer { - boundary: String, - name: Option, - visible: bool, - ctm: Option, - draw_param: Option, - line_width: f64, - cap: super::CtGraphicUnitCapXType, - join: super::CtGraphicUnitJoinXType, - miter_limit: f64, - dash_offset: f64, - dash_pattern: Option, - alpha: i32, - actions: Option, - clips: Option, state__: Box, } #[derive(Debug)] - enum CtGraphicUnitXTypeDeserializerState { - Init__, - Actions( - Option<::Deserializer>, - ), - Clips( - Option<::Deserializer>, - ), - Done__, - Unknown__, - } + pub enum CtGraphicUnitXTypeDeserializerState { + Init__ , CtText (Option < super :: CtTextXType > , Option << super :: CtTextXType as WithDeserializer > :: Deserializer > , Option << super :: CtTextXType as WithDeserializer > :: Deserializer > ,) , CtPageBlockTextObject (Option < super :: CtPageBlockTextObjectXElementType > , Option << super :: CtPageBlockTextObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockTextObjectXElementType as WithDeserializer > :: Deserializer > ,) , CtPath (Option < super :: CtPathXType > , Option << super :: CtPathXType as WithDeserializer > :: Deserializer > , Option << super :: CtPathXType as WithDeserializer > :: Deserializer > ,) , CtPageBlockPathObject (Option < super :: CtPageBlockPathObjectXElementType > , Option << super :: CtPageBlockPathObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockPathObjectXElementType as WithDeserializer > :: Deserializer > ,) , CtImage (Option < super :: CtImageXType > , Option << super :: CtImageXType as WithDeserializer > :: Deserializer > , Option << super :: CtImageXType as WithDeserializer > :: Deserializer > ,) , CtPageBlockImageObject (Option < super :: CtPageBlockImageObjectXElementType > , Option << super :: CtPageBlockImageObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockImageObjectXElementType as WithDeserializer > :: Deserializer > ,) , CtComposite (Option < super :: CtCompositeXType > , Option << super :: CtCompositeXType as WithDeserializer > :: Deserializer > , Option << super :: CtCompositeXType as WithDeserializer > :: Deserializer > ,) , CtPageBlockCompositeObject (Option < super :: CtPageBlockCompositeObjectXElementType > , Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer > ,) , Done__ (super :: CtGraphicUnitXType) , Unknown__ , } impl CtGraphicUnitXTypeDeserializer { - fn from_bytes_start( + fn find_suitable<'de>( + &mut self, helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut boundary: Option = None; - let mut name: Option = None; - let mut visible: Option = None; - let mut ctm: Option = None; - let mut draw_param: Option = None; - let mut line_width: Option = None; - let mut cap: Option = None; - let mut join: Option = None; - let mut miter_limit: Option = None; - let mut dash_offset: Option = None; - let mut dash_pattern: Option = None; - let mut alpha: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Boundary") - ) { - helper.read_attrib(&mut boundary, b"Boundary", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Name") - ) { - helper.read_attrib(&mut name, b"Name", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Visible") - ) { - helper.read_attrib(&mut visible, b"Visible", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"CTM") - ) { - helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DrawParam") - ) { - helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"LineWidth") - ) { - helper.read_attrib(&mut line_width, b"LineWidth", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Cap") - ) { - helper.read_attrib(&mut cap, b"Cap", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Join") - ) { - helper.read_attrib(&mut join, b"Join", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"MiterLimit") - ) { - helper.read_attrib(&mut miter_limit, b"MiterLimit", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashOffset") - ) { - helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashPattern") - ) { - helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Alpha") - ) { - helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"CT_GraphicUnit") + ) { + if let Some(type_name) = helper.get_dynamic_type_from_attrib_bytes(x)? { + let type_name = type_name.into_owned(); + if matches!( + helper.resolve_local_name( + QName(&type_name), + &super::super::NS_UNNAMED_5 + ), + Some(b"CT_Text") + ) { + let output = + ::init(helper, event)?; + return self.handle_ct_text( + helper, + Default::default(), + None, + output, + ); + } + if matches!( + helper.resolve_local_name( + QName(&type_name), + &super::super::NS_UNNAMED_5 + ), + Some(b"CT_Path") + ) { + let output = + ::init(helper, event)?; + return self.handle_ct_path( + helper, + Default::default(), + None, + output, + ); + } + if matches!( + helper.resolve_local_name( + QName(&type_name), + &super::super::NS_UNNAMED_5 + ), + Some(b"CT_Image") + ) { + let output = + ::init(helper, event)?; + return self.handle_ct_image( + helper, + Default::default(), + None, + output, + ); + } + if matches!( + helper.resolve_local_name( + QName(&type_name), + &super::super::NS_UNNAMED_5 + ), + Some(b"CT_Composite") + ) { + let output = ::init( + helper, event, + )?; + return self.handle_ct_composite( + helper, + Default::default(), + None, + output, + ); + } + } } } - Ok(Self { - boundary: boundary - .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, - name: name, - visible: visible.unwrap_or_else(super::CtGraphicUnitXType::default_visible), - ctm: ctm, - draw_param: draw_param, - line_width: line_width - .unwrap_or_else(super::CtGraphicUnitXType::default_line_width), - cap: cap.unwrap_or_else(super::CtGraphicUnitXType::default_cap), - join: join.unwrap_or_else(super::CtGraphicUnitXType::default_join), - miter_limit: miter_limit - .unwrap_or_else(super::CtGraphicUnitXType::default_miter_limit), - dash_offset: dash_offset - .unwrap_or_else(super::CtGraphicUnitXType::default_dash_offset), - dash_pattern: dash_pattern, - alpha: alpha.unwrap_or_else(super::CtGraphicUnitXType::default_alpha), - actions: None, - clips: None, - state__: Box::new(CtGraphicUnitXTypeDeserializerState::Init__), - }) + *self.state__ = CtGraphicUnitXTypeDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( - &mut self, helper: &mut DeserializeHelper, state: CtGraphicUnitXTypeDeserializerState, - ) -> Result<(), Error> { + ) -> Result { use CtGraphicUnitXTypeDeserializerState as S; match state { - S::Actions(Some(deserializer)) => { - self.store_actions(deserializer.finish(helper)?)? + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::CtText(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_ct_text(&mut values, value)?; + } + Ok(super::CtGraphicUnitXType::CtText( + helper.finish_element("CT_Text", values)?, + )) } - S::Clips(Some(deserializer)) => { - self.store_clips(deserializer.finish(helper)?)? + S::CtPageBlockTextObject(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_ct_page_block_text_object(&mut values, value)?; + } + Ok(super::CtGraphicUnitXType::CtPageBlockTextObject( + helper.finish_element("CtPageBlockTextObject", values)?, + )) } - _ => (), + S::CtPath(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_ct_path(&mut values, value)?; + } + Ok(super::CtGraphicUnitXType::CtPath( + helper.finish_element("CT_Path", values)?, + )) + } + S::CtPageBlockPathObject(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_ct_page_block_path_object(&mut values, value)?; + } + Ok(super::CtGraphicUnitXType::CtPageBlockPathObject( + helper.finish_element("CtPageBlockPathObject", values)?, + )) + } + S::CtImage(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_ct_image(&mut values, value)?; + } + Ok(super::CtGraphicUnitXType::CtImage( + helper.finish_element("CT_Image", values)?, + )) + } + S::CtPageBlockImageObject(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_ct_page_block_image_object(&mut values, value)?; + } + Ok(super::CtGraphicUnitXType::CtPageBlockImageObject( + helper.finish_element("CtPageBlockImageObject", values)?, + )) + } + S::CtComposite(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_ct_composite(&mut values, value)?; + } + Ok(super::CtGraphicUnitXType::CtComposite( + helper.finish_element("CT_Composite", values)?, + )) + } + S::CtPageBlockCompositeObject(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_ct_page_block_composite_object(&mut values, value)?; + } + Ok(super::CtGraphicUnitXType::CtPageBlockCompositeObject( + helper.finish_element("CtPageBlockCompositeObject", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), } - Ok(()) } - fn store_actions( - &mut self, - value: super::CtGraphicUnitActionsXElementType, + fn store_ct_text( + values: &mut Option, + value: super::CtTextXType, ) -> Result<(), Error> { - if self.actions.is_some() { + if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Actions", + b"CT_Text", )))?; } - self.actions = Some(value); + *values = Some(value); Ok(()) } - fn store_clips( - &mut self, - value: super::CtGraphicUnitClipsXElementType, + fn store_ct_page_block_text_object( + values: &mut Option, + value: super::CtPageBlockTextObjectXElementType, ) -> Result<(), Error> { - if self.clips.is_some() { + if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Clips", + b"CtPageBlockTextObject", )))?; } - self.clips = Some(value); + *values = Some(value); Ok(()) } - fn handle_actions<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtGraphicUnitXTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::Clips(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + fn store_ct_path( + values: &mut Option, + value: super::CtPathXType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"CT_Path", + )))?; } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + *values = Some(value); + Ok(()) + } + fn store_ct_page_block_path_object( + values: &mut Option, + value: super::CtPageBlockPathObjectXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"CtPageBlockPathObject", + )))?; } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_actions(data)?; - *self.state__ = S::Clips(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Actions(Some(deserializer))); - *self.state__ = S::Clips(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } + *values = Some(value); + Ok(()) + } + fn store_ct_image( + values: &mut Option, + value: super::CtImageXType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"CT_Image", + )))?; } + *values = Some(value); + Ok(()) } - fn handle_clips<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, - fallback: &mut Option, - ) -> Result, Error> { + fn store_ct_page_block_image_object( + values: &mut Option, + value: super::CtPageBlockImageObjectXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"CtPageBlockImageObject", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_ct_composite( + values: &mut Option, + value: super::CtCompositeXType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"CT_Composite", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_ct_page_block_composite_object( + values: &mut Option, + value: super::CtPageBlockCompositeObjectXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"CtPageBlockCompositeObject", + )))?; + } + *values = Some(value); + Ok(()) + } + fn handle_ct_text<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CtTextXType>, + ) -> Result, Error> { use CtGraphicUnitXTypeDeserializerState as S; let DeserializerOutput { artifact, @@ -25545,766 +25636,778 @@ pub mod page { allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_ct_text(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_clips(data)?; - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_ct_text(&mut values, data)?; + let data = Self::finish_state(helper, S::CtText(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Clips(Some(deserializer))); - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::CtText(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - } - impl<'de> Deserializer<'de, super::CtGraphicUnitXType> for CtGraphicUnitXTypeDeserializer { - fn init( + fn handle_ct_page_block_text_object<'de>( + &mut self, helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtGraphicUnitXType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtPageBlockTextObjectXElementType>, + ) -> Result, Error> { + use CtGraphicUnitXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_ct_page_block_text_object(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_ct_page_block_text_object(&mut values, data)?; + let data = Self::finish_state( + helper, + S::CtPageBlockTextObject(values, None, None), + )?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::CtPageBlockTextObject(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } } - fn next( - mut self, + fn handle_ct_path<'de>( + &mut self, helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtGraphicUnitXType> { + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CtPathXType>, + ) -> Result, Error> { use CtGraphicUnitXTypeDeserializerState as S; - let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::Actions(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_actions(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Clips(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_clips(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, - allow_any: false, - }); - } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Actions(None); - event - } - (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Actions", - true, - )?; - match self.handle_actions(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Clips(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Clips", - true, - )?; - match self.handle_clips(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Break(event), false); - } + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_ct_path(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_ct_path(&mut values, data)?; + let data = Self::finish_state(helper, S::CtPath(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::CtPath(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } - }; - if let Some(fallback) = fallback { - *self.state__ = fallback; } - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + } + fn handle_ct_page_block_path_object<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtPageBlockPathObjectXElementType>, + ) -> Result, Error> { + use CtGraphicUnitXTypeDeserializerState as S; + let DeserializerOutput { + artifact, event, allow_any, - }) + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_ct_page_block_path_object(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_ct_page_block_path_object(&mut values, data)?; + let data = Self::finish_state( + helper, + S::CtPageBlockPathObject(values, None, None), + )?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::CtPageBlockPathObject(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } } - fn finish( - mut self, + fn handle_ct_image<'de>( + &mut self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - CtGraphicUnitXTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::CtGraphicUnitXType { - boundary: self.boundary, - name: self.name, - visible: self.visible, - ctm: self.ctm, - draw_param: self.draw_param, - line_width: self.line_width, - cap: self.cap, - join: self.join, - miter_limit: self.miter_limit, - dash_offset: self.dash_offset, - dash_pattern: self.dash_pattern, - alpha: self.alpha, - actions: self.actions, - clips: self.clips, - }) - } - } - #[derive(Debug)] - pub struct CtImageXTypeDeserializer { - boundary: String, - name: Option, - visible: bool, - ctm: Option, - draw_param: Option, - line_width: f64, - cap: super::CtGraphicUnitCapXType, - join: super::CtGraphicUnitJoinXType, - miter_limit: f64, - dash_offset: f64, - dash_pattern: Option, - alpha: i32, - resource_id: u32, - substitution: Option, - image_mask: Option, - actions: Option, - clips: Option, - border: Option, - state__: Box, - } - #[derive(Debug)] - enum CtImageXTypeDeserializerState { - Init__, - Actions( - Option<::Deserializer>, - ), - Clips( - Option<::Deserializer>, - ), - Border(Option<::Deserializer>), - Done__, - Unknown__, - } - impl CtImageXTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut boundary: Option = None; - let mut name: Option = None; - let mut visible: Option = None; - let mut ctm: Option = None; - let mut draw_param: Option = None; - let mut line_width: Option = None; - let mut cap: Option = None; - let mut join: Option = None; - let mut miter_limit: Option = None; - let mut dash_offset: Option = None; - let mut dash_pattern: Option = None; - let mut alpha: Option = None; - let mut resource_id: Option = None; - let mut substitution: Option = None; - let mut image_mask: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Boundary") - ) { - helper.read_attrib(&mut boundary, b"Boundary", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Name") - ) { - helper.read_attrib(&mut name, b"Name", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Visible") - ) { - helper.read_attrib(&mut visible, b"Visible", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"CTM") - ) { - helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DrawParam") - ) { - helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"LineWidth") - ) { - helper.read_attrib(&mut line_width, b"LineWidth", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Cap") - ) { - helper.read_attrib(&mut cap, b"Cap", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Join") - ) { - helper.read_attrib(&mut join, b"Join", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"MiterLimit") - ) { - helper.read_attrib(&mut miter_limit, b"MiterLimit", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashOffset") - ) { - helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashPattern") - ) { - helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Alpha") - ) { - helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"ResourceID") - ) { - helper.read_attrib(&mut resource_id, b"ResourceID", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Substitution") - ) { - helper.read_attrib(&mut substitution, b"Substitution", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"ImageMask") - ) { - helper.read_attrib(&mut image_mask, b"ImageMask", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; - } - } - Ok(Self { - boundary: boundary - .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, - name: name, - visible: visible.unwrap_or_else(super::CtImageXType::default_visible), - ctm: ctm, - draw_param: draw_param, - line_width: line_width.unwrap_or_else(super::CtImageXType::default_line_width), - cap: cap.unwrap_or_else(super::CtImageXType::default_cap), - join: join.unwrap_or_else(super::CtImageXType::default_join), - miter_limit: miter_limit - .unwrap_or_else(super::CtImageXType::default_miter_limit), - dash_offset: dash_offset - .unwrap_or_else(super::CtImageXType::default_dash_offset), - dash_pattern: dash_pattern, - alpha: alpha.unwrap_or_else(super::CtImageXType::default_alpha), - resource_id: resource_id - .ok_or_else(|| ErrorKind::MissingAttribute("ResourceID".into()))?, - substitution: substitution, - image_mask: image_mask, - actions: None, - clips: None, - border: None, - state__: Box::new(CtImageXTypeDeserializerState::Init__), - }) - } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: CtImageXTypeDeserializerState, - ) -> Result<(), Error> { - use CtImageXTypeDeserializerState as S; - match state { - S::Actions(Some(deserializer)) => { - self.store_actions(deserializer.finish(helper)?)? - } - S::Clips(Some(deserializer)) => { - self.store_clips(deserializer.finish(helper)?)? - } - S::Border(Some(deserializer)) => { - self.store_border(deserializer.finish(helper)?)? - } - _ => (), - } - Ok(()) - } - fn store_actions( - &mut self, - value: super::CtGraphicUnitActionsXElementType, - ) -> Result<(), Error> { - if self.actions.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Actions", - )))?; - } - self.actions = Some(value); - Ok(()) - } - fn store_clips( - &mut self, - value: super::CtGraphicUnitClipsXElementType, - ) -> Result<(), Error> { - if self.clips.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Clips", - )))?; - } - self.clips = Some(value); - Ok(()) - } - fn store_border( - &mut self, - value: super::CtImageBorderXElementType, - ) -> Result<(), Error> { - if self.border.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Border", - )))?; - } - self.border = Some(value); - Ok(()) - } - fn handle_actions<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, - fallback: &mut Option, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CtImageXType>, ) -> Result, Error> { - use CtImageXTypeDeserializerState as S; + use CtGraphicUnitXTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Clips(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_ct_image(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_actions(data)?; - *self.state__ = S::Clips(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_ct_image(&mut values, data)?; + let data = Self::finish_state(helper, S::CtImage(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Actions(Some(deserializer))); - *self.state__ = S::Clips(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::CtImage(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_clips<'de>( + fn handle_ct_page_block_image_object<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtImageXTypeDeserializerState as S; + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtPageBlockImageObjectXElementType>, + ) -> Result, Error> { + use CtGraphicUnitXTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Border(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_ct_page_block_image_object(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_clips(data)?; - *self.state__ = S::Border(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_ct_page_block_image_object(&mut values, data)?; + let data = Self::finish_state( + helper, + S::CtPageBlockImageObject(values, None, None), + )?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Clips(Some(deserializer))); - *self.state__ = S::Border(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::CtPageBlockImageObject(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_border<'de>( + fn handle_ct_composite<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtImageBorderXElementType>, - fallback: &mut Option, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CtCompositeXType>, ) -> Result, Error> { - use CtImageXTypeDeserializerState as S; + use CtGraphicUnitXTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_ct_composite(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_border(data)?; - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_ct_composite(&mut values, data)?; + let data = Self::finish_state(helper, S::CtComposite(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Border(Some(deserializer))); - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::CtComposite(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_ct_page_block_composite_object<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback : Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer >, + output: DeserializerOutput<'de, super::CtPageBlockCompositeObjectXElementType>, + ) -> Result, Error> { + use CtGraphicUnitXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_ct_page_block_composite_object(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_ct_page_block_composite_object(&mut values, data)?; + let data = Self::finish_state( + helper, + S::CtPageBlockCompositeObject(values, None, None), + )?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = + S::CtPageBlockCompositeObject(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtImageXType> for CtImageXTypeDeserializer { + impl<'de> Deserializer<'de, super::CtGraphicUnitXType> for CtGraphicUnitXTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtImageXType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + ) -> DeserializerResult<'de, super::CtGraphicUnitXType> { + let deserializer = Self { + state__: Box::new(CtGraphicUnitXTypeDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, CtGraphicUnitXTypeDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtImageXType> { - use CtImageXTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtGraphicUnitXType> { + use CtGraphicUnitXTypeDeserializerState as S; let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Actions(Some(deserializer)), event) => { + (S::CtText(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_actions(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_ct_text(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::CtPageBlockTextObject(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_ct_page_block_text_object( + helper, values, fallback, output, + )? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::CtPath(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_ct_path(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Clips(Some(deserializer)), event) => { + (S::CtPageBlockPathObject(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_clips(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_ct_page_block_path_object( + helper, values, fallback, output, + )? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::CtImage(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_ct_image(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Border(Some(deserializer)), event) => { + ( + S::CtPageBlockImageObject(values, fallback, Some(deserializer)), + event, + ) => { let output = deserializer.next(helper, event)?; - match self.handle_border(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_ct_page_block_image_object( + helper, values, fallback, output, + )? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::CtComposite(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_ct_composite(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + ( + S::CtPageBlockCompositeObject(values, fallback, Some(deserializer)), + event, + ) => { + let output = deserializer.next(helper, event)?; + match self.handle_ct_page_block_composite_object( + helper, values, fallback, output, + )? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, } + } + (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), allow_any: false, }); } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Actions(None); - event - } - (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::CtText(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Actions", + b"CT_Text", true, )?; - match self.handle_actions(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_ct_text(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::CtPageBlockTextObject(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"CtPageBlockTextObject", + true, + )?; + match self.handle_ct_page_block_text_object( + helper, values, fallback, output, + )? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Clips(None), event @ (Event::Start(_) | Event::Empty(_))) => { + ( + S::CtPath(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Clips", + b"CT_Path", true, )?; - match self.handle_clips(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_ct_path(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::CtPageBlockPathObject(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"CtPageBlockPathObject", + true, + )?; + match self.handle_ct_page_block_path_object( + helper, values, fallback, output, + )? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Border(None), event @ (Event::Start(_) | Event::Empty(_))) => { + ( + S::CtImage(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Border", + b"CT_Image", true, )?; - match self.handle_border(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_ct_image(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::CtPageBlockImageObject(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"CtPageBlockImageObject", + true, + )?; + match self.handle_ct_page_block_image_object( + helper, values, fallback, output, + )? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); + ( + S::CtComposite(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"CT_Composite", + true, + )?; + match self.handle_ct_composite(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::CtPageBlockCompositeObject(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"CtPageBlockCompositeObject", + true, + )?; + match self.handle_ct_page_block_composite_object( + helper, values, fallback, output, + )? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); } (state, event) => { *self.state__ = state; - break (DeserializerEvent::Break(event), false); + break (DeserializerEvent::Continue(event), false); } } }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + artifact, event, allow_any, }) } fn finish( - mut self, + self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace(&mut *self.state__, CtImageXTypeDeserializerState::Unknown__); - self.finish_state(helper, state)?; - Ok(super::CtImageXType { - boundary: self.boundary, - name: self.name, - visible: self.visible, - ctm: self.ctm, - draw_param: self.draw_param, - line_width: self.line_width, - cap: self.cap, - join: self.join, - miter_limit: self.miter_limit, - dash_offset: self.dash_offset, - dash_pattern: self.dash_pattern, - alpha: self.alpha, - resource_id: self.resource_id, - substitution: self.substitution, - image_mask: self.image_mask, - actions: self.actions, - clips: self.clips, - border: self.border, - }) + ) -> Result { + Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct CtLaGouraudShdXTypeDeserializer { - vertices_per_row: i32, - extend: Option, - point: Vec, - back_color: Option, - state__: Box, + pub struct CtGraphicUnitDynDeserializer { + boundary: String, + name: Option, + visible: bool, + ctm: Option, + draw_param: Option, + line_width: f64, + cap: super::CtGraphicUnitCapXType, + join: super::CtGraphicUnitJoinXType, + miter_limit: f64, + dash_offset: f64, + dash_pattern: Option, + alpha: i32, + actions: Option, + clips: Option, + state__: Box, } #[derive(Debug)] - enum CtLaGouraudShdXTypeDeserializerState { + enum CtGraphicUnitDynDeserializerState { Init__, - Point( - Option<::Deserializer>, + Actions( + Option<::Deserializer>, + ), + Clips( + Option<::Deserializer>, ), - BackColor(Option<::Deserializer>), Done__, Unknown__, } - impl CtLaGouraudShdXTypeDeserializer { + impl CtGraphicUnitDynDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut vertices_per_row: Option = None; - let mut extend: Option = None; + let mut boundary: Option = None; + let mut name: Option = None; + let mut visible: Option = None; + let mut ctm: Option = None; + let mut draw_param: Option = None; + let mut line_width: Option = None; + let mut cap: Option = None; + let mut join: Option = None; + let mut miter_limit: Option = None; + let mut dash_offset: Option = None; + let mut dash_pattern: Option = None; + let mut alpha: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"VerticesPerRow") + Some(b"Boundary") ) { - helper.read_attrib( - &mut vertices_per_row, - b"VerticesPerRow", - &attrib.value, - )?; + helper.read_attrib(&mut boundary, b"Boundary", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Extend") + Some(b"Name") ) { - helper.read_attrib(&mut extend, b"Extend", &attrib.value)?; + helper.read_attrib(&mut name, b"Name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Visible") + ) { + helper.read_attrib(&mut visible, b"Visible", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"CTM") + ) { + helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DrawParam") + ) { + helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"LineWidth") + ) { + helper.read_attrib(&mut line_width, b"LineWidth", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Cap") + ) { + helper.read_attrib(&mut cap, b"Cap", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Join") + ) { + helper.read_attrib(&mut join, b"Join", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"MiterLimit") + ) { + helper.read_attrib(&mut miter_limit, b"MiterLimit", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DashOffset") + ) { + helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DashPattern") + ) { + helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Alpha") + ) { + helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - vertices_per_row: vertices_per_row - .ok_or_else(|| ErrorKind::MissingAttribute("VerticesPerRow".into()))?, - extend: extend, - point: Vec::new(), - back_color: None, - state__: Box::new(CtLaGouraudShdXTypeDeserializerState::Init__), + boundary: boundary + .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, + name: name, + visible: visible.unwrap_or_else(super::CtGraphicUnitDyn::default_visible), + ctm: ctm, + draw_param: draw_param, + line_width: line_width + .unwrap_or_else(super::CtGraphicUnitDyn::default_line_width), + cap: cap.unwrap_or_else(super::CtGraphicUnitDyn::default_cap), + join: join.unwrap_or_else(super::CtGraphicUnitDyn::default_join), + miter_limit: miter_limit + .unwrap_or_else(super::CtGraphicUnitDyn::default_miter_limit), + dash_offset: dash_offset + .unwrap_or_else(super::CtGraphicUnitDyn::default_dash_offset), + dash_pattern: dash_pattern, + alpha: alpha.unwrap_or_else(super::CtGraphicUnitDyn::default_alpha), + actions: None, + clips: None, + state__: Box::new(CtGraphicUnitDynDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: CtLaGouraudShdXTypeDeserializerState, + state: CtGraphicUnitDynDeserializerState, ) -> Result<(), Error> { - use CtLaGouraudShdXTypeDeserializerState as S; + use CtGraphicUnitDynDeserializerState as S; match state { - S::Point(Some(deserializer)) => { - self.store_point(deserializer.finish(helper)?)? + S::Actions(Some(deserializer)) => { + self.store_actions(deserializer.finish(helper)?)? } - S::BackColor(Some(deserializer)) => { - self.store_back_color(deserializer.finish(helper)?)? + S::Clips(Some(deserializer)) => { + self.store_clips(deserializer.finish(helper)?)? } _ => (), } Ok(()) } - fn store_point( + fn store_actions( &mut self, - value: super::CtLaGouraudShdPointXElementType, + value: super::CtGraphicUnitActionsXElementType, ) -> Result<(), Error> { - self.point.push(value); + if self.actions.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Actions", + )))?; + } + self.actions = Some(value); Ok(()) } - fn store_back_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { - if self.back_color.is_some() { + fn store_clips( + &mut self, + value: super::CtGraphicUnitClipsXElementType, + ) -> Result<(), Error> { + if self.clips.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"BackColor", + b"Clips", )))?; } - self.back_color = Some(value); + self.clips = Some(value); Ok(()) } - fn handle_point<'de>( + fn handle_actions<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtLaGouraudShdPointXElementType>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, + fallback: &mut Option, ) -> Result, Error> { - use CtLaGouraudShdXTypeDeserializerState as S; + use CtGraphicUnitDynDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - if self.point.len() < 4usize { - fallback.get_or_insert(S::Point(None)); - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } else { - *self.state__ = S::BackColor(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } + *self.state__ = S::Clips(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; @@ -26312,24 +26415,24 @@ pub mod page { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_point(data)?; - *self.state__ = S::Point(None); + self.store_actions(data)?; + *self.state__ = S::Clips(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Point(Some(deserializer))); - *self.state__ = S::Point(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + fallback.get_or_insert(S::Actions(Some(deserializer))); + *self.state__ = S::Clips(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } - fn handle_back_color<'de>( + fn handle_clips<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtColorXType>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, + fallback: &mut Option, ) -> Result, Error> { - use CtLaGouraudShdXTypeDeserializerState as S; + use CtGraphicUnitDynDeserializerState as S; let DeserializerOutput { artifact, event, @@ -26345,31 +26448,31 @@ pub mod page { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_back_color(data)?; + self.store_clips(data)?; *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::BackColor(Some(deserializer))); + fallback.get_or_insert(S::Clips(Some(deserializer))); *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtLaGouraudShdXType> for CtLaGouraudShdXTypeDeserializer { + impl<'de> Deserializer<'de, super::CtGraphicUnitDyn> for CtGraphicUnitDynDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtLaGouraudShdXType> { + ) -> DeserializerResult<'de, super::CtGraphicUnitDyn> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtLaGouraudShdXType> { - use CtLaGouraudShdXTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtGraphicUnitDyn> { + use CtGraphicUnitDynDeserializerState as S; let mut event = event; let mut fallback = None; let mut allow_any_element = false; @@ -26377,9 +26480,9 @@ pub mod page { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Point(Some(deserializer)), event) => { + (S::Actions(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_point(helper, output, &mut fallback)? { + match self.handle_actions(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -26389,9 +26492,9 @@ pub mod page { } } } - (S::BackColor(Some(deserializer)), event) => { + (S::Clips(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_back_color(helper, output, &mut fallback)? { + match self.handle_clips(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -26413,17 +26516,17 @@ pub mod page { } (S::Init__, event) => { fallback.get_or_insert(S::Init__); - *self.state__ = S::Point(None); + *self.state__ = S::Actions(None); event } - (S::Point(None), event @ (Event::Start(_) | Event::Empty(_))) => { + (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Point", + b"Actions", true, )?; - match self.handle_point(helper, output, &mut fallback)? { + match self.handle_actions(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -26433,14 +26536,14 @@ pub mod page { } } } - (S::BackColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { + (S::Clips(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"BackColor", + b"Clips", true, )?; - match self.handle_back_color(helper, output, &mut fallback)? { + match self.handle_clips(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -26472,167 +26575,485 @@ pub mod page { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - CtLaGouraudShdXTypeDeserializerState::Unknown__, + CtGraphicUnitDynDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::CtLaGouraudShdXType { - vertices_per_row: self.vertices_per_row, - extend: self.extend, - point: helper.finish_vec(4usize, None, self.point)?, - back_color: self.back_color.map(Box::new), + Ok(super::CtGraphicUnitDyn { + boundary: self.boundary, + name: self.name, + visible: self.visible, + ctm: self.ctm, + draw_param: self.draw_param, + line_width: self.line_width, + cap: self.cap, + join: self.join, + miter_limit: self.miter_limit, + dash_offset: self.dash_offset, + dash_pattern: self.dash_pattern, + alpha: self.alpha, + actions: self.actions, + clips: self.clips, }) } } #[derive(Debug)] - pub struct CtLayerXTypeDeserializer { - type_: super::CtLayerTypeXType, + pub struct CtImageXTypeDeserializer { + boundary: String, + name: Option, + visible: bool, + ctm: Option, draw_param: Option, - content: Vec, - state__: Box, + line_width: f64, + cap: super::CtGraphicUnitCapXType, + join: super::CtGraphicUnitJoinXType, + miter_limit: f64, + dash_offset: f64, + dash_pattern: Option, + alpha: i32, + resource_id: u32, + substitution: Option, + image_mask: Option, + actions: Option, + clips: Option, + border: Option, + state__: Box, } #[derive(Debug)] - enum CtLayerXTypeDeserializerState { + enum CtImageXTypeDeserializerState { Init__, - Next__, - Content__(::Deserializer), + Actions( + Option<::Deserializer>, + ), + Clips( + Option<::Deserializer>, + ), + Border(Option<::Deserializer>), + Done__, Unknown__, } - impl CtLayerXTypeDeserializer { + impl CtImageXTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut type_: Option = None; + let mut boundary: Option = None; + let mut name: Option = None; + let mut visible: Option = None; + let mut ctm: Option = None; let mut draw_param: Option = None; + let mut line_width: Option = None; + let mut cap: Option = None; + let mut join: Option = None; + let mut miter_limit: Option = None; + let mut dash_offset: Option = None; + let mut dash_pattern: Option = None; + let mut alpha: Option = None; + let mut resource_id: Option = None; + let mut substitution: Option = None; + let mut image_mask: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Type") + Some(b"Boundary") ) { - helper.read_attrib(&mut type_, b"Type", &attrib.value)?; + helper.read_attrib(&mut boundary, b"Boundary", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Name") + ) { + helper.read_attrib(&mut name, b"Name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Visible") + ) { + helper.read_attrib(&mut visible, b"Visible", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"CTM") + ) { + helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), Some(b"DrawParam") ) { helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"LineWidth") + ) { + helper.read_attrib(&mut line_width, b"LineWidth", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Cap") + ) { + helper.read_attrib(&mut cap, b"Cap", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Join") + ) { + helper.read_attrib(&mut join, b"Join", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"MiterLimit") + ) { + helper.read_attrib(&mut miter_limit, b"MiterLimit", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DashOffset") + ) { + helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DashPattern") + ) { + helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Alpha") + ) { + helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"ResourceID") + ) { + helper.read_attrib(&mut resource_id, b"ResourceID", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Substitution") + ) { + helper.read_attrib(&mut substitution, b"Substitution", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"ImageMask") + ) { + helper.read_attrib(&mut image_mask, b"ImageMask", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - type_: type_.unwrap_or_else(super::CtLayerXType::default_type_), + boundary: boundary + .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, + name: name, + visible: visible.unwrap_or_else(super::CtImageXType::default_visible), + ctm: ctm, draw_param: draw_param, - content: Vec::new(), - state__: Box::new(CtLayerXTypeDeserializerState::Init__), + line_width: line_width.unwrap_or_else(super::CtImageXType::default_line_width), + cap: cap.unwrap_or_else(super::CtImageXType::default_cap), + join: join.unwrap_or_else(super::CtImageXType::default_join), + miter_limit: miter_limit + .unwrap_or_else(super::CtImageXType::default_miter_limit), + dash_offset: dash_offset + .unwrap_or_else(super::CtImageXType::default_dash_offset), + dash_pattern: dash_pattern, + alpha: alpha.unwrap_or_else(super::CtImageXType::default_alpha), + resource_id: resource_id + .ok_or_else(|| ErrorKind::MissingAttribute("ResourceID".into()))?, + substitution: substitution, + image_mask: image_mask, + actions: None, + clips: None, + border: None, + state__: Box::new(CtImageXTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: CtLayerXTypeDeserializerState, + state: CtImageXTypeDeserializerState, ) -> Result<(), Error> { - if let CtLayerXTypeDeserializerState::Content__(deserializer) = state { - self.store_content(deserializer.finish(helper)?)?; + use CtImageXTypeDeserializerState as S; + match state { + S::Actions(Some(deserializer)) => { + self.store_actions(deserializer.finish(helper)?)? + } + S::Clips(Some(deserializer)) => { + self.store_clips(deserializer.finish(helper)?)? + } + S::Border(Some(deserializer)) => { + self.store_border(deserializer.finish(helper)?)? + } + _ => (), } Ok(()) } - fn store_content(&mut self, value: super::CtLayerXTypeContent) -> Result<(), Error> { - self.content.push(value); + fn store_actions( + &mut self, + value: super::CtGraphicUnitActionsXElementType, + ) -> Result<(), Error> { + if self.actions.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Actions", + )))?; + } + self.actions = Some(value); Ok(()) } - fn handle_content<'de>( + fn store_clips( &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtLayerXTypeContent>, - fallback: &mut Option, - ) -> Result, Error> { - use CtLayerXTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = fallback.take().unwrap_or(S::Next__); - return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); + value: super::CtGraphicUnitClipsXElementType, + ) -> Result<(), Error> { + if self.clips.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Clips", + )))?; } - if let Some(fallback) = fallback.take() { + self.clips = Some(value); + Ok(()) + } + fn store_border( + &mut self, + value: super::CtImageBorderXElementType, + ) -> Result<(), Error> { + if self.border.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Border", + )))?; + } + self.border = Some(value); + Ok(()) + } + fn handle_actions<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtImageXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Clips(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_content(data)?; - *self.state__ = S::Next__; + self.store_actions(data)?; + *self.state__ = S::Clips(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *fallback = Some(S::Content__(deserializer)); - *self.state__ = S::Next__; + fallback.get_or_insert(S::Actions(Some(deserializer))); + *self.state__ = S::Clips(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_clips<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtImageXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Border(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_clips(data)?; + *self.state__ = S::Border(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Clips(Some(deserializer))); + *self.state__ = S::Border(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_border<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtImageBorderXElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtImageXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_border(data)?; + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Border(Some(deserializer))); + *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtLayerXType> for CtLayerXTypeDeserializer { + impl<'de> Deserializer<'de, super::CtImageXType> for CtImageXTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtLayerXType> { + ) -> DeserializerResult<'de, super::CtImageXType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtLayerXType> { - use CtLayerXTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtImageXType> { + use CtImageXTypeDeserializerState as S; let mut event = event; let mut fallback = None; + let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Content__(deserializer), event) => { + (S::Actions(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_content(helper, output, &mut fallback)? { + match self.handle_actions(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Clips(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_clips(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Border(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_border(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } return Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), event: DeserializerEvent::None, allow_any: false, }); } - (state @ (S::Init__ | S::Next__), event) => { - fallback.get_or_insert(state); - let output = ::init( - helper, event, + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Actions(None); + event + } + (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Actions", + true, )?; - match self.handle_content(helper, output, &mut fallback)? { + match self.handle_actions(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Clips(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Clips", + true, + )?; + match self.handle_clips(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Border(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Border", + true, + )?; + match self.handle_border(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } } }; if let Some(fallback) = fallback { *self.state__ = fallback; } - let artifact = DeserializerArtifact::Deserializer(self); Ok(DeserializerOutput { - artifact, + artifact: DeserializerArtifact::Deserializer(self), event, allow_any, }) @@ -26640,635 +27061,390 @@ pub mod page { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace(&mut *self.state__, CtLayerXTypeDeserializerState::Unknown__); + ) -> Result { + let state = replace(&mut *self.state__, CtImageXTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::CtLayerXType { - type_: self.type_, + Ok(super::CtImageXType { + boundary: self.boundary, + name: self.name, + visible: self.visible, + ctm: self.ctm, draw_param: self.draw_param, - content: helper.finish_vec(0usize, None, self.content)?, + line_width: self.line_width, + cap: self.cap, + join: self.join, + miter_limit: self.miter_limit, + dash_offset: self.dash_offset, + dash_pattern: self.dash_pattern, + alpha: self.alpha, + resource_id: self.resource_id, + substitution: self.substitution, + image_mask: self.image_mask, + actions: self.actions, + clips: self.clips, + border: self.border, }) } } #[derive(Debug)] - pub struct CtLayerXTypeContentDeserializer { - state__: Box, + pub struct CtLaGouraudShdXTypeDeserializer { + vertices_per_row: i32, + extend: Option, + point: Vec, + back_color: Option, + state__: Box, } #[derive(Debug)] - pub enum CtLayerXTypeContentDeserializerState { - Init__ , TextObject (Option < super :: CtPageBlockTextObjectXElementType > , Option << super :: CtPageBlockTextObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockTextObjectXElementType as WithDeserializer > :: Deserializer > ,) , PathObject (Option < super :: CtPageBlockPathObjectXElementType > , Option << super :: CtPageBlockPathObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockPathObjectXElementType as WithDeserializer > :: Deserializer > ,) , ImageObject (Option < super :: CtPageBlockImageObjectXElementType > , Option << super :: CtPageBlockImageObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockImageObjectXElementType as WithDeserializer > :: Deserializer > ,) , CompositeObject (Option < super :: CtPageBlockCompositeObjectXElementType > , Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer > ,) , PageBlock (Option < super :: CtPageBlockPageBlockXElementType > , Option << super :: CtPageBlockPageBlockXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockPageBlockXElementType as WithDeserializer > :: Deserializer > ,) , Done__ (super :: CtLayerXTypeContent) , Unknown__ , } - impl CtLayerXTypeContentDeserializer { - fn find_suitable<'de>( - &mut self, + enum CtLaGouraudShdXTypeDeserializerState { + Init__, + Point( + Option<::Deserializer>, + ), + BackColor(Option<::Deserializer>), + Done__, + Unknown__, + } + impl CtLaGouraudShdXTypeDeserializer { + fn from_bytes_start( helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> Result, Error> { - if let Event::Start(x) | Event::Empty(x) = &event { - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"TextObject") - ) { - let output = - ::init( - helper, event, - )?; - return self.handle_text_object(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"PathObject") - ) { - let output = - ::init( - helper, event, - )?; - return self.handle_path_object(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"ImageObject") - ) { - let output = - ::init( - helper, event, - )?; - return self.handle_image_object(helper, Default::default(), None, output); - } + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut vertices_per_row: Option = None; + let mut extend: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"CompositeObject") + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"VerticesPerRow") ) { - let output = < super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: init (helper , event) ? ; - return self.handle_composite_object( - helper, - Default::default(), - None, - output, - ); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"PageBlock") + helper.read_attrib( + &mut vertices_per_row, + b"VerticesPerRow", + &attrib.value, + )?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Extend") ) { - let output = - ::init( - helper, event, - )?; - return self.handle_page_block(helper, Default::default(), None, output); + helper.read_attrib(&mut extend, b"Extend", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; } } - *self.state__ = CtLayerXTypeContentDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent(event, false)) + Ok(Self { + vertices_per_row: vertices_per_row + .ok_or_else(|| ErrorKind::MissingAttribute("VerticesPerRow".into()))?, + extend: extend, + point: Vec::new(), + back_color: None, + state__: Box::new(CtLaGouraudShdXTypeDeserializerState::Init__), + }) } fn finish_state( + &mut self, helper: &mut DeserializeHelper, - state: CtLayerXTypeContentDeserializerState, - ) -> Result { - use CtLayerXTypeContentDeserializerState as S; + state: CtLaGouraudShdXTypeDeserializerState, + ) -> Result<(), Error> { + use CtLaGouraudShdXTypeDeserializerState as S; match state { - S::Init__ => Err(ErrorKind::MissingContent.into()), - S::TextObject(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_text_object(&mut values, value)?; - } - Ok(super::CtLayerXTypeContent::TextObject( - helper.finish_element("TextObject", values)?, - )) - } - S::PathObject(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_path_object(&mut values, value)?; - } - Ok(super::CtLayerXTypeContent::PathObject( - helper.finish_element("PathObject", values)?, - )) - } - S::ImageObject(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_image_object(&mut values, value)?; - } - Ok(super::CtLayerXTypeContent::ImageObject( - helper.finish_element("ImageObject", values)?, - )) - } - S::CompositeObject(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_composite_object(&mut values, value)?; - } - Ok(super::CtLayerXTypeContent::CompositeObject( - helper.finish_element("CompositeObject", values)?, - )) + S::Point(Some(deserializer)) => { + self.store_point(deserializer.finish(helper)?)? } - S::PageBlock(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_page_block(&mut values, value)?; - } - Ok(super::CtLayerXTypeContent::PageBlock( - helper.finish_element("PageBlock", values)?, - )) + S::BackColor(Some(deserializer)) => { + self.store_back_color(deserializer.finish(helper)?)? } - S::Done__(data) => Ok(data), - _ => unreachable!(), - } - } - fn store_text_object( - values: &mut Option, - value: super::CtPageBlockTextObjectXElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"TextObject", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_path_object( - values: &mut Option, - value: super::CtPageBlockPathObjectXElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"PathObject", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_image_object( - values: &mut Option, - value: super::CtPageBlockImageObjectXElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"ImageObject", - )))?; + _ => (), } - *values = Some(value); Ok(()) } - fn store_composite_object( - values: &mut Option, - value: super::CtPageBlockCompositeObjectXElementType, + fn store_point( + &mut self, + value: super::CtLaGouraudShdPointXElementType, ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"CompositeObject", - )))?; - } - *values = Some(value); + self.point.push(value); Ok(()) } - fn store_page_block( - values: &mut Option, - value: super::CtPageBlockPageBlockXElementType, - ) -> Result<(), Error> { - if values.is_some() { + fn store_back_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { + if self.back_color.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"PageBlock", + b"BackColor", )))?; } - *values = Some(value); + self.back_color = Some(value); Ok(()) } - fn handle_text_object<'de>( + fn handle_point<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option< - ::Deserializer, - >, - output: DeserializerOutput<'de, super::CtPageBlockTextObjectXElementType>, + output: DeserializerOutput<'de, super::CtLaGouraudShdPointXElementType>, + fallback: &mut Option, ) -> Result, Error> { - use CtLayerXTypeContentDeserializerState as S; + use CtLaGouraudShdXTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + if self.point.len() < 4usize { + fallback.get_or_insert(S::Point(None)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } else { + *self.state__ = S::BackColor(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_text_object(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_text_object(&mut values, data)?; - let data = Self::finish_state(helper, S::TextObject(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_point(data)?; + *self.state__ = S::Point(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::TextObject(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + fallback.get_or_insert(S::Point(Some(deserializer))); + *self.state__ = S::Point(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } - fn handle_path_object<'de>( + fn handle_back_color<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option< - ::Deserializer, - >, - output: DeserializerOutput<'de, super::CtPageBlockPathObjectXElementType>, - ) -> Result, Error> { - use CtLayerXTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_path_object(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_path_object(&mut values, data)?; - let data = Self::finish_state(helper, S::PathObject(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::PathObject(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_image_object<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option< - ::Deserializer, - >, - output: DeserializerOutput<'de, super::CtPageBlockImageObjectXElementType>, - ) -> Result, Error> { - use CtLayerXTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_image_object(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_image_object(&mut values, data)?; - let data = Self::finish_state(helper, S::ImageObject(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::ImageObject(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_composite_object<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback : Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer >, - output: DeserializerOutput<'de, super::CtPageBlockCompositeObjectXElementType>, - ) -> Result, Error> { - use CtLayerXTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_composite_object(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_composite_object(&mut values, data)?; - let data = - Self::finish_state(helper, S::CompositeObject(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::CompositeObject(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_page_block<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option< - ::Deserializer, - >, - output: DeserializerOutput<'de, super::CtPageBlockPageBlockXElementType>, + output: DeserializerOutput<'de, super::CtColorXType>, + fallback: &mut Option, ) -> Result, Error> { - use CtLayerXTypeContentDeserializerState as S; + use CtLaGouraudShdXTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_page_block(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_page_block(&mut values, data)?; - let data = Self::finish_state(helper, S::PageBlock(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_back_color(data)?; + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::PageBlock(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + fallback.get_or_insert(S::BackColor(Some(deserializer))); + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtLayerXTypeContent> for CtLayerXTypeContentDeserializer { + impl<'de> Deserializer<'de, super::CtLaGouraudShdXType> for CtLaGouraudShdXTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtLayerXTypeContent> { - let deserializer = Self { - state__: Box::new(CtLayerXTypeContentDeserializerState::Init__), - }; - let mut output = deserializer.next(helper, event)?; - output.artifact = match output.artifact { - DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, CtLayerXTypeContentDeserializerState::Init__) => - { - DeserializerArtifact::None - } - artifact => artifact, - }; - Ok(output) + ) -> DeserializerResult<'de, super::CtLaGouraudShdXType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtLayerXTypeContent> { - use CtLayerXTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::CtLaGouraudShdXType> { + use CtLaGouraudShdXTypeDeserializerState as S; let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::TextObject(values, fallback, Some(deserializer)), event) => { + (S::Point(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_text_object(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + match self.handle_point(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::PathObject(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_path_object(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (S::ImageObject(values, fallback, Some(deserializer)), event) => { + (S::BackColor(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_image_object(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + match self.handle_back_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::CompositeObject(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_composite_object(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (S::PageBlock(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_page_block(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } - } - (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(Self::finish_state( - helper, state, - )?), - event: DeserializerEvent::Continue(event), + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, allow_any: false, }); } - (S::Init__, event) => match self.find_suitable(helper, event)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - }, - ( - S::TextObject(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Point(None); + event + } + (S::Point(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"TextObject", + b"Point", true, )?; - match self.handle_text_object(helper, values, fallback, output)? { + match self.handle_point(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - ( - S::PathObject(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { + (S::BackColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"PathObject", + b"BackColor", true, )?; - match self.handle_path_object(helper, values, fallback, output)? { + match self.handle_back_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - ( - S::ImageObject(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"ImageObject", - true, - )?; - match self.handle_image_object(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::CompositeObject(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"CompositeObject", - true, - )?; - match self.handle_composite_object(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::PageBlock(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"PageBlock", - true, - )?; - match self.handle_page_block(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (state @ S::Done__(_), event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); } (state, event) => { *self.state__ = state; - break (DeserializerEvent::Continue(event), false); + break (DeserializerEvent::Break(event), false); } } }; - let artifact = if matches!(&*self.state__, S::Done__(_)) { - DeserializerArtifact::Data(self.finish(helper)?) - } else { - DeserializerArtifact::Deserializer(self) - }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } Ok(DeserializerOutput { - artifact, + artifact: DeserializerArtifact::Deserializer(self), event, allow_any, }) } fn finish( - self, + mut self, helper: &mut DeserializeHelper, - ) -> Result { - Self::finish_state(helper, *self.state__) + ) -> Result { + let state = replace( + &mut *self.state__, + CtLaGouraudShdXTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::CtLaGouraudShdXType { + vertices_per_row: self.vertices_per_row, + extend: self.extend, + point: helper.finish_vec(4usize, None, self.point)?, + back_color: self.back_color.map(Box::new), + }) } } #[derive(Debug)] - pub struct CtPageBlockXTypeDeserializer { - content: Vec, - state__: Box, + pub struct CtLayerXTypeDeserializer { + type_: super::CtLayerTypeXType, + draw_param: Option, + content: Vec, + state__: Box, } #[derive(Debug)] - enum CtPageBlockXTypeDeserializerState { + enum CtLayerXTypeDeserializerState { Init__, Next__, - Content__(::Deserializer), + Content__(::Deserializer), Unknown__, } - impl CtPageBlockXTypeDeserializer { + impl CtLayerXTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { + let mut type_: Option = None; + let mut draw_param: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; - helper.raise_unexpected_attrib_checked(&attrib)?; + if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Type") + ) { + helper.read_attrib(&mut type_, b"Type", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DrawParam") + ) { + helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } } Ok(Self { + type_: type_.unwrap_or_else(super::CtLayerXType::default_type_), + draw_param: draw_param, content: Vec::new(), - state__: Box::new(CtPageBlockXTypeDeserializerState::Init__), + state__: Box::new(CtLayerXTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: CtPageBlockXTypeDeserializerState, + state: CtLayerXTypeDeserializerState, ) -> Result<(), Error> { - if let CtPageBlockXTypeDeserializerState::Content__(deserializer) = state { + if let CtLayerXTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content( - &mut self, - value: super::CtPageBlockXTypeContent, - ) -> Result<(), Error> { + fn store_content(&mut self, value: super::CtLayerXTypeContent) -> Result<(), Error> { self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtPageBlockXTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::CtLayerXTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use CtPageBlockXTypeDeserializerState as S; + use CtLayerXTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -27296,19 +27472,19 @@ pub mod page { } } } - impl<'de> Deserializer<'de, super::CtPageBlockXType> for CtPageBlockXTypeDeserializer { + impl<'de> Deserializer<'de, super::CtLayerXType> for CtLayerXTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockXType> { + ) -> DeserializerResult<'de, super::CtLayerXType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockXType> { - use CtPageBlockXTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtLayerXType> { + use CtLayerXTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -27333,10 +27509,9 @@ pub mod page { } (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); - let output = - ::init( - helper, event, - )?; + let output = ::init( + helper, event, + )?; match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) @@ -27359,25 +27534,24 @@ pub mod page { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - CtPageBlockXTypeDeserializerState::Unknown__, - ); + ) -> Result { + let state = replace(&mut *self.state__, CtLayerXTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::CtPageBlockXType { + Ok(super::CtLayerXType { + type_: self.type_, + draw_param: self.draw_param, content: helper.finish_vec(0usize, None, self.content)?, }) } } #[derive(Debug)] - pub struct CtPageBlockXTypeContentDeserializer { - state__: Box, + pub struct CtLayerXTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - pub enum CtPageBlockXTypeContentDeserializerState { - Init__ , TextObject (Option < super :: CtPageBlockTextObjectXElementType > , Option << super :: CtPageBlockTextObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockTextObjectXElementType as WithDeserializer > :: Deserializer > ,) , PathObject (Option < super :: CtPageBlockPathObjectXElementType > , Option << super :: CtPageBlockPathObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockPathObjectXElementType as WithDeserializer > :: Deserializer > ,) , ImageObject (Option < super :: CtPageBlockImageObjectXElementType > , Option << super :: CtPageBlockImageObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockImageObjectXElementType as WithDeserializer > :: Deserializer > ,) , CompositeObject (Option < super :: CtPageBlockCompositeObjectXElementType > , Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer > ,) , PageBlock (Option < super :: CtPageBlockPageBlockXElementType > , Option << super :: CtPageBlockPageBlockXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockPageBlockXElementType as WithDeserializer > :: Deserializer > ,) , Done__ (super :: CtPageBlockXTypeContent) , Unknown__ , } - impl CtPageBlockXTypeContentDeserializer { + pub enum CtLayerXTypeContentDeserializerState { + Init__ , TextObject (Option < super :: CtPageBlockTextObjectXElementType > , Option << super :: CtPageBlockTextObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockTextObjectXElementType as WithDeserializer > :: Deserializer > ,) , PathObject (Option < super :: CtPageBlockPathObjectXElementType > , Option << super :: CtPageBlockPathObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockPathObjectXElementType as WithDeserializer > :: Deserializer > ,) , ImageObject (Option < super :: CtPageBlockImageObjectXElementType > , Option << super :: CtPageBlockImageObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockImageObjectXElementType as WithDeserializer > :: Deserializer > ,) , CompositeObject (Option < super :: CtPageBlockCompositeObjectXElementType > , Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer > ,) , PageBlock (Option < super :: CtPageBlockPageBlockXElementType > , Option << super :: CtPageBlockPageBlockXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockPageBlockXElementType as WithDeserializer > :: Deserializer > ,) , Done__ (super :: CtLayerXTypeContent) , Unknown__ , } + impl CtLayerXTypeContentDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, @@ -27437,14 +27611,14 @@ pub mod page { return self.handle_page_block(helper, Default::default(), None, output); } } - *self.state__ = CtPageBlockXTypeContentDeserializerState::Init__; + *self.state__ = CtLayerXTypeContentDeserializerState::Init__; Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( helper: &mut DeserializeHelper, - state: CtPageBlockXTypeContentDeserializerState, - ) -> Result { - use CtPageBlockXTypeContentDeserializerState as S; + state: CtLayerXTypeContentDeserializerState, + ) -> Result { + use CtLayerXTypeContentDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), S::TextObject(mut values, None, deserializer) => { @@ -27452,7 +27626,7 @@ pub mod page { let value = deserializer.finish(helper)?; Self::store_text_object(&mut values, value)?; } - Ok(super::CtPageBlockXTypeContent::TextObject( + Ok(super::CtLayerXTypeContent::TextObject( helper.finish_element("TextObject", values)?, )) } @@ -27461,7 +27635,7 @@ pub mod page { let value = deserializer.finish(helper)?; Self::store_path_object(&mut values, value)?; } - Ok(super::CtPageBlockXTypeContent::PathObject( + Ok(super::CtLayerXTypeContent::PathObject( helper.finish_element("PathObject", values)?, )) } @@ -27470,7 +27644,7 @@ pub mod page { let value = deserializer.finish(helper)?; Self::store_image_object(&mut values, value)?; } - Ok(super::CtPageBlockXTypeContent::ImageObject( + Ok(super::CtLayerXTypeContent::ImageObject( helper.finish_element("ImageObject", values)?, )) } @@ -27479,7 +27653,7 @@ pub mod page { let value = deserializer.finish(helper)?; Self::store_composite_object(&mut values, value)?; } - Ok(super::CtPageBlockXTypeContent::CompositeObject( + Ok(super::CtLayerXTypeContent::CompositeObject( helper.finish_element("CompositeObject", values)?, )) } @@ -27488,7 +27662,7 @@ pub mod page { let value = deserializer.finish(helper)?; Self::store_page_block(&mut values, value)?; } - Ok(super::CtPageBlockXTypeContent::PageBlock( + Ok(super::CtLayerXTypeContent::PageBlock( helper.finish_element("PageBlock", values)?, )) } @@ -27565,7 +27739,7 @@ pub mod page { >, output: DeserializerOutput<'de, super::CtPageBlockTextObjectXElementType>, ) -> Result, Error> { - use CtPageBlockXTypeContentDeserializerState as S; + use CtLayerXTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -27601,7 +27775,7 @@ pub mod page { >, output: DeserializerOutput<'de, super::CtPageBlockPathObjectXElementType>, ) -> Result, Error> { - use CtPageBlockXTypeContentDeserializerState as S; + use CtLayerXTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -27637,7 +27811,7 @@ pub mod page { >, output: DeserializerOutput<'de, super::CtPageBlockImageObjectXElementType>, ) -> Result, Error> { - use CtPageBlockXTypeContentDeserializerState as S; + use CtLayerXTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -27671,7 +27845,7 @@ pub mod page { fallback : Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer >, output: DeserializerOutput<'de, super::CtPageBlockCompositeObjectXElementType>, ) -> Result, Error> { - use CtPageBlockXTypeContentDeserializerState as S; + use CtLayerXTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -27708,7 +27882,7 @@ pub mod page { >, output: DeserializerOutput<'de, super::CtPageBlockPageBlockXElementType>, ) -> Result, Error> { - use CtPageBlockXTypeContentDeserializerState as S; + use CtLayerXTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -27736,23 +27910,18 @@ pub mod page { } } } - impl<'de> Deserializer<'de, super::CtPageBlockXTypeContent> - for CtPageBlockXTypeContentDeserializer - { + impl<'de> Deserializer<'de, super::CtLayerXTypeContent> for CtLayerXTypeContentDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockXTypeContent> { + ) -> DeserializerResult<'de, super::CtLayerXTypeContent> { let deserializer = Self { - state__: Box::new(CtPageBlockXTypeContentDeserializerState::Init__), + state__: Box::new(CtLayerXTypeContentDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!( - &*x.state__, - CtPageBlockXTypeContentDeserializerState::Init__ - ) => + if matches!(&*x.state__, CtLayerXTypeContentDeserializerState::Init__) => { DeserializerArtifact::None } @@ -27764,8 +27933,8 @@ pub mod page { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockXTypeContent> { - use CtPageBlockXTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::CtLayerXTypeContent> { + use CtLayerXTypeContentDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); @@ -27940,269 +28109,68 @@ pub mod page { fn finish( self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct CtPathXTypeDeserializer { - boundary: String, - name: Option, - visible: bool, - ctm: Option, - draw_param: Option, - line_width: f64, - cap: super::CtGraphicUnitCapXType, - join: super::CtGraphicUnitJoinXType, - miter_limit: f64, - dash_offset: f64, - dash_pattern: Option, - alpha: i32, - stroke: bool, - fill: bool, - rule: super::CtPathRuleXType, - actions: Option, - clips: Option, - stroke_color: Option, - fill_color: Option, - abbreviated_data: Option, - state__: Box, + pub struct CtPageBlockXTypeDeserializer { + content: Vec, + state__: Box, } #[derive(Debug)] - enum CtPathXTypeDeserializerState { + enum CtPageBlockXTypeDeserializerState { Init__, - Actions( - Option<::Deserializer>, - ), - Clips( - Option<::Deserializer>, - ), - StrokeColor(Option<::Deserializer>), - FillColor(Option<::Deserializer>), - AbbreviatedData(Option<::Deserializer>), - Done__, + Next__, + Content__(::Deserializer), Unknown__, } - impl CtPathXTypeDeserializer { + impl CtPageBlockXTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut boundary: Option = None; - let mut name: Option = None; - let mut visible: Option = None; - let mut ctm: Option = None; - let mut draw_param: Option = None; - let mut line_width: Option = None; - let mut cap: Option = None; - let mut join: Option = None; - let mut miter_limit: Option = None; - let mut dash_offset: Option = None; - let mut dash_pattern: Option = None; - let mut alpha: Option = None; - let mut stroke: Option = None; - let mut fill: Option = None; - let mut rule: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Boundary") - ) { - helper.read_attrib(&mut boundary, b"Boundary", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Name") - ) { - helper.read_attrib(&mut name, b"Name", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Visible") - ) { - helper.read_attrib(&mut visible, b"Visible", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"CTM") - ) { - helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DrawParam") - ) { - helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"LineWidth") - ) { - helper.read_attrib(&mut line_width, b"LineWidth", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Cap") - ) { - helper.read_attrib(&mut cap, b"Cap", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Join") - ) { - helper.read_attrib(&mut join, b"Join", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"MiterLimit") - ) { - helper.read_attrib(&mut miter_limit, b"MiterLimit", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashOffset") - ) { - helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashPattern") - ) { - helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Alpha") - ) { - helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Stroke") - ) { - helper.read_attrib(&mut stroke, b"Stroke", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Fill") - ) { - helper.read_attrib(&mut fill, b"Fill", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Rule") - ) { - helper.read_attrib(&mut rule, b"Rule", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; - } + helper.raise_unexpected_attrib_checked(&attrib)?; } Ok(Self { - boundary: boundary - .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, - name: name, - visible: visible.unwrap_or_else(super::CtPathXType::default_visible), - ctm: ctm, - draw_param: draw_param, - line_width: line_width.unwrap_or_else(super::CtPathXType::default_line_width), - cap: cap.unwrap_or_else(super::CtPathXType::default_cap), - join: join.unwrap_or_else(super::CtPathXType::default_join), - miter_limit: miter_limit - .unwrap_or_else(super::CtPathXType::default_miter_limit), - dash_offset: dash_offset - .unwrap_or_else(super::CtPathXType::default_dash_offset), - dash_pattern: dash_pattern, - alpha: alpha.unwrap_or_else(super::CtPathXType::default_alpha), - stroke: stroke.unwrap_or_else(super::CtPathXType::default_stroke), - fill: fill.unwrap_or_else(super::CtPathXType::default_fill), - rule: rule.unwrap_or_else(super::CtPathXType::default_rule), - actions: None, - clips: None, - stroke_color: None, - fill_color: None, - abbreviated_data: None, - state__: Box::new(CtPathXTypeDeserializerState::Init__), + content: Vec::new(), + state__: Box::new(CtPageBlockXTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: CtPathXTypeDeserializerState, - ) -> Result<(), Error> { - use CtPathXTypeDeserializerState as S; - match state { - S::Actions(Some(deserializer)) => { - self.store_actions(deserializer.finish(helper)?)? - } - S::Clips(Some(deserializer)) => { - self.store_clips(deserializer.finish(helper)?)? - } - S::StrokeColor(Some(deserializer)) => { - self.store_stroke_color(deserializer.finish(helper)?)? - } - S::FillColor(Some(deserializer)) => { - self.store_fill_color(deserializer.finish(helper)?)? - } - S::AbbreviatedData(Some(deserializer)) => { - self.store_abbreviated_data(deserializer.finish(helper)?)? - } - _ => (), - } - Ok(()) - } - fn store_actions( - &mut self, - value: super::CtGraphicUnitActionsXElementType, + state: CtPageBlockXTypeDeserializerState, ) -> Result<(), Error> { - if self.actions.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Actions", - )))?; + if let CtPageBlockXTypeDeserializerState::Content__(deserializer) = state { + self.store_content(deserializer.finish(helper)?)?; } - self.actions = Some(value); Ok(()) } - fn store_clips( + fn store_content( &mut self, - value: super::CtGraphicUnitClipsXElementType, + value: super::CtPageBlockXTypeContent, ) -> Result<(), Error> { - if self.clips.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Clips", - )))?; - } - self.clips = Some(value); - Ok(()) - } - fn store_stroke_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { - if self.stroke_color.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"StrokeColor", - )))?; - } - self.stroke_color = Some(value); - Ok(()) - } - fn store_fill_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { - if self.fill_color.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"FillColor", - )))?; - } - self.fill_color = Some(value); - Ok(()) - } - fn store_abbreviated_data(&mut self, value: String) -> Result<(), Error> { - if self.abbreviated_data.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"AbbreviatedData", - )))?; - } - self.abbreviated_data = Some(value); + self.content.push(value); Ok(()) } - fn handle_actions<'de>( + fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::CtPageBlockXTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use CtPathXTypeDeserializerState as S; + use CtPageBlockXTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Clips(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + *self.state__ = fallback.take().unwrap_or(S::Next__); + return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); } if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; @@ -28210,921 +28178,668 @@ pub mod page { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_actions(data)?; - *self.state__ = S::Clips(None); + self.store_content(data)?; + *self.state__ = S::Next__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Actions(Some(deserializer))); - *self.state__ = S::Clips(None); + *fallback = Some(S::Content__(deserializer)); + *self.state__ = S::Next__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } - fn handle_clips<'de>( - &mut self, + } + impl<'de> Deserializer<'de, super::CtPageBlockXType> for CtPageBlockXTypeDeserializer { + fn init( helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtPathXTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::StrokeColor(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_clips(data)?; - *self.state__ = S::StrokeColor(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Clips(Some(deserializer))); - *self.state__ = S::StrokeColor(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtPageBlockXType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } - fn handle_stroke_color<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtColorXType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtPathXTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::FillColor(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_stroke_color(data)?; - *self.state__ = S::FillColor(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::StrokeColor(Some(deserializer))); - *self.state__ = S::FillColor(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - fn handle_fill_color<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtColorXType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtPathXTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::AbbreviatedData(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_fill_color(data)?; - *self.state__ = S::AbbreviatedData(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::FillColor(Some(deserializer))); - *self.state__ = S::AbbreviatedData(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - fn handle_abbreviated_data<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, String>, - fallback: &mut Option, - ) -> Result, Error> { - use CtPathXTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - fallback.get_or_insert(S::AbbreviatedData(None)); - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } else { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_abbreviated_data(data)?; - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::AbbreviatedData(Some(deserializer))); - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - } - impl<'de> Deserializer<'de, super::CtPathXType> for CtPathXTypeDeserializer { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPathXType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, + fn next( + mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPathXType> { - use CtPathXTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtPageBlockXType> { + use CtPageBlockXTypeDeserializerState as S; let mut event = event; let mut fallback = None; - let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Actions(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_actions(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Clips(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_clips(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::StrokeColor(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_stroke_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::FillColor(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_fill_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::AbbreviatedData(Some(deserializer)), event) => { + (S::Content__(deserializer), event) => { let output = deserializer.next(helper, event)?; - match self.handle_abbreviated_data(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } return Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), event: DeserializerEvent::None, allow_any: false, }); } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Actions(None); - event - } - (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Actions", - true, - )?; - match self.handle_actions(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + (state @ (S::Init__ | S::Next__), event) => { + fallback.get_or_insert(state); + let output = + ::init( + helper, event, + )?; + match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Clips(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Clips", - true, + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + let artifact = DeserializerArtifact::Deserializer(self); + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + CtPageBlockXTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::CtPageBlockXType { + content: helper.finish_vec(0usize, None, self.content)?, + }) + } + } + #[derive(Debug)] + pub struct CtPageBlockXTypeContentDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum CtPageBlockXTypeContentDeserializerState { + Init__ , TextObject (Option < super :: CtPageBlockTextObjectXElementType > , Option << super :: CtPageBlockTextObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockTextObjectXElementType as WithDeserializer > :: Deserializer > ,) , PathObject (Option < super :: CtPageBlockPathObjectXElementType > , Option << super :: CtPageBlockPathObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockPathObjectXElementType as WithDeserializer > :: Deserializer > ,) , ImageObject (Option < super :: CtPageBlockImageObjectXElementType > , Option << super :: CtPageBlockImageObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockImageObjectXElementType as WithDeserializer > :: Deserializer > ,) , CompositeObject (Option < super :: CtPageBlockCompositeObjectXElementType > , Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer > ,) , PageBlock (Option < super :: CtPageBlockPageBlockXElementType > , Option << super :: CtPageBlockPageBlockXElementType as WithDeserializer > :: Deserializer > , Option << super :: CtPageBlockPageBlockXElementType as WithDeserializer > :: Deserializer > ,) , Done__ (super :: CtPageBlockXTypeContent) , Unknown__ , } + impl CtPageBlockXTypeContentDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"TextObject") + ) { + let output = + ::init( + helper, event, )?; - match self.handle_clips(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::StrokeColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"StrokeColor", - true, - )?; - match self.handle_stroke_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::FillColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"FillColor", - true, - )?; - match self.handle_fill_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::AbbreviatedData(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"AbbreviatedData", - false, - )?; - match self.handle_abbreviated_data(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Break(event), false); - } + return self.handle_text_object(helper, Default::default(), None, output); } - }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), - event, - allow_any, - }) - } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace(&mut *self.state__, CtPathXTypeDeserializerState::Unknown__); - self.finish_state(helper, state)?; - Ok(super::CtPathXType { - boundary: self.boundary, - name: self.name, - visible: self.visible, - ctm: self.ctm, - draw_param: self.draw_param, - line_width: self.line_width, - cap: self.cap, - join: self.join, - miter_limit: self.miter_limit, - dash_offset: self.dash_offset, - dash_pattern: self.dash_pattern, - alpha: self.alpha, - stroke: self.stroke, - fill: self.fill, - rule: self.rule, - actions: self.actions, - clips: self.clips, - stroke_color: self.stroke_color, - fill_color: self.fill_color, - abbreviated_data: helper - .finish_element("AbbreviatedData", self.abbreviated_data)?, - }) - } - } - #[derive(Debug)] - pub struct CtPatternXTypeDeserializer { - width: f64, - height: f64, - x_step: Option, - y_step: Option, - reflect_method: super::CtPatternReflectMethodXType, - relative_to: super::CtPatternRelativeToXType, - ctm: Option, - cell_content: Option, - state__: Box, - } - #[derive(Debug)] - enum CtPatternXTypeDeserializerState { - Init__, - CellContent( - Option<::Deserializer>, - ), - Done__, - Unknown__, - } - impl CtPatternXTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut width: Option = None; - let mut height: Option = None; - let mut x_step: Option = None; - let mut y_step: Option = None; - let mut reflect_method: Option = None; - let mut relative_to: Option = None; - let mut ctm: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Width") - ) { - helper.read_attrib(&mut width, b"Width", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Height") - ) { - helper.read_attrib(&mut height, b"Height", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"XStep") - ) { - helper.read_attrib(&mut x_step, b"XStep", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"YStep") + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"PathObject") ) { - helper.read_attrib(&mut y_step, b"YStep", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"ReflectMethod") + let output = + ::init( + helper, event, + )?; + return self.handle_path_object(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"ImageObject") ) { - helper.read_attrib(&mut reflect_method, b"ReflectMethod", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"RelativeTo") + let output = + ::init( + helper, event, + )?; + return self.handle_image_object(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"CompositeObject") ) { - helper.read_attrib(&mut relative_to, b"RelativeTo", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"CTM") + let output = < super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: init (helper , event) ? ; + return self.handle_composite_object( + helper, + Default::default(), + None, + output, + ); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"PageBlock") ) { - helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; + let output = + ::init( + helper, event, + )?; + return self.handle_page_block(helper, Default::default(), None, output); } } - Ok(Self { - width: width.ok_or_else(|| ErrorKind::MissingAttribute("Width".into()))?, - height: height.ok_or_else(|| ErrorKind::MissingAttribute("Height".into()))?, - x_step: x_step, - y_step: y_step, - reflect_method: reflect_method - .unwrap_or_else(super::CtPatternXType::default_reflect_method), - relative_to: relative_to - .unwrap_or_else(super::CtPatternXType::default_relative_to), - ctm: ctm, - cell_content: None, - state__: Box::new(CtPatternXTypeDeserializerState::Init__), - }) + *self.state__ = CtPageBlockXTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( - &mut self, helper: &mut DeserializeHelper, - state: CtPatternXTypeDeserializerState, - ) -> Result<(), Error> { - use CtPatternXTypeDeserializerState as S; + state: CtPageBlockXTypeContentDeserializerState, + ) -> Result { + use CtPageBlockXTypeContentDeserializerState as S; match state { - S::CellContent(Some(deserializer)) => { - self.store_cell_content(deserializer.finish(helper)?)? + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::TextObject(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_text_object(&mut values, value)?; + } + Ok(super::CtPageBlockXTypeContent::TextObject( + helper.finish_element("TextObject", values)?, + )) } - _ => (), - } - Ok(()) - } - fn store_cell_content( - &mut self, - value: super::CtPatternCellContentXElementType, - ) -> Result<(), Error> { - if self.cell_content.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"CellContent", - )))?; - } - self.cell_content = Some(value); - Ok(()) - } - fn handle_cell_content<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtPatternCellContentXElementType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtPatternXTypeDeserializerState as S; + S::PathObject(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_path_object(&mut values, value)?; + } + Ok(super::CtPageBlockXTypeContent::PathObject( + helper.finish_element("PathObject", values)?, + )) + } + S::ImageObject(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_image_object(&mut values, value)?; + } + Ok(super::CtPageBlockXTypeContent::ImageObject( + helper.finish_element("ImageObject", values)?, + )) + } + S::CompositeObject(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_composite_object(&mut values, value)?; + } + Ok(super::CtPageBlockXTypeContent::CompositeObject( + helper.finish_element("CompositeObject", values)?, + )) + } + S::PageBlock(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_page_block(&mut values, value)?; + } + Ok(super::CtPageBlockXTypeContent::PageBlock( + helper.finish_element("PageBlock", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_text_object( + values: &mut Option, + value: super::CtPageBlockTextObjectXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"TextObject", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_path_object( + values: &mut Option, + value: super::CtPageBlockPathObjectXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"PathObject", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_image_object( + values: &mut Option, + value: super::CtPageBlockImageObjectXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"ImageObject", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_composite_object( + values: &mut Option, + value: super::CtPageBlockCompositeObjectXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"CompositeObject", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_page_block( + values: &mut Option, + value: super::CtPageBlockPageBlockXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"PageBlock", + )))?; + } + *values = Some(value); + Ok(()) + } + fn handle_text_object<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtPageBlockTextObjectXElementType>, + ) -> Result, Error> { + use CtPageBlockXTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - fallback.get_or_insert(S::CellContent(None)); - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } else { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_text_object(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_cell_content(data)?; - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_text_object(&mut values, data)?; + let data = Self::finish_state(helper, S::TextObject(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::CellContent(Some(deserializer))); - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::TextObject(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - } - impl<'de> Deserializer<'de, super::CtPatternXType> for CtPatternXTypeDeserializer { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPatternXType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, + fn handle_path_object<'de>( + &mut self, helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPatternXType> { - use CtPatternXTypeDeserializerState as S; - let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::CellContent(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_cell_content(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, - allow_any: false, - }); - } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::CellContent(None); - event - } - (S::CellContent(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"CellContent", - true, - )?; - match self.handle_cell_content(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Break(event), false); - } - } - }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtPageBlockPathObjectXElementType>, + ) -> Result, Error> { + use CtPageBlockXTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, event, allow_any, - }) + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_path_object(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_path_object(&mut values, data)?; + let data = Self::finish_state(helper, S::PathObject(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::PathObject(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } } - fn finish( - mut self, + fn handle_image_object<'de>( + &mut self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - CtPatternXTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::CtPatternXType { - width: self.width, - height: self.height, - x_step: self.x_step, - y_step: self.y_step, - reflect_method: self.reflect_method, - relative_to: self.relative_to, - ctm: self.ctm, - cell_content: helper.finish_element("CellContent", self.cell_content)?, - }) - } - } - #[derive(Debug)] - pub struct CtRadialShdXTypeDeserializer { - map_type: super::CtAxialShdMapTypeXType, - map_unit: Option, - eccentricity: f64, - angle: f64, - start_point: String, - start_radius: f64, - end_point: String, - end_radius: f64, - extend: i32, - seqment: Vec, - state__: Box, - } - #[derive(Debug)] - enum CtRadialShdXTypeDeserializerState { - Init__, - Seqment( - Option<::Deserializer>, - ), - Done__, - Unknown__, - } - impl CtRadialShdXTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut map_type: Option = None; - let mut map_unit: Option = None; - let mut eccentricity: Option = None; - let mut angle: Option = None; - let mut start_point: Option = None; - let mut start_radius: Option = None; - let mut end_point: Option = None; - let mut end_radius: Option = None; - let mut extend: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"MapType") - ) { - helper.read_attrib(&mut map_type, b"MapType", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"MapUnit") - ) { - helper.read_attrib(&mut map_unit, b"MapUnit", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Eccentricity") - ) { - helper.read_attrib(&mut eccentricity, b"Eccentricity", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Angle") - ) { - helper.read_attrib(&mut angle, b"Angle", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"StartPoint") - ) { - helper.read_attrib(&mut start_point, b"StartPoint", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"StartRadius") - ) { - helper.read_attrib(&mut start_radius, b"StartRadius", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"EndPoint") - ) { - helper.read_attrib(&mut end_point, b"EndPoint", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"EndRadius") - ) { - helper.read_attrib(&mut end_radius, b"EndRadius", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Extend") - ) { - helper.read_attrib(&mut extend, b"Extend", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtPageBlockImageObjectXElementType>, + ) -> Result, Error> { + use CtPageBlockXTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_image_object(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_image_object(&mut values, data)?; + let data = Self::finish_state(helper, S::ImageObject(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::ImageObject(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } - Ok(Self { - map_type: map_type.unwrap_or_else(super::CtRadialShdXType::default_map_type), - map_unit: map_unit, - eccentricity: eccentricity - .unwrap_or_else(super::CtRadialShdXType::default_eccentricity), - angle: angle.unwrap_or_else(super::CtRadialShdXType::default_angle), - start_point: start_point - .ok_or_else(|| ErrorKind::MissingAttribute("StartPoint".into()))?, - start_radius: start_radius - .unwrap_or_else(super::CtRadialShdXType::default_start_radius), - end_point: end_point - .ok_or_else(|| ErrorKind::MissingAttribute("EndPoint".into()))?, - end_radius: end_radius - .ok_or_else(|| ErrorKind::MissingAttribute("EndRadius".into()))?, - extend: extend.unwrap_or_else(super::CtRadialShdXType::default_extend), - seqment: Vec::new(), - state__: Box::new(CtRadialShdXTypeDeserializerState::Init__), - }) } - fn finish_state( + fn handle_composite_object<'de>( &mut self, helper: &mut DeserializeHelper, - state: CtRadialShdXTypeDeserializerState, - ) -> Result<(), Error> { - use CtRadialShdXTypeDeserializerState as S; - match state { - S::Seqment(Some(deserializer)) => { - self.store_seqment(deserializer.finish(helper)?)? + mut values: Option, + fallback : Option << super :: CtPageBlockCompositeObjectXElementType as WithDeserializer > :: Deserializer >, + output: DeserializerOutput<'de, super::CtPageBlockCompositeObjectXElementType>, + ) -> Result, Error> { + use CtPageBlockXTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_composite_object(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_composite_object(&mut values, data)?; + let data = + Self::finish_state(helper, S::CompositeObject(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::CompositeObject(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } - _ => (), } - Ok(()) - } - fn store_seqment( - &mut self, - value: super::CtAxialShdSegmentXElementType, - ) -> Result<(), Error> { - self.seqment.push(value); - Ok(()) } - fn handle_seqment<'de>( + fn handle_page_block<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtAxialShdSegmentXElementType>, - fallback: &mut Option, + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtPageBlockPageBlockXElementType>, ) -> Result, Error> { - use CtRadialShdXTypeDeserializerState as S; + use CtPageBlockXTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - if self.seqment.len() < 2usize { - fallback.get_or_insert(S::Seqment(None)); - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } else { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_page_block(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_seqment(data)?; - *self.state__ = S::Seqment(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_page_block(&mut values, data)?; + let data = Self::finish_state(helper, S::PageBlock(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Seqment(Some(deserializer))); - *self.state__ = S::Seqment(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::PageBlock(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtRadialShdXType> for CtRadialShdXTypeDeserializer { + impl<'de> Deserializer<'de, super::CtPageBlockXTypeContent> + for CtPageBlockXTypeContentDeserializer + { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtRadialShdXType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtRadialShdXType> { - use CtRadialShdXTypeDeserializerState as S; - let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::Seqment(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_seqment(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + ) -> DeserializerResult<'de, super::CtPageBlockXTypeContent> { + let deserializer = Self { + state__: Box::new(CtPageBlockXTypeContentDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!( + &*x.state__, + CtPageBlockXTypeContentDeserializerState::Init__ + ) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtPageBlockXTypeContent> { + use CtPageBlockXTypeContentDeserializerState as S; + let mut event = event; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::TextObject(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_text_object(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::PathObject(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_path_object(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + (S::ImageObject(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_image_object(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::CompositeObject(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_composite_object(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, } + } + (S::PageBlock(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_page_block(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), allow_any: false, }); } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Seqment(None); - event + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::TextObject(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"TextObject", + true, + )?; + match self.handle_text_object(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } } - (S::Seqment(None), event @ (Event::Start(_) | Event::Empty(_))) => { + ( + S::PathObject(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Seqment", + b"PathObject", true, )?; - match self.handle_seqment(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_path_object(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::ImageObject(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"ImageObject", + true, + )?; + match self.handle_image_object(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::CompositeObject(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"CompositeObject", + true, + )?; + match self.handle_composite_object(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); + ( + S::PageBlock(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"PageBlock", + true, + )?; + match self.handle_page_block(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); } (state, event) => { *self.state__ = state; - break (DeserializerEvent::Break(event), false); + break (DeserializerEvent::Continue(event), false); } } }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + artifact, event, allow_any, }) } fn finish( - mut self, + self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - CtRadialShdXTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::CtRadialShdXType { - map_type: self.map_type, - map_unit: self.map_unit, - eccentricity: self.eccentricity, - angle: self.angle, - start_point: self.start_point, - start_radius: self.start_radius, - end_point: self.end_point, - end_radius: self.end_radius, - extend: self.extend, - seqment: helper.finish_vec(2usize, None, self.seqment)?, - }) + ) -> Result { + Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct CtTextXTypeDeserializer { + pub struct CtPathXTypeDeserializer { boundary: String, name: Option, visible: bool, @@ -29137,26 +28852,32 @@ pub mod page { dash_offset: f64, dash_pattern: Option, alpha: i32, - font: u32, - size: f64, stroke: bool, fill: bool, - h_scale: f64, - read_direction: i32, - char_direction: i32, - weight: super::CtTextWeightXType, - italic: bool, - content: Vec, - state__: Box, + rule: super::CtPathRuleXType, + actions: Option, + clips: Option, + stroke_color: Option, + fill_color: Option, + abbreviated_data: Option, + state__: Box, } #[derive(Debug)] - enum CtTextXTypeDeserializerState { + enum CtPathXTypeDeserializerState { Init__, - Next__, - Content__(::Deserializer), + Actions( + Option<::Deserializer>, + ), + Clips( + Option<::Deserializer>, + ), + StrokeColor(Option<::Deserializer>), + FillColor(Option<::Deserializer>), + AbbreviatedData(Option<::Deserializer>), + Done__, Unknown__, } - impl CtTextXTypeDeserializer { + impl CtPathXTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -29173,15 +28894,9 @@ pub mod page { let mut dash_offset: Option = None; let mut dash_pattern: Option = None; let mut alpha: Option = None; - let mut font: Option = None; - let mut size: Option = None; let mut stroke: Option = None; let mut fill: Option = None; - let mut h_scale: Option = None; - let mut read_direction: Option = None; - let mut char_direction: Option = None; - let mut weight: Option = None; - let mut italic: Option = None; + let mut rule: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( @@ -29246,19 +28961,9 @@ pub mod page { helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Font") + Some(b"Stroke") ) { - helper.read_attrib(&mut font, b"Font", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Size") - ) { - helper.read_attrib(&mut size, b"Size", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Stroke") - ) { - helper.read_attrib(&mut stroke, b"Stroke", &attrib.value)?; + helper.read_attrib(&mut stroke, b"Stroke", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), Some(b"Fill") @@ -29266,165 +28971,2060 @@ pub mod page { helper.read_attrib(&mut fill, b"Fill", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"HScale") - ) { - helper.read_attrib(&mut h_scale, b"HScale", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"ReadDirection") - ) { - helper.read_attrib(&mut read_direction, b"ReadDirection", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"CharDirection") - ) { - helper.read_attrib(&mut char_direction, b"CharDirection", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Weight") - ) { - helper.read_attrib(&mut weight, b"Weight", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Italic") + Some(b"Rule") ) { - helper.read_attrib(&mut italic, b"Italic", &attrib.value)?; + helper.read_attrib(&mut rule, b"Rule", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } - Ok(Self { - boundary: boundary - .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, - name: name, - visible: visible.unwrap_or_else(super::CtTextXType::default_visible), - ctm: ctm, - draw_param: draw_param, - line_width: line_width.unwrap_or_else(super::CtTextXType::default_line_width), - cap: cap.unwrap_or_else(super::CtTextXType::default_cap), - join: join.unwrap_or_else(super::CtTextXType::default_join), - miter_limit: miter_limit - .unwrap_or_else(super::CtTextXType::default_miter_limit), - dash_offset: dash_offset - .unwrap_or_else(super::CtTextXType::default_dash_offset), - dash_pattern: dash_pattern, - alpha: alpha.unwrap_or_else(super::CtTextXType::default_alpha), - font: font.ok_or_else(|| ErrorKind::MissingAttribute("Font".into()))?, - size: size.ok_or_else(|| ErrorKind::MissingAttribute("Size".into()))?, - stroke: stroke.unwrap_or_else(super::CtTextXType::default_stroke), - fill: fill.unwrap_or_else(super::CtTextXType::default_fill), - h_scale: h_scale.unwrap_or_else(super::CtTextXType::default_h_scale), - read_direction: read_direction - .unwrap_or_else(super::CtTextXType::default_read_direction), - char_direction: char_direction - .unwrap_or_else(super::CtTextXType::default_char_direction), - weight: weight.unwrap_or_else(super::CtTextXType::default_weight), - italic: italic.unwrap_or_else(super::CtTextXType::default_italic), - content: Vec::new(), - state__: Box::new(CtTextXTypeDeserializerState::Init__), - }) + Ok(Self { + boundary: boundary + .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, + name: name, + visible: visible.unwrap_or_else(super::CtPathXType::default_visible), + ctm: ctm, + draw_param: draw_param, + line_width: line_width.unwrap_or_else(super::CtPathXType::default_line_width), + cap: cap.unwrap_or_else(super::CtPathXType::default_cap), + join: join.unwrap_or_else(super::CtPathXType::default_join), + miter_limit: miter_limit + .unwrap_or_else(super::CtPathXType::default_miter_limit), + dash_offset: dash_offset + .unwrap_or_else(super::CtPathXType::default_dash_offset), + dash_pattern: dash_pattern, + alpha: alpha.unwrap_or_else(super::CtPathXType::default_alpha), + stroke: stroke.unwrap_or_else(super::CtPathXType::default_stroke), + fill: fill.unwrap_or_else(super::CtPathXType::default_fill), + rule: rule.unwrap_or_else(super::CtPathXType::default_rule), + actions: None, + clips: None, + stroke_color: None, + fill_color: None, + abbreviated_data: None, + state__: Box::new(CtPathXTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: CtPathXTypeDeserializerState, + ) -> Result<(), Error> { + use CtPathXTypeDeserializerState as S; + match state { + S::Actions(Some(deserializer)) => { + self.store_actions(deserializer.finish(helper)?)? + } + S::Clips(Some(deserializer)) => { + self.store_clips(deserializer.finish(helper)?)? + } + S::StrokeColor(Some(deserializer)) => { + self.store_stroke_color(deserializer.finish(helper)?)? + } + S::FillColor(Some(deserializer)) => { + self.store_fill_color(deserializer.finish(helper)?)? + } + S::AbbreviatedData(Some(deserializer)) => { + self.store_abbreviated_data(deserializer.finish(helper)?)? + } + _ => (), + } + Ok(()) + } + fn store_actions( + &mut self, + value: super::CtGraphicUnitActionsXElementType, + ) -> Result<(), Error> { + if self.actions.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Actions", + )))?; + } + self.actions = Some(value); + Ok(()) + } + fn store_clips( + &mut self, + value: super::CtGraphicUnitClipsXElementType, + ) -> Result<(), Error> { + if self.clips.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Clips", + )))?; + } + self.clips = Some(value); + Ok(()) + } + fn store_stroke_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { + if self.stroke_color.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"StrokeColor", + )))?; + } + self.stroke_color = Some(value); + Ok(()) + } + fn store_fill_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { + if self.fill_color.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"FillColor", + )))?; + } + self.fill_color = Some(value); + Ok(()) + } + fn store_abbreviated_data(&mut self, value: String) -> Result<(), Error> { + if self.abbreviated_data.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"AbbreviatedData", + )))?; + } + self.abbreviated_data = Some(value); + Ok(()) + } + fn handle_actions<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtPathXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Clips(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_actions(data)?; + *self.state__ = S::Clips(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Actions(Some(deserializer))); + *self.state__ = S::Clips(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_clips<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtPathXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::StrokeColor(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_clips(data)?; + *self.state__ = S::StrokeColor(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Clips(Some(deserializer))); + *self.state__ = S::StrokeColor(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_stroke_color<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtColorXType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtPathXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::FillColor(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_stroke_color(data)?; + *self.state__ = S::FillColor(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::StrokeColor(Some(deserializer))); + *self.state__ = S::FillColor(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_fill_color<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtColorXType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtPathXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::AbbreviatedData(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_fill_color(data)?; + *self.state__ = S::AbbreviatedData(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::FillColor(Some(deserializer))); + *self.state__ = S::AbbreviatedData(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_abbreviated_data<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, String>, + fallback: &mut Option, + ) -> Result, Error> { + use CtPathXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + fallback.get_or_insert(S::AbbreviatedData(None)); + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } else { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_abbreviated_data(data)?; + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::AbbreviatedData(Some(deserializer))); + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::CtPathXType> for CtPathXTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtPathXType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtPathXType> { + use CtPathXTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Actions(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_actions(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Clips(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_clips(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::StrokeColor(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_stroke_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::FillColor(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_fill_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::AbbreviatedData(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_abbreviated_data(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Actions(None); + event + } + (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Actions", + true, + )?; + match self.handle_actions(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Clips(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Clips", + true, + )?; + match self.handle_clips(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::StrokeColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"StrokeColor", + true, + )?; + match self.handle_stroke_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::FillColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"FillColor", + true, + )?; + match self.handle_fill_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::AbbreviatedData(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"AbbreviatedData", + false, + )?; + match self.handle_abbreviated_data(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace(&mut *self.state__, CtPathXTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::CtPathXType { + boundary: self.boundary, + name: self.name, + visible: self.visible, + ctm: self.ctm, + draw_param: self.draw_param, + line_width: self.line_width, + cap: self.cap, + join: self.join, + miter_limit: self.miter_limit, + dash_offset: self.dash_offset, + dash_pattern: self.dash_pattern, + alpha: self.alpha, + stroke: self.stroke, + fill: self.fill, + rule: self.rule, + actions: self.actions, + clips: self.clips, + stroke_color: self.stroke_color, + fill_color: self.fill_color, + abbreviated_data: helper + .finish_element("AbbreviatedData", self.abbreviated_data)?, + }) + } + } + #[derive(Debug)] + pub struct CtPatternXTypeDeserializer { + width: f64, + height: f64, + x_step: Option, + y_step: Option, + reflect_method: super::CtPatternReflectMethodXType, + relative_to: super::CtPatternRelativeToXType, + ctm: Option, + cell_content: Option, + state__: Box, + } + #[derive(Debug)] + enum CtPatternXTypeDeserializerState { + Init__, + CellContent( + Option<::Deserializer>, + ), + Done__, + Unknown__, + } + impl CtPatternXTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut width: Option = None; + let mut height: Option = None; + let mut x_step: Option = None; + let mut y_step: Option = None; + let mut reflect_method: Option = None; + let mut relative_to: Option = None; + let mut ctm: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Width") + ) { + helper.read_attrib(&mut width, b"Width", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Height") + ) { + helper.read_attrib(&mut height, b"Height", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"XStep") + ) { + helper.read_attrib(&mut x_step, b"XStep", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"YStep") + ) { + helper.read_attrib(&mut y_step, b"YStep", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"ReflectMethod") + ) { + helper.read_attrib(&mut reflect_method, b"ReflectMethod", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"RelativeTo") + ) { + helper.read_attrib(&mut relative_to, b"RelativeTo", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"CTM") + ) { + helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + width: width.ok_or_else(|| ErrorKind::MissingAttribute("Width".into()))?, + height: height.ok_or_else(|| ErrorKind::MissingAttribute("Height".into()))?, + x_step: x_step, + y_step: y_step, + reflect_method: reflect_method + .unwrap_or_else(super::CtPatternXType::default_reflect_method), + relative_to: relative_to + .unwrap_or_else(super::CtPatternXType::default_relative_to), + ctm: ctm, + cell_content: None, + state__: Box::new(CtPatternXTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: CtPatternXTypeDeserializerState, + ) -> Result<(), Error> { + use CtPatternXTypeDeserializerState as S; + match state { + S::CellContent(Some(deserializer)) => { + self.store_cell_content(deserializer.finish(helper)?)? + } + _ => (), + } + Ok(()) + } + fn store_cell_content( + &mut self, + value: super::CtPatternCellContentXElementType, + ) -> Result<(), Error> { + if self.cell_content.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"CellContent", + )))?; + } + self.cell_content = Some(value); + Ok(()) + } + fn handle_cell_content<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtPatternCellContentXElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtPatternXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + fallback.get_or_insert(S::CellContent(None)); + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } else { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_cell_content(data)?; + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::CellContent(Some(deserializer))); + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::CtPatternXType> for CtPatternXTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtPatternXType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtPatternXType> { + use CtPatternXTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::CellContent(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_cell_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::CellContent(None); + event + } + (S::CellContent(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"CellContent", + true, + )?; + match self.handle_cell_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + CtPatternXTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::CtPatternXType { + width: self.width, + height: self.height, + x_step: self.x_step, + y_step: self.y_step, + reflect_method: self.reflect_method, + relative_to: self.relative_to, + ctm: self.ctm, + cell_content: helper.finish_element("CellContent", self.cell_content)?, + }) + } + } + #[derive(Debug)] + pub struct CtRadialShdXTypeDeserializer { + map_type: super::CtAxialShdMapTypeXType, + map_unit: Option, + eccentricity: f64, + angle: f64, + start_point: String, + start_radius: f64, + end_point: String, + end_radius: f64, + extend: i32, + seqment: Vec, + state__: Box, + } + #[derive(Debug)] + enum CtRadialShdXTypeDeserializerState { + Init__, + Seqment( + Option<::Deserializer>, + ), + Done__, + Unknown__, + } + impl CtRadialShdXTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut map_type: Option = None; + let mut map_unit: Option = None; + let mut eccentricity: Option = None; + let mut angle: Option = None; + let mut start_point: Option = None; + let mut start_radius: Option = None; + let mut end_point: Option = None; + let mut end_radius: Option = None; + let mut extend: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"MapType") + ) { + helper.read_attrib(&mut map_type, b"MapType", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"MapUnit") + ) { + helper.read_attrib(&mut map_unit, b"MapUnit", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Eccentricity") + ) { + helper.read_attrib(&mut eccentricity, b"Eccentricity", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Angle") + ) { + helper.read_attrib(&mut angle, b"Angle", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"StartPoint") + ) { + helper.read_attrib(&mut start_point, b"StartPoint", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"StartRadius") + ) { + helper.read_attrib(&mut start_radius, b"StartRadius", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"EndPoint") + ) { + helper.read_attrib(&mut end_point, b"EndPoint", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"EndRadius") + ) { + helper.read_attrib(&mut end_radius, b"EndRadius", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Extend") + ) { + helper.read_attrib(&mut extend, b"Extend", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + map_type: map_type.unwrap_or_else(super::CtRadialShdXType::default_map_type), + map_unit: map_unit, + eccentricity: eccentricity + .unwrap_or_else(super::CtRadialShdXType::default_eccentricity), + angle: angle.unwrap_or_else(super::CtRadialShdXType::default_angle), + start_point: start_point + .ok_or_else(|| ErrorKind::MissingAttribute("StartPoint".into()))?, + start_radius: start_radius + .unwrap_or_else(super::CtRadialShdXType::default_start_radius), + end_point: end_point + .ok_or_else(|| ErrorKind::MissingAttribute("EndPoint".into()))?, + end_radius: end_radius + .ok_or_else(|| ErrorKind::MissingAttribute("EndRadius".into()))?, + extend: extend.unwrap_or_else(super::CtRadialShdXType::default_extend), + seqment: Vec::new(), + state__: Box::new(CtRadialShdXTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: CtRadialShdXTypeDeserializerState, + ) -> Result<(), Error> { + use CtRadialShdXTypeDeserializerState as S; + match state { + S::Seqment(Some(deserializer)) => { + self.store_seqment(deserializer.finish(helper)?)? + } + _ => (), + } + Ok(()) + } + fn store_seqment( + &mut self, + value: super::CtAxialShdSegmentXElementType, + ) -> Result<(), Error> { + self.seqment.push(value); + Ok(()) + } + fn handle_seqment<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtAxialShdSegmentXElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtRadialShdXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + if self.seqment.len() < 2usize { + fallback.get_or_insert(S::Seqment(None)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } else { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_seqment(data)?; + *self.state__ = S::Seqment(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Seqment(Some(deserializer))); + *self.state__ = S::Seqment(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::CtRadialShdXType> for CtRadialShdXTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtRadialShdXType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtRadialShdXType> { + use CtRadialShdXTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Seqment(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_seqment(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Seqment(None); + event + } + (S::Seqment(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Seqment", + true, + )?; + match self.handle_seqment(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + CtRadialShdXTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::CtRadialShdXType { + map_type: self.map_type, + map_unit: self.map_unit, + eccentricity: self.eccentricity, + angle: self.angle, + start_point: self.start_point, + start_radius: self.start_radius, + end_point: self.end_point, + end_radius: self.end_radius, + extend: self.extend, + seqment: helper.finish_vec(2usize, None, self.seqment)?, + }) + } + } + #[derive(Debug)] + pub struct CtTextXTypeDeserializer { + boundary: String, + name: Option, + visible: bool, + ctm: Option, + draw_param: Option, + line_width: f64, + cap: super::CtGraphicUnitCapXType, + join: super::CtGraphicUnitJoinXType, + miter_limit: f64, + dash_offset: f64, + dash_pattern: Option, + alpha: i32, + font: u32, + size: f64, + stroke: bool, + fill: bool, + h_scale: f64, + read_direction: i32, + char_direction: i32, + weight: super::CtTextWeightXType, + italic: bool, + content: Vec, + state__: Box, + } + #[derive(Debug)] + enum CtTextXTypeDeserializerState { + Init__, + Next__, + Content__(::Deserializer), + Unknown__, + } + impl CtTextXTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut boundary: Option = None; + let mut name: Option = None; + let mut visible: Option = None; + let mut ctm: Option = None; + let mut draw_param: Option = None; + let mut line_width: Option = None; + let mut cap: Option = None; + let mut join: Option = None; + let mut miter_limit: Option = None; + let mut dash_offset: Option = None; + let mut dash_pattern: Option = None; + let mut alpha: Option = None; + let mut font: Option = None; + let mut size: Option = None; + let mut stroke: Option = None; + let mut fill: Option = None; + let mut h_scale: Option = None; + let mut read_direction: Option = None; + let mut char_direction: Option = None; + let mut weight: Option = None; + let mut italic: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Boundary") + ) { + helper.read_attrib(&mut boundary, b"Boundary", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Name") + ) { + helper.read_attrib(&mut name, b"Name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Visible") + ) { + helper.read_attrib(&mut visible, b"Visible", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"CTM") + ) { + helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DrawParam") + ) { + helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"LineWidth") + ) { + helper.read_attrib(&mut line_width, b"LineWidth", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Cap") + ) { + helper.read_attrib(&mut cap, b"Cap", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Join") + ) { + helper.read_attrib(&mut join, b"Join", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"MiterLimit") + ) { + helper.read_attrib(&mut miter_limit, b"MiterLimit", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DashOffset") + ) { + helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DashPattern") + ) { + helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Alpha") + ) { + helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Font") + ) { + helper.read_attrib(&mut font, b"Font", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Size") + ) { + helper.read_attrib(&mut size, b"Size", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Stroke") + ) { + helper.read_attrib(&mut stroke, b"Stroke", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Fill") + ) { + helper.read_attrib(&mut fill, b"Fill", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"HScale") + ) { + helper.read_attrib(&mut h_scale, b"HScale", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"ReadDirection") + ) { + helper.read_attrib(&mut read_direction, b"ReadDirection", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"CharDirection") + ) { + helper.read_attrib(&mut char_direction, b"CharDirection", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Weight") + ) { + helper.read_attrib(&mut weight, b"Weight", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Italic") + ) { + helper.read_attrib(&mut italic, b"Italic", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + boundary: boundary + .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, + name: name, + visible: visible.unwrap_or_else(super::CtTextXType::default_visible), + ctm: ctm, + draw_param: draw_param, + line_width: line_width.unwrap_or_else(super::CtTextXType::default_line_width), + cap: cap.unwrap_or_else(super::CtTextXType::default_cap), + join: join.unwrap_or_else(super::CtTextXType::default_join), + miter_limit: miter_limit + .unwrap_or_else(super::CtTextXType::default_miter_limit), + dash_offset: dash_offset + .unwrap_or_else(super::CtTextXType::default_dash_offset), + dash_pattern: dash_pattern, + alpha: alpha.unwrap_or_else(super::CtTextXType::default_alpha), + font: font.ok_or_else(|| ErrorKind::MissingAttribute("Font".into()))?, + size: size.ok_or_else(|| ErrorKind::MissingAttribute("Size".into()))?, + stroke: stroke.unwrap_or_else(super::CtTextXType::default_stroke), + fill: fill.unwrap_or_else(super::CtTextXType::default_fill), + h_scale: h_scale.unwrap_or_else(super::CtTextXType::default_h_scale), + read_direction: read_direction + .unwrap_or_else(super::CtTextXType::default_read_direction), + char_direction: char_direction + .unwrap_or_else(super::CtTextXType::default_char_direction), + weight: weight.unwrap_or_else(super::CtTextXType::default_weight), + italic: italic.unwrap_or_else(super::CtTextXType::default_italic), + content: Vec::new(), + state__: Box::new(CtTextXTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: CtTextXTypeDeserializerState, + ) -> Result<(), Error> { + if let CtTextXTypeDeserializerState::Content__(deserializer) = state { + self.store_content(deserializer.finish(helper)?)?; + } + Ok(()) + } + fn store_content(&mut self, value: super::CtTextXTypeContent) -> Result<(), Error> { + self.content.push(value); + Ok(()) + } + fn handle_content<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtTextXTypeContent>, + fallback: &mut Option, + ) -> Result, Error> { + use CtTextXTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = fallback.take().unwrap_or(S::Next__); + return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_content(data)?; + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *fallback = Some(S::Content__(deserializer)); + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::CtTextXType> for CtTextXTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtTextXType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtTextXType> { + use CtTextXTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Content__(deserializer), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (_, Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (state @ (S::Init__ | S::Next__), event) => { + fallback.get_or_insert(state); + let output = ::init( + helper, event, + )?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + let artifact = DeserializerArtifact::Deserializer(self); + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace(&mut *self.state__, CtTextXTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::CtTextXType { + boundary: self.boundary, + name: self.name, + visible: self.visible, + ctm: self.ctm, + draw_param: self.draw_param, + line_width: self.line_width, + cap: self.cap, + join: self.join, + miter_limit: self.miter_limit, + dash_offset: self.dash_offset, + dash_pattern: self.dash_pattern, + alpha: self.alpha, + font: self.font, + size: self.size, + stroke: self.stroke, + fill: self.fill, + h_scale: self.h_scale, + read_direction: self.read_direction, + char_direction: self.char_direction, + weight: self.weight, + italic: self.italic, + content: helper.finish_vec(1usize, None, self.content)?, + }) + } + } + #[derive(Debug)] + pub struct CtTextXTypeContentDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum CtTextXTypeContentDeserializerState { + Init__, + Actions( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Clips( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + FillColor( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + StrokeColor( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + CgTransform( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + TextCode( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::CtTextXTypeContent), + Unknown__, + } + impl CtTextXTypeContentDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"Actions") + ) { + let output = + ::init( + helper, event, + )?; + return self.handle_actions(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"Clips") + ) { + let output = + ::init( + helper, event, + )?; + return self.handle_clips(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"FillColor") + ) { + let output = + ::init(helper, event)?; + return self.handle_fill_color(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"StrokeColor") + ) { + let output = + ::init(helper, event)?; + return self.handle_stroke_color(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"CGTransform") + ) { + let output = + ::init(helper, event)?; + return self.handle_cg_transform(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"TextCode") + ) { + let output = ::init( + helper, event, + )?; + return self.handle_text_code(helper, Default::default(), None, output); + } + } + *self.state__ = CtTextXTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: CtTextXTypeContentDeserializerState, + ) -> Result { + use CtTextXTypeContentDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Actions(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_actions(&mut values, value)?; + } + Ok(super::CtTextXTypeContent::Actions( + helper.finish_element("Actions", values)?, + )) + } + S::Clips(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_clips(&mut values, value)?; + } + Ok(super::CtTextXTypeContent::Clips( + helper.finish_element("Clips", values)?, + )) + } + S::FillColor(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_fill_color(&mut values, value)?; + } + Ok(super::CtTextXTypeContent::FillColor( + helper.finish_element("FillColor", values)?, + )) + } + S::StrokeColor(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_stroke_color(&mut values, value)?; + } + Ok(super::CtTextXTypeContent::StrokeColor( + helper.finish_element("StrokeColor", values)?, + )) + } + S::CgTransform(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_cg_transform(&mut values, value)?; + } + Ok(super::CtTextXTypeContent::CgTransform( + helper.finish_element("CGTransform", values)?, + )) + } + S::TextCode(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_text_code(&mut values, value)?; + } + Ok(super::CtTextXTypeContent::TextCode( + helper.finish_element("TextCode", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_actions( + values: &mut Option, + value: super::CtGraphicUnitActionsXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Actions", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_clips( + values: &mut Option, + value: super::CtGraphicUnitClipsXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Clips", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_fill_color( + values: &mut Option, + value: super::CtColorXType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"FillColor", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_stroke_color( + values: &mut Option, + value: super::CtColorXType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"StrokeColor", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_cg_transform( + values: &mut Option, + value: super::CtCgTransformXType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"CGTransform", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_text_code( + values: &mut Option, + value: super::CtTextTextCodeXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"TextCode", + )))?; + } + *values = Some(value); + Ok(()) + } + fn handle_actions<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, + ) -> Result, Error> { + use CtTextXTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_actions(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_actions(&mut values, data)?; + let data = Self::finish_state(helper, S::Actions(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Actions(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } } - fn finish_state( + fn handle_clips<'de>( &mut self, helper: &mut DeserializeHelper, - state: CtTextXTypeDeserializerState, - ) -> Result<(), Error> { - if let CtTextXTypeDeserializerState::Content__(deserializer) = state { - self.store_content(deserializer.finish(helper)?)?; + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, + ) -> Result, Error> { + use CtTextXTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_clips(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_clips(&mut values, data)?; + let data = Self::finish_state(helper, S::Clips(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Clips(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } } - Ok(()) } - fn store_content(&mut self, value: super::CtTextXTypeContent) -> Result<(), Error> { - self.content.push(value); - Ok(()) + fn handle_fill_color<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CtColorXType>, + ) -> Result, Error> { + use CtTextXTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_fill_color(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_fill_color(&mut values, data)?; + let data = Self::finish_state(helper, S::FillColor(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::FillColor(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } } - fn handle_content<'de>( + fn handle_stroke_color<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtTextXTypeContent>, - fallback: &mut Option, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CtColorXType>, ) -> Result, Error> { - use CtTextXTypeDeserializerState as S; + use CtTextXTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = fallback.take().unwrap_or(S::Next__); - return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_stroke_color(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_content(data)?; - *self.state__ = S::Next__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_stroke_color(&mut values, data)?; + let data = Self::finish_state(helper, S::StrokeColor(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *fallback = Some(S::Content__(deserializer)); - *self.state__ = S::Next__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::StrokeColor(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_cg_transform<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CtCgTransformXType>, + ) -> Result, Error> { + use CtTextXTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_cg_transform(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_cg_transform(&mut values, data)?; + let data = Self::finish_state(helper, S::CgTransform(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::CgTransform(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_text_code<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtTextTextCodeXElementType>, + ) -> Result, Error> { + use CtTextXTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_text_code(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_text_code(&mut values, data)?; + let data = Self::finish_state(helper, S::TextCode(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::TextCode(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtTextXType> for CtTextXTypeDeserializer { + impl<'de> Deserializer<'de, super::CtTextXTypeContent> for CtTextXTypeContentDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtTextXType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + ) -> DeserializerResult<'de, super::CtTextXTypeContent> { + let deserializer = Self { + state__: Box::new(CtTextXTypeContentDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, CtTextXTypeContentDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtTextXType> { - use CtTextXTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtTextXTypeContent> { + use CtTextXTypeContentDeserializerState as S; let mut event = event; - let mut fallback = None; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Content__(deserializer), event) => { + (S::Actions(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_actions(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Clips(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_content(helper, output, &mut fallback)? { + match self.handle_clips(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (_, Event::End(_)) => { + (S::FillColor(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_fill_color(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::StrokeColor(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_stroke_color(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::CgTransform(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_cg_transform(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::TextCode(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_text_code(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), allow_any: false, }); } - (state @ (S::Init__ | S::Next__), event) => { - fallback.get_or_insert(state); - let output = ::init( - helper, event, + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Actions(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Actions", + true, )?; - match self.handle_content(helper, output, &mut fallback)? { + match self.handle_actions(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Clips(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Clips", + true, + )?; + match self.handle_clips(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::FillColor(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"FillColor", + true, + )?; + match self.handle_fill_color(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::StrokeColor(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"StrokeColor", + true, + )?; + match self.handle_stroke_color(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::CgTransform(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"CGTransform", + false, + )?; + match self.handle_cg_transform(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::TextCode(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"TextCode", + false, + )?; + match self.handle_text_code(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } } }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } - let artifact = DeserializerArtifact::Deserializer(self); + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; Ok(DeserializerOutput { artifact, event, @@ -29432,879 +31032,784 @@ pub mod page { }) } fn finish( - mut self, + self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace(&mut *self.state__, CtTextXTypeDeserializerState::Unknown__); - self.finish_state(helper, state)?; - Ok(super::CtTextXType { - boundary: self.boundary, - name: self.name, - visible: self.visible, - ctm: self.ctm, - draw_param: self.draw_param, - line_width: self.line_width, - cap: self.cap, - join: self.join, - miter_limit: self.miter_limit, - dash_offset: self.dash_offset, - dash_pattern: self.dash_pattern, - alpha: self.alpha, - font: self.font, - size: self.size, - stroke: self.stroke, - fill: self.fill, - h_scale: self.h_scale, - read_direction: self.read_direction, - char_direction: self.char_direction, - weight: self.weight, - italic: self.italic, - content: helper.finish_vec(1usize, None, self.content)?, - }) + ) -> Result { + Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct CtTextXTypeContentDeserializer { - state__: Box, + pub struct PageXElementTypeDeserializer { + template: Vec, + page_res: Vec, + area: Option, + content: Option, + actions: Option, + state__: Box, } #[derive(Debug)] - pub enum CtTextXTypeContentDeserializerState { + enum PageXElementTypeDeserializerState { Init__, + Template(Option<::Deserializer>), + PageRes(Option<::Deserializer>), + Area( + Option< + ::Deserializer, + >, + ), + Content(Option<::Deserializer>), Actions( - Option, Option<::Deserializer>, - Option<::Deserializer>, - ), - Clips( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - FillColor( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - StrokeColor( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - CgTransform( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - TextCode( - Option, - Option<::Deserializer>, - Option<::Deserializer>, ), - Done__(super::CtTextXTypeContent), + Done__, Unknown__, } - impl CtTextXTypeContentDeserializer { - fn find_suitable<'de>( - &mut self, + impl PageXElementTypeDeserializer { + fn from_bytes_start( helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> Result, Error> { - if let Event::Start(x) | Event::Empty(x) = &event { - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"Actions") - ) { - let output = - ::init( - helper, event, - )?; - return self.handle_actions(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"Clips") - ) { - let output = - ::init( - helper, event, - )?; - return self.handle_clips(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"FillColor") - ) { - let output = - ::init(helper, event)?; - return self.handle_fill_color(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"StrokeColor") - ) { - let output = - ::init(helper, event)?; - return self.handle_stroke_color(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"CGTransform") - ) { - let output = - ::init(helper, event)?; - return self.handle_cg_transform(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"TextCode") - ) { - let output = ::init( - helper, event, - )?; - return self.handle_text_code(helper, Default::default(), None, output); - } + bytes_start: &BytesStart<'_>, + ) -> Result { + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + helper.raise_unexpected_attrib_checked(&attrib)?; } - *self.state__ = CtTextXTypeContentDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent(event, false)) + Ok(Self { + template: Vec::new(), + page_res: Vec::new(), + area: None, + content: None, + actions: None, + state__: Box::new(PageXElementTypeDeserializerState::Init__), + }) } fn finish_state( + &mut self, helper: &mut DeserializeHelper, - state: CtTextXTypeContentDeserializerState, - ) -> Result { - use CtTextXTypeContentDeserializerState as S; + state: PageXElementTypeDeserializerState, + ) -> Result<(), Error> { + use PageXElementTypeDeserializerState as S; match state { - S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Actions(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_actions(&mut values, value)?; - } - Ok(super::CtTextXTypeContent::Actions( - helper.finish_element("Actions", values)?, - )) - } - S::Clips(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_clips(&mut values, value)?; - } - Ok(super::CtTextXTypeContent::Clips( - helper.finish_element("Clips", values)?, - )) - } - S::FillColor(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_fill_color(&mut values, value)?; - } - Ok(super::CtTextXTypeContent::FillColor( - helper.finish_element("FillColor", values)?, - )) + S::Template(Some(deserializer)) => { + self.store_template(deserializer.finish(helper)?)? } - S::StrokeColor(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_stroke_color(&mut values, value)?; - } - Ok(super::CtTextXTypeContent::StrokeColor( - helper.finish_element("StrokeColor", values)?, - )) + S::PageRes(Some(deserializer)) => { + self.store_page_res(deserializer.finish(helper)?)? } - S::CgTransform(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_cg_transform(&mut values, value)?; - } - Ok(super::CtTextXTypeContent::CgTransform( - helper.finish_element("CGTransform", values)?, - )) + S::Area(Some(deserializer)) => self.store_area(deserializer.finish(helper)?)?, + S::Content(Some(deserializer)) => { + self.store_content(deserializer.finish(helper)?)? } - S::TextCode(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_text_code(&mut values, value)?; - } - Ok(super::CtTextXTypeContent::TextCode( - helper.finish_element("TextCode", values)?, - )) + S::Actions(Some(deserializer)) => { + self.store_actions(deserializer.finish(helper)?)? } - S::Done__(data) => Ok(data), - _ => unreachable!(), - } - } - fn store_actions( - values: &mut Option, - value: super::CtGraphicUnitActionsXElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Actions", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_clips( - values: &mut Option, - value: super::CtGraphicUnitClipsXElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Clips", - )))?; + _ => (), } - *values = Some(value); Ok(()) } - fn store_fill_color( - values: &mut Option, - value: super::CtColorXType, + fn store_template( + &mut self, + value: super::PageTemplateXElementType, ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"FillColor", - )))?; - } - *values = Some(value); + self.template.push(value); Ok(()) } - fn store_stroke_color( - values: &mut Option, - value: super::CtColorXType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"StrokeColor", - )))?; - } - *values = Some(value); + fn store_page_res(&mut self, value: String) -> Result<(), Error> { + self.page_res.push(value); Ok(()) } - fn store_cg_transform( - values: &mut Option, - value: super::CtCgTransformXType, + fn store_area( + &mut self, + value: super::super::definition::CtPageAreaXType, ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"CGTransform", - )))?; + if self.area.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"Area")))?; } - *values = Some(value); + self.area = Some(value); Ok(()) } - fn store_text_code( - values: &mut Option, - value: super::CtTextTextCodeXElementType, + fn store_content( + &mut self, + value: super::PageContentXElementType, ) -> Result<(), Error> { - if values.is_some() { + if self.content.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"TextCode", + b"Content", )))?; } - *values = Some(value); - Ok(()) - } - fn handle_actions<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option< - ::Deserializer, - >, - output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, - ) -> Result, Error> { - use CtTextXTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_actions(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_actions(&mut values, data)?; - let data = Self::finish_state(helper, S::Actions(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Actions(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } + self.content = Some(value); + Ok(()) } - fn handle_clips<'de>( + fn store_actions( + &mut self, + value: super::CtGraphicUnitActionsXElementType, + ) -> Result<(), Error> { + if self.actions.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Actions", + )))?; + } + self.actions = Some(value); + Ok(()) + } + fn handle_template<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option< - ::Deserializer, - >, - output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, + output: DeserializerOutput<'de, super::PageTemplateXElementType>, + fallback: &mut Option, ) -> Result, Error> { - use CtTextXTypeContentDeserializerState as S; + use PageXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + *self.state__ = S::PageRes(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_clips(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_clips(&mut values, data)?; - let data = Self::finish_state(helper, S::Clips(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_template(data)?; + *self.state__ = S::Template(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Clips(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + fallback.get_or_insert(S::Template(Some(deserializer))); + *self.state__ = S::Template(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } - fn handle_fill_color<'de>( + fn handle_page_res<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::CtColorXType>, + output: DeserializerOutput<'de, String>, + fallback: &mut Option, ) -> Result, Error> { - use CtTextXTypeContentDeserializerState as S; + use PageXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + *self.state__ = S::Area(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_fill_color(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_fill_color(&mut values, data)?; - let data = Self::finish_state(helper, S::FillColor(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_page_res(data)?; + *self.state__ = S::PageRes(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::FillColor(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + fallback.get_or_insert(S::PageRes(Some(deserializer))); + *self.state__ = S::PageRes(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } - fn handle_stroke_color<'de>( + fn handle_area<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::CtColorXType>, + output: DeserializerOutput<'de, super::super::definition::CtPageAreaXType>, + fallback: &mut Option, ) -> Result, Error> { - use CtTextXTypeContentDeserializerState as S; + use PageXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + *self.state__ = S::Content(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_stroke_color(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_stroke_color(&mut values, data)?; - let data = Self::finish_state(helper, S::StrokeColor(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_area(data)?; + *self.state__ = S::Content(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::StrokeColor(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + fallback.get_or_insert(S::Area(Some(deserializer))); + *self.state__ = S::Content(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } - fn handle_cg_transform<'de>( + fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::CtCgTransformXType>, + output: DeserializerOutput<'de, super::PageContentXElementType>, + fallback: &mut Option, ) -> Result, Error> { - use CtTextXTypeContentDeserializerState as S; + use PageXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + *self.state__ = S::Actions(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_cg_transform(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_cg_transform(&mut values, data)?; - let data = Self::finish_state(helper, S::CgTransform(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_content(data)?; + *self.state__ = S::Actions(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::CgTransform(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + fallback.get_or_insert(S::Content(Some(deserializer))); + *self.state__ = S::Actions(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } - fn handle_text_code<'de>( + fn handle_actions<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option< - ::Deserializer, - >, - output: DeserializerOutput<'de, super::CtTextTextCodeXElementType>, + output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, + fallback: &mut Option, ) -> Result, Error> { - use CtTextXTypeContentDeserializerState as S; + use PageXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_text_code(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_text_code(&mut values, data)?; - let data = Self::finish_state(helper, S::TextCode(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_actions(data)?; + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::TextCode(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + fallback.get_or_insert(S::Actions(Some(deserializer))); + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtTextXTypeContent> for CtTextXTypeContentDeserializer { + impl<'de> Deserializer<'de, super::PageXElementType> for PageXElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtTextXTypeContent> { - let deserializer = Self { - state__: Box::new(CtTextXTypeContentDeserializerState::Init__), - }; - let mut output = deserializer.next(helper, event)?; - output.artifact = match output.artifact { - DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, CtTextXTypeContentDeserializerState::Init__) => - { - DeserializerArtifact::None - } - artifact => artifact, - }; - Ok(output) + ) -> DeserializerResult<'de, super::PageXElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtTextXTypeContent> { - use CtTextXTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::PageXElementType> { + use PageXElementTypeDeserializerState as S; let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Actions(values, fallback, Some(deserializer)), event) => { + (S::Template(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_actions(helper, values, fallback, output)? { + match self.handle_template(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Clips(values, fallback, Some(deserializer)), event) => { + (S::PageRes(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_clips(helper, values, fallback, output)? { + match self.handle_page_res(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (S::FillColor(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_fill_color(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + (S::Area(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_area(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Content(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Actions(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_actions(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Template(None); + event + } + (S::Template(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Template", + false, + )?; + match self.handle_template(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::StrokeColor(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_stroke_color(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (S::CgTransform(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_cg_transform(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + (S::PageRes(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"PageRes", + false, + )?; + match self.handle_page_res(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::TextCode(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_text_code(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (state, event @ Event::End(_)) => { - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(Self::finish_state( - helper, state, - )?), - event: DeserializerEvent::Continue(event), - allow_any: false, - }); - } - (S::Init__, event) => match self.find_suitable(helper, event)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - }, - ( - S::Actions(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { + (S::Area(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Actions", - true, + b"Area", + false, )?; - match self.handle_actions(helper, values, fallback, output)? { + match self.handle_area(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - ( - S::Clips(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { + (S::Content(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Clips", + b"Content", true, )?; - match self.handle_clips(helper, values, fallback, output)? { + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - ( - S::FillColor(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { + (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"FillColor", + b"Actions", true, )?; - match self.handle_fill_color(helper, values, fallback, output)? { + match self.handle_actions(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::StrokeColor(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"StrokeColor", - true, - )?; - match self.handle_stroke_color(helper, values, fallback, output)? { + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + PageXElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::PageXElementType { + template: self.template, + page_res: self.page_res, + area: self.area, + content: self.content, + actions: self.actions, + }) + } + } + #[derive(Debug)] + pub struct CtAxialShdSegmentXElementTypeDeserializer { + position: Option, + color: Option, + state__: Box, + } + #[derive(Debug)] + enum CtAxialShdSegmentXElementTypeDeserializerState { + Init__, + Color(Option<::Deserializer>), + Done__, + Unknown__, + } + impl CtAxialShdSegmentXElementTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut position: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Position") + ) { + helper.read_attrib(&mut position, b"Position", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + position: position, + color: None, + state__: Box::new(CtAxialShdSegmentXElementTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: CtAxialShdSegmentXElementTypeDeserializerState, + ) -> Result<(), Error> { + use CtAxialShdSegmentXElementTypeDeserializerState as S; + match state { + S::Color(Some(deserializer)) => { + self.store_color(deserializer.finish(helper)?)? + } + _ => (), + } + Ok(()) + } + fn store_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { + if self.color.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Color", + )))?; + } + self.color = Some(value); + Ok(()) + } + fn handle_color<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtColorXType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtAxialShdSegmentXElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + fallback.get_or_insert(S::Color(None)); + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } else { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_color(data)?; + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Color(Some(deserializer))); + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::CtAxialShdSegmentXElementType> + for CtAxialShdSegmentXElementTypeDeserializer + { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtAxialShdSegmentXElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtAxialShdSegmentXElementType> { + use CtAxialShdSegmentXElementTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Color(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - ( - S::CgTransform(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"CGTransform", - false, - )?; - match self.handle_cg_transform(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); } - ( - S::TextCode(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Color(None); + event + } + (S::Color(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"TextCode", - false, + b"Color", + true, )?; - match self.handle_text_code(helper, values, fallback, output)? { + match self.handle_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (state @ S::Done__(_), event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); } (state, event) => { *self.state__ = state; - break (DeserializerEvent::Continue(event), false); + break (DeserializerEvent::Break(event), false); } } }; - let artifact = if matches!(&*self.state__, S::Done__(_)) { - DeserializerArtifact::Data(self.finish(helper)?) - } else { - DeserializerArtifact::Deserializer(self) - }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } Ok(DeserializerOutput { - artifact, + artifact: DeserializerArtifact::Deserializer(self), event, allow_any, }) } fn finish( - self, + mut self, helper: &mut DeserializeHelper, - ) -> Result { - Self::finish_state(helper, *self.state__) + ) -> Result { + let state = replace( + &mut *self.state__, + CtAxialShdSegmentXElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::CtAxialShdSegmentXElementType { + position: self.position, + color: Box::new(helper.finish_element("Color", self.color)?), + }) } } #[derive(Debug)] - pub struct PageXElementTypeDeserializer { - template: Vec, - page_res: Vec, - area: Option, - content: Option, - actions: Option, - state__: Box, + pub struct CtClipAreaXElementTypeDeserializer { + draw_param: Option, + ctm: Option, + content: Option, + state__: Box, } #[derive(Debug)] - enum PageXElementTypeDeserializerState { + enum CtClipAreaXElementTypeDeserializerState { Init__, - Template(Option<::Deserializer>), - PageRes(Option<::Deserializer>), - Area( - Option< - ::Deserializer, - >, - ), - Content(Option<::Deserializer>), - Actions( - Option<::Deserializer>, - ), - Done__, + Next__, + Content__(::Deserializer), Unknown__, } - impl PageXElementTypeDeserializer { + impl CtClipAreaXElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { + let mut draw_param: Option = None; + let mut ctm: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; - helper.raise_unexpected_attrib_checked(&attrib)?; + if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DrawParam") + ) { + helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"CTM") + ) { + helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } } Ok(Self { - template: Vec::new(), - page_res: Vec::new(), - area: None, + draw_param: draw_param, + ctm: ctm, content: None, - actions: None, - state__: Box::new(PageXElementTypeDeserializerState::Init__), + state__: Box::new(CtClipAreaXElementTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: PageXElementTypeDeserializerState, - ) -> Result<(), Error> { - use PageXElementTypeDeserializerState as S; - match state { - S::Template(Some(deserializer)) => { - self.store_template(deserializer.finish(helper)?)? - } - S::PageRes(Some(deserializer)) => { - self.store_page_res(deserializer.finish(helper)?)? - } - S::Area(Some(deserializer)) => self.store_area(deserializer.finish(helper)?)?, - S::Content(Some(deserializer)) => { - self.store_content(deserializer.finish(helper)?)? - } - S::Actions(Some(deserializer)) => { - self.store_actions(deserializer.finish(helper)?)? - } - _ => (), - } - Ok(()) - } - fn store_template( - &mut self, - value: super::PageTemplateXElementType, - ) -> Result<(), Error> { - self.template.push(value); - Ok(()) - } - fn store_page_res(&mut self, value: String) -> Result<(), Error> { - self.page_res.push(value); - Ok(()) - } - fn store_area( - &mut self, - value: super::super::definition::CtPageAreaXType, - ) -> Result<(), Error> { - if self.area.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"Area")))?; - } - self.area = Some(value); - Ok(()) - } - fn store_content( - &mut self, - value: super::PageContentXElementType, - ) -> Result<(), Error> { - if self.content.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Content", - )))?; - } - self.content = Some(value); - Ok(()) - } - fn store_actions( - &mut self, - value: super::CtGraphicUnitActionsXElementType, - ) -> Result<(), Error> { - if self.actions.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Actions", - )))?; - } - self.actions = Some(value); - Ok(()) - } - fn handle_template<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::PageTemplateXElementType>, - fallback: &mut Option, - ) -> Result, Error> { - use PageXElementTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::PageRes(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_template(data)?; - *self.state__ = S::Template(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Template(Some(deserializer))); - *self.state__ = S::Template(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } + state: CtClipAreaXElementTypeDeserializerState, + ) -> Result<(), Error> { + if let CtClipAreaXElementTypeDeserializerState::Content__(deserializer) = state { + self.store_content(deserializer.finish(helper)?)?; } + Ok(()) } - fn handle_page_res<'de>( + fn store_content( + &mut self, + value: super::CtClipAreaXElementTypeContent, + ) -> Result<(), Error> { + if self.content.is_some() { + Err(ErrorKind::DuplicateContent)?; + } + self.content = Some(value); + Ok(()) + } + fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, String>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::CtClipAreaXElementTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use PageXElementTypeDeserializerState as S; + use CtClipAreaXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Area(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + *self.state__ = fallback.take().unwrap_or(S::Next__); + return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); } if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; @@ -30312,188 +31817,505 @@ pub mod page { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_page_res(data)?; - *self.state__ = S::PageRes(None); + self.store_content(data)?; + *self.state__ = S::Next__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::PageRes(Some(deserializer))); - *self.state__ = S::PageRes(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::Content__(deserializer); + Ok(ElementHandlerOutput::from_event_end(event, allow_any)) } } } - fn handle_area<'de>( - &mut self, + } + impl<'de> Deserializer<'de, super::CtClipAreaXElementType> for CtClipAreaXElementTypeDeserializer { + fn init( helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::super::definition::CtPageAreaXType>, - fallback: &mut Option, - ) -> Result, Error> { - use PageXElementTypeDeserializerState as S; - let DeserializerOutput { + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtClipAreaXElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtClipAreaXElementType> { + use CtClipAreaXElementTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Content__(deserializer), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (_, Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (state @ (S::Init__ | S::Next__), event) => { + fallback.get_or_insert(state); + let output = + ::init( + helper, event, + )?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + let artifact = DeserializerArtifact::Deserializer(self); + Ok(DeserializerOutput { artifact, event, allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::Content(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + CtClipAreaXElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::CtClipAreaXElementType { + draw_param: self.draw_param, + ctm: self.ctm, + content: helper.finish_content(self.content)?, + }) + } + } + #[derive(Debug)] + pub struct CtClipAreaXElementTypeContentDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum CtClipAreaXElementTypeContentDeserializerState { + Init__, + Path( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Text( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::CtClipAreaXElementTypeContent), + Unknown__, + } + impl CtClipAreaXElementTypeContentDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"Path") + ) { + let output = ::init(helper, event)?; + return self.handle_path(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"Text") + ) { + let output = ::init(helper, event)?; + return self.handle_text(helper, Default::default(), None, output); + } } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_area(data)?; - *self.state__ = S::Content(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = CtClipAreaXElementTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: CtClipAreaXElementTypeContentDeserializerState, + ) -> Result { + use CtClipAreaXElementTypeContentDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Path(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_path(&mut values, value)?; + } + Ok(super::CtClipAreaXElementTypeContent::Path( + helper.finish_element("Path", values)?, + )) } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Area(Some(deserializer))); - *self.state__ = S::Content(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + S::Text(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_text(&mut values, value)?; + } + Ok(super::CtClipAreaXElementTypeContent::Text( + helper.finish_element("Text", values)?, + )) } + S::Done__(data) => Ok(data), + _ => unreachable!(), } } - fn handle_content<'de>( + fn store_path( + values: &mut Option, + value: super::CtPathXType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"Path")))?; + } + *values = Some(value); + Ok(()) + } + fn store_text( + values: &mut Option, + value: super::CtTextXType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"Text")))?; + } + *values = Some(value); + Ok(()) + } + fn handle_path<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::PageContentXElementType>, - fallback: &mut Option, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CtPathXType>, ) -> Result, Error> { - use PageXElementTypeDeserializerState as S; + use CtClipAreaXElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Actions(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_path(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_content(data)?; - *self.state__ = S::Actions(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_path(&mut values, data)?; + let data = Self::finish_state(helper, S::Path(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Content(Some(deserializer))); - *self.state__ = S::Actions(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::Path(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_actions<'de>( + fn handle_text<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, - fallback: &mut Option, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CtTextXType>, ) -> Result, Error> { - use PageXElementTypeDeserializerState as S; + use CtClipAreaXElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_text(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_actions(data)?; - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_text(&mut values, data)?; + let data = Self::finish_state(helper, S::Text(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Actions(Some(deserializer))); - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::Text(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::PageXElementType> for PageXElementTypeDeserializer { + impl<'de> Deserializer<'de, super::CtClipAreaXElementTypeContent> + for CtClipAreaXElementTypeContentDeserializer + { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::PageXElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + ) -> DeserializerResult<'de, super::CtClipAreaXElementTypeContent> { + let deserializer = Self { + state__: Box::new(CtClipAreaXElementTypeContentDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!( + &*x.state__, + CtClipAreaXElementTypeContentDeserializerState::Init__ + ) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::PageXElementType> { - use PageXElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtClipAreaXElementTypeContent> { + use CtClipAreaXElementTypeContentDeserializerState as S; let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Template(Some(deserializer)), event) => { + (S::Path(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_template(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_path(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::PageRes(Some(deserializer)), event) => { + (S::Text(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_page_res(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_text(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Area(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_area(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + (state, event @ Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Path(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Path", + true, + )?; + match self.handle_path(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Content(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_content(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + ( + S::Text(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Text", + true, + )?; + match self.handle_text(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Actions(Some(deserializer)), event) => { + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + } + }; + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish( + self, + helper: &mut DeserializeHelper, + ) -> Result { + Self::finish_state(helper, *self.state__) + } + } + #[derive(Debug)] + pub struct CtGraphicUnitActionsXElementTypeDeserializer { + action: Vec, + state__: Box, + } + #[derive(Debug)] + enum CtGraphicUnitActionsXElementTypeDeserializerState { + Init__, + Action( + Option<::Deserializer>, + ), + Done__, + Unknown__, + } + impl CtGraphicUnitActionsXElementTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + helper.raise_unexpected_attrib_checked(&attrib)?; + } + Ok(Self { + action: Vec::new(), + state__: Box::new(CtGraphicUnitActionsXElementTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: CtGraphicUnitActionsXElementTypeDeserializerState, + ) -> Result<(), Error> { + use CtGraphicUnitActionsXElementTypeDeserializerState as S; + match state { + S::Action(Some(deserializer)) => { + self.store_action(deserializer.finish(helper)?)? + } + _ => (), + } + Ok(()) + } + fn store_action( + &mut self, + value: super::super::definition::CtActionXType, + ) -> Result<(), Error> { + self.action.push(value); + Ok(()) + } + fn handle_action<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::super::definition::CtActionXType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtGraphicUnitActionsXElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + if self.action.len() < 1usize { + fallback.get_or_insert(S::Action(None)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } else { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_action(data)?; + *self.state__ = S::Action(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Action(Some(deserializer))); + *self.state__ = S::Action(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::CtGraphicUnitActionsXElementType> + for CtGraphicUnitActionsXElementTypeDeserializer + { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtGraphicUnitActionsXElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtGraphicUnitActionsXElementType> { + use CtGraphicUnitActionsXElementTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Action(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_actions(helper, output, &mut fallback)? { + match self.handle_action(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -30515,85 +32337,17 @@ pub mod page { } (S::Init__, event) => { fallback.get_or_insert(S::Init__); - *self.state__ = S::Template(None); + *self.state__ = S::Action(None); event } - (S::Template(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Template", - false, - )?; - match self.handle_template(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::PageRes(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"PageRes", - false, - )?; - match self.handle_page_res(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Area(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Area", - false, - )?; - match self.handle_area(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Content(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Content", - true, - )?; - match self.handle_content(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { + (S::Action(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Actions", + b"Action", true, )?; - match self.handle_actions(helper, output, &mut fallback)? { + match self.handle_action(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -30625,98 +32379,84 @@ pub mod page { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - PageXElementTypeDeserializerState::Unknown__, + CtGraphicUnitActionsXElementTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::PageXElementType { - template: self.template, - page_res: self.page_res, - area: self.area, - content: self.content, - actions: self.actions, + Ok(super::CtGraphicUnitActionsXElementType { + action: helper.finish_vec(1usize, None, self.action)?, }) } } #[derive(Debug)] - pub struct CtAxialShdSegmentXElementTypeDeserializer { - position: Option, - color: Option, - state__: Box, + pub struct CtGraphicUnitClipsXElementTypeDeserializer { + clip: Vec, + state__: Box, } #[derive(Debug)] - enum CtAxialShdSegmentXElementTypeDeserializerState { + enum CtGraphicUnitClipsXElementTypeDeserializerState { Init__, - Color(Option<::Deserializer>), + Clip(Option<::Deserializer>), Done__, Unknown__, } - impl CtAxialShdSegmentXElementTypeDeserializer { + impl CtGraphicUnitClipsXElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut position: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Position") - ) { - helper.read_attrib(&mut position, b"Position", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; - } + helper.raise_unexpected_attrib_checked(&attrib)?; } Ok(Self { - position: position, - color: None, - state__: Box::new(CtAxialShdSegmentXElementTypeDeserializerState::Init__), + clip: Vec::new(), + state__: Box::new(CtGraphicUnitClipsXElementTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: CtAxialShdSegmentXElementTypeDeserializerState, + state: CtGraphicUnitClipsXElementTypeDeserializerState, ) -> Result<(), Error> { - use CtAxialShdSegmentXElementTypeDeserializerState as S; + use CtGraphicUnitClipsXElementTypeDeserializerState as S; match state { - S::Color(Some(deserializer)) => { - self.store_color(deserializer.finish(helper)?)? - } + S::Clip(Some(deserializer)) => self.store_clip(deserializer.finish(helper)?)?, _ => (), } Ok(()) } - fn store_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { - if self.color.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Color", - )))?; - } - self.color = Some(value); + fn store_clip(&mut self, value: super::CtClipXType) -> Result<(), Error> { + self.clip.push(value); Ok(()) } - fn handle_color<'de>( + fn handle_clip<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtColorXType>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::CtClipXType>, + fallback: &mut Option, ) -> Result, Error> { - use CtAxialShdSegmentXElementTypeDeserializerState as S; + use CtGraphicUnitClipsXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - fallback.get_or_insert(S::Color(None)); if matches!(&fallback, Some(S::Init__)) { return Ok(ElementHandlerOutput::break_(event, allow_any)); - } else { + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + if self.clip.len() < 1usize { + fallback.get_or_insert(S::Clip(None)); return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } else { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } } if let Some(fallback) = fallback.take() { @@ -30725,33 +32465,33 @@ pub mod page { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_color(data)?; - *self.state__ = S::Done__; + self.store_clip(data)?; + *self.state__ = S::Clip(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Color(Some(deserializer))); - *self.state__ = S::Done__; + fallback.get_or_insert(S::Clip(Some(deserializer))); + *self.state__ = S::Clip(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtAxialShdSegmentXElementType> - for CtAxialShdSegmentXElementTypeDeserializer + impl<'de> Deserializer<'de, super::CtGraphicUnitClipsXElementType> + for CtGraphicUnitClipsXElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtAxialShdSegmentXElementType> { + ) -> DeserializerResult<'de, super::CtGraphicUnitClipsXElementType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtAxialShdSegmentXElementType> { - use CtAxialShdSegmentXElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtGraphicUnitClipsXElementType> { + use CtGraphicUnitClipsXElementTypeDeserializerState as S; let mut event = event; let mut fallback = None; let mut allow_any_element = false; @@ -30759,9 +32499,9 @@ pub mod page { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Color(Some(deserializer)), event) => { + (S::Clip(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_color(helper, output, &mut fallback)? { + match self.handle_clip(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -30783,17 +32523,17 @@ pub mod page { } (S::Init__, event) => { fallback.get_or_insert(S::Init__); - *self.state__ = S::Color(None); + *self.state__ = S::Clip(None); event } - (S::Color(None), event @ (Event::Start(_) | Event::Empty(_))) => { + (S::Clip(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Color", + b"Clip", true, )?; - match self.handle_color(helper, output, &mut fallback)? { + match self.handle_clip(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -30825,97 +32565,111 @@ pub mod page { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - CtAxialShdSegmentXElementTypeDeserializerState::Unknown__, + CtGraphicUnitClipsXElementTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::CtAxialShdSegmentXElementType { - position: self.position, - color: Box::new(helper.finish_element("Color", self.color)?), + Ok(super::CtGraphicUnitClipsXElementType { + clip: helper.finish_vec(1usize, None, self.clip)?, }) } } #[derive(Debug)] - pub struct CtClipAreaXElementTypeDeserializer { - draw_param: Option, - ctm: Option, - content: Option, - state__: Box, + pub struct CtGouraudShdPointXElementTypeDeserializer { + x: f64, + y: f64, + edge_flag: Option, + color: Option, + state__: Box, } #[derive(Debug)] - enum CtClipAreaXElementTypeDeserializerState { + enum CtGouraudShdPointXElementTypeDeserializerState { Init__, - Next__, - Content__(::Deserializer), + Color(Option<::Deserializer>), + Done__, Unknown__, } - impl CtClipAreaXElementTypeDeserializer { + impl CtGouraudShdPointXElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut draw_param: Option = None; - let mut ctm: Option = None; + let mut x: Option = None; + let mut y: Option = None; + let mut edge_flag: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DrawParam") + Some(b"X") ) { - helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; + helper.read_attrib(&mut x, b"X", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"CTM") + Some(b"y") ) { - helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; + helper.read_attrib(&mut y, b"y", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"EdgeFlag") + ) { + helper.read_attrib(&mut edge_flag, b"EdgeFlag", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - draw_param: draw_param, - ctm: ctm, - content: None, - state__: Box::new(CtClipAreaXElementTypeDeserializerState::Init__), + x: x.ok_or_else(|| ErrorKind::MissingAttribute("X".into()))?, + y: y.ok_or_else(|| ErrorKind::MissingAttribute("y".into()))?, + edge_flag: edge_flag, + color: None, + state__: Box::new(CtGouraudShdPointXElementTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: CtClipAreaXElementTypeDeserializerState, + state: CtGouraudShdPointXElementTypeDeserializerState, ) -> Result<(), Error> { - if let CtClipAreaXElementTypeDeserializerState::Content__(deserializer) = state { - self.store_content(deserializer.finish(helper)?)?; + use CtGouraudShdPointXElementTypeDeserializerState as S; + match state { + S::Color(Some(deserializer)) => { + self.store_color(deserializer.finish(helper)?)? + } + _ => (), } Ok(()) } - fn store_content( - &mut self, - value: super::CtClipAreaXElementTypeContent, - ) -> Result<(), Error> { - if self.content.is_some() { - Err(ErrorKind::DuplicateContent)?; + fn store_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { + if self.color.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Color", + )))?; } - self.content = Some(value); + self.color = Some(value); Ok(()) } - fn handle_content<'de>( + fn handle_color<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtClipAreaXElementTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::CtColorXType>, + fallback: &mut Option, ) -> Result, Error> { - use CtClipAreaXElementTypeDeserializerState as S; + use CtGouraudShdPointXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = fallback.take().unwrap_or(S::Next__); - return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); + fallback.get_or_insert(S::Color(None)); + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } else { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } } if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; @@ -30923,73 +32677,99 @@ pub mod page { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_content(data)?; - *self.state__ = S::Next__; + self.store_color(data)?; + *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Content__(deserializer); - Ok(ElementHandlerOutput::from_event_end(event, allow_any)) + fallback.get_or_insert(S::Color(Some(deserializer))); + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtClipAreaXElementType> for CtClipAreaXElementTypeDeserializer { + impl<'de> Deserializer<'de, super::CtGouraudShdPointXElementType> + for CtGouraudShdPointXElementTypeDeserializer + { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtClipAreaXElementType> { + ) -> DeserializerResult<'de, super::CtGouraudShdPointXElementType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtClipAreaXElementType> { - use CtClipAreaXElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtGouraudShdPointXElementType> { + use CtGouraudShdPointXElementTypeDeserializerState as S; let mut event = event; let mut fallback = None; + let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Content__(deserializer), event) => { + (S::Color(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_content(helper, output, &mut fallback)? { + match self.handle_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } return Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), event: DeserializerEvent::None, allow_any: false, }); } - (state @ (S::Init__ | S::Next__), event) => { - fallback.get_or_insert(state); - let output = - ::init( - helper, event, - )?; - match self.handle_content(helper, output, &mut fallback)? { + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Color(None); + event + } + (S::Color(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Color", + true, + )?; + match self.handle_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } } }; if let Some(fallback) = fallback { *self.state__ = fallback; } - let artifact = DeserializerArtifact::Deserializer(self); Ok(DeserializerOutput { - artifact, + artifact: DeserializerArtifact::Deserializer(self), event, allow_any, }) @@ -30997,299 +32777,351 @@ pub mod page { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - CtClipAreaXElementTypeDeserializerState::Unknown__, + CtGouraudShdPointXElementTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::CtClipAreaXElementType { - draw_param: self.draw_param, - ctm: self.ctm, - content: helper.finish_content(self.content)?, + Ok(super::CtGouraudShdPointXElementType { + x: self.x, + y: self.y, + edge_flag: self.edge_flag, + color: Box::new(helper.finish_element("Color", self.color)?), }) } } #[derive(Debug)] - pub struct CtClipAreaXElementTypeContentDeserializer { - state__: Box, + pub struct CtPageBlockTextObjectXElementTypeDeserializer { + boundary: String, + name: Option, + visible: bool, + ctm: Option, + draw_param: Option, + line_width: f64, + cap: super::CtGraphicUnitCapXType, + join: super::CtGraphicUnitJoinXType, + miter_limit: f64, + dash_offset: f64, + dash_pattern: Option, + alpha: i32, + font: u32, + size: f64, + stroke: bool, + fill: bool, + h_scale: f64, + read_direction: i32, + char_direction: i32, + weight: super::CtTextWeightXType, + italic: bool, + id: u32, + content: Vec, + state__: Box, } #[derive(Debug)] - pub enum CtClipAreaXElementTypeContentDeserializerState { + enum CtPageBlockTextObjectXElementTypeDeserializerState { Init__, - Path( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Text( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Next__, + Content__( + ::Deserializer, ), - Done__(super::CtClipAreaXElementTypeContent), Unknown__, } - impl CtClipAreaXElementTypeContentDeserializer { - fn find_suitable<'de>( - &mut self, + impl CtPageBlockTextObjectXElementTypeDeserializer { + fn from_bytes_start( helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> Result, Error> { - if let Event::Start(x) | Event::Empty(x) = &event { + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut boundary: Option = None; + let mut name: Option = None; + let mut visible: Option = None; + let mut ctm: Option = None; + let mut draw_param: Option = None; + let mut line_width: Option = None; + let mut cap: Option = None; + let mut join: Option = None; + let mut miter_limit: Option = None; + let mut dash_offset: Option = None; + let mut dash_pattern: Option = None; + let mut alpha: Option = None; + let mut font: Option = None; + let mut size: Option = None; + let mut stroke: Option = None; + let mut fill: Option = None; + let mut h_scale: Option = None; + let mut read_direction: Option = None; + let mut char_direction: Option = None; + let mut weight: Option = None; + let mut italic: Option = None; + let mut id: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"Path") + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Boundary") + ) { + helper.read_attrib(&mut boundary, b"Boundary", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Name") + ) { + helper.read_attrib(&mut name, b"Name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Visible") + ) { + helper.read_attrib(&mut visible, b"Visible", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"CTM") + ) { + helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DrawParam") + ) { + helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"LineWidth") + ) { + helper.read_attrib(&mut line_width, b"LineWidth", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Cap") + ) { + helper.read_attrib(&mut cap, b"Cap", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Join") + ) { + helper.read_attrib(&mut join, b"Join", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"MiterLimit") + ) { + helper.read_attrib(&mut miter_limit, b"MiterLimit", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DashOffset") + ) { + helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DashPattern") + ) { + helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Alpha") + ) { + helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Font") ) { - let output = ::init(helper, event)?; - return self.handle_path(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"Text") + helper.read_attrib(&mut font, b"Font", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Size") ) { - let output = ::init(helper, event)?; - return self.handle_text(helper, Default::default(), None, output); + helper.read_attrib(&mut size, b"Size", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Stroke") + ) { + helper.read_attrib(&mut stroke, b"Stroke", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Fill") + ) { + helper.read_attrib(&mut fill, b"Fill", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"HScale") + ) { + helper.read_attrib(&mut h_scale, b"HScale", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"ReadDirection") + ) { + helper.read_attrib(&mut read_direction, b"ReadDirection", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"CharDirection") + ) { + helper.read_attrib(&mut char_direction, b"CharDirection", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Weight") + ) { + helper.read_attrib(&mut weight, b"Weight", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Italic") + ) { + helper.read_attrib(&mut italic, b"Italic", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"ID") + ) { + helper.read_attrib(&mut id, b"ID", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; } } - *self.state__ = CtClipAreaXElementTypeContentDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent(event, false)) + Ok(Self { + boundary: boundary + .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, + name: name, + visible: visible + .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_visible), + ctm: ctm, + draw_param: draw_param, + line_width: line_width.unwrap_or_else( + super::CtPageBlockTextObjectXElementType::default_line_width, + ), + cap: cap.unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_cap), + join: join + .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_join), + miter_limit: miter_limit.unwrap_or_else( + super::CtPageBlockTextObjectXElementType::default_miter_limit, + ), + dash_offset: dash_offset.unwrap_or_else( + super::CtPageBlockTextObjectXElementType::default_dash_offset, + ), + dash_pattern: dash_pattern, + alpha: alpha + .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_alpha), + font: font.ok_or_else(|| ErrorKind::MissingAttribute("Font".into()))?, + size: size.ok_or_else(|| ErrorKind::MissingAttribute("Size".into()))?, + stroke: stroke + .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_stroke), + fill: fill + .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_fill), + h_scale: h_scale + .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_h_scale), + read_direction: read_direction.unwrap_or_else( + super::CtPageBlockTextObjectXElementType::default_read_direction, + ), + char_direction: char_direction.unwrap_or_else( + super::CtPageBlockTextObjectXElementType::default_char_direction, + ), + weight: weight + .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_weight), + italic: italic + .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_italic), + id: id.ok_or_else(|| ErrorKind::MissingAttribute("ID".into()))?, + content: Vec::new(), + state__: Box::new(CtPageBlockTextObjectXElementTypeDeserializerState::Init__), + }) } fn finish_state( + &mut self, helper: &mut DeserializeHelper, - state: CtClipAreaXElementTypeContentDeserializerState, - ) -> Result { - use CtClipAreaXElementTypeContentDeserializerState as S; - match state { - S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Path(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_path(&mut values, value)?; - } - Ok(super::CtClipAreaXElementTypeContent::Path( - helper.finish_element("Path", values)?, - )) - } - S::Text(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_text(&mut values, value)?; - } - Ok(super::CtClipAreaXElementTypeContent::Text( - helper.finish_element("Text", values)?, - )) - } - S::Done__(data) => Ok(data), - _ => unreachable!(), - } - } - fn store_path( - values: &mut Option, - value: super::CtPathXType, + state: CtPageBlockTextObjectXElementTypeDeserializerState, ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"Path")))?; + if let CtPageBlockTextObjectXElementTypeDeserializerState::Content__(deserializer) = + state + { + self.store_content(deserializer.finish(helper)?)?; } - *values = Some(value); Ok(()) } - fn store_text( - values: &mut Option, - value: super::CtTextXType, + fn store_content( + &mut self, + value: super::CtPageBlockTextObjectXElementTypeContent, ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"Text")))?; - } - *values = Some(value); + self.content.push(value); Ok(()) } - fn handle_path<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::CtPathXType>, - ) -> Result, Error> { - use CtClipAreaXElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_path(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_path(&mut values, data)?; - let data = Self::finish_state(helper, S::Path(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Path(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_text<'de>( + fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::CtTextXType>, + output: DeserializerOutput<'de, super::CtPageBlockTextObjectXElementTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use CtClipAreaXElementTypeContentDeserializerState as S; + use CtPageBlockTextObjectXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + *self.state__ = fallback.take().unwrap_or(S::Next__); + return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_text(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_text(&mut values, data)?; - let data = Self::finish_state(helper, S::Text(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_content(data)?; + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Text(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + *fallback = Some(S::Content__(deserializer)); + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtClipAreaXElementTypeContent> - for CtClipAreaXElementTypeContentDeserializer + impl<'de> Deserializer<'de, super::CtPageBlockTextObjectXElementType> + for CtPageBlockTextObjectXElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtClipAreaXElementTypeContent> { - let deserializer = Self { - state__: Box::new(CtClipAreaXElementTypeContentDeserializerState::Init__), - }; - let mut output = deserializer.next(helper, event)?; - output.artifact = match output.artifact { - DeserializerArtifact::Deserializer(x) - if matches!( - &*x.state__, - CtClipAreaXElementTypeContentDeserializerState::Init__ - ) => - { - DeserializerArtifact::None - } - artifact => artifact, - }; - Ok(output) + ) -> DeserializerResult<'de, super::CtPageBlockTextObjectXElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtClipAreaXElementTypeContent> { - use CtClipAreaXElementTypeContentDeserializerState as S; - let mut event = event; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::Path(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_path(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Text(values, fallback, Some(deserializer)), event) => { + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtPageBlockTextObjectXElementType> { + use CtPageBlockTextObjectXElementTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Content__(deserializer), event) => { let output = deserializer.next(helper, event)?; - match self.handle_text(helper, values, fallback, output)? { + match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (state, event @ Event::End(_)) => { + (_, Event::End(_)) => { return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(Self::finish_state( - helper, state, - )?), - event: DeserializerEvent::Continue(event), + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, allow_any: false, }); } - (S::Init__, event) => match self.find_suitable(helper, event)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - }, - ( - S::Path(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Path", - true, - )?; - match self.handle_path(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::Text(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Text", - true, - )?; - match self.handle_text(helper, values, fallback, output)? { + (state @ (S::Init__ | S::Next__), event) => { + fallback.get_or_insert(state); + let output = < super :: CtPageBlockTextObjectXElementTypeContent as WithDeserializer > :: init (helper , event) ? ; + match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (state @ S::Done__(_), event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); - } } }; - let artifact = if matches!(&*self.state__, S::Done__(_)) { - DeserializerArtifact::Data(self.finish(helper)?) - } else { - DeserializerArtifact::Deserializer(self) - }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + let artifact = DeserializerArtifact::Deserializer(self); Ok(DeserializerOutput { artifact, event, @@ -31297,1057 +33129,737 @@ pub mod page { }) } fn finish( - self, + mut self, helper: &mut DeserializeHelper, - ) -> Result { - Self::finish_state(helper, *self.state__) + ) -> Result { + let state = replace( + &mut *self.state__, + CtPageBlockTextObjectXElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::CtPageBlockTextObjectXElementType { + boundary: self.boundary, + name: self.name, + visible: self.visible, + ctm: self.ctm, + draw_param: self.draw_param, + line_width: self.line_width, + cap: self.cap, + join: self.join, + miter_limit: self.miter_limit, + dash_offset: self.dash_offset, + dash_pattern: self.dash_pattern, + alpha: self.alpha, + font: self.font, + size: self.size, + stroke: self.stroke, + fill: self.fill, + h_scale: self.h_scale, + read_direction: self.read_direction, + char_direction: self.char_direction, + weight: self.weight, + italic: self.italic, + id: self.id, + content: helper.finish_vec(1usize, None, self.content)?, + }) } } #[derive(Debug)] - pub struct CtGraphicUnitActionsXElementTypeDeserializer { - action: Vec, - state__: Box, + pub struct CtPageBlockTextObjectXElementTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - enum CtGraphicUnitActionsXElementTypeDeserializerState { + pub enum CtPageBlockTextObjectXElementTypeContentDeserializerState { Init__, - Action( - Option<::Deserializer>, + Actions( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Done__, + Clips( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + FillColor( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + StrokeColor( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + CgTransform( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + TextCode( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::CtPageBlockTextObjectXElementTypeContent), Unknown__, } - impl CtGraphicUnitActionsXElementTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - helper.raise_unexpected_attrib_checked(&attrib)?; - } - Ok(Self { - action: Vec::new(), - state__: Box::new(CtGraphicUnitActionsXElementTypeDeserializerState::Init__), - }) - } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: CtGraphicUnitActionsXElementTypeDeserializerState, - ) -> Result<(), Error> { - use CtGraphicUnitActionsXElementTypeDeserializerState as S; - match state { - S::Action(Some(deserializer)) => { - self.store_action(deserializer.finish(helper)?)? - } - _ => (), - } - Ok(()) - } - fn store_action( - &mut self, - value: super::super::definition::CtActionXType, - ) -> Result<(), Error> { - self.action.push(value); - Ok(()) - } - fn handle_action<'de>( + impl CtPageBlockTextObjectXElementTypeContentDeserializer { + fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::super::definition::CtActionXType>, - fallback: &mut Option, + event: Event<'de>, ) -> Result, Error> { - use CtGraphicUnitActionsXElementTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"Actions") + ) { + let output = + ::init( + helper, event, + )?; + return self.handle_actions(helper, Default::default(), None, output); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"Clips") + ) { + let output = + ::init( + helper, event, + )?; + return self.handle_clips(helper, Default::default(), None, output); } - if self.action.len() < 1usize { - fallback.get_or_insert(S::Action(None)); - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } else { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"FillColor") + ) { + let output = + ::init(helper, event)?; + return self.handle_fill_color(helper, Default::default(), None, output); } - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_action(data)?; - *self.state__ = S::Action(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"StrokeColor") + ) { + let output = + ::init(helper, event)?; + return self.handle_stroke_color(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"CGTransform") + ) { + let output = + ::init(helper, event)?; + return self.handle_cg_transform(helper, Default::default(), None, output); } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Action(Some(deserializer))); - *self.state__ = S::Action(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), + Some(b"TextCode") + ) { + let output = ::init( + helper, event, + )?; + return self.handle_text_code(helper, Default::default(), None, output); } } + *self.state__ = CtPageBlockTextObjectXElementTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) } - } - impl<'de> Deserializer<'de, super::CtGraphicUnitActionsXElementType> - for CtGraphicUnitActionsXElementTypeDeserializer - { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtGraphicUnitActionsXElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, + fn finish_state( helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtGraphicUnitActionsXElementType> { - use CtGraphicUnitActionsXElementTypeDeserializerState as S; - let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::Action(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_action(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } + state: CtPageBlockTextObjectXElementTypeContentDeserializerState, + ) -> Result { + use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Actions(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_actions(&mut values, value)?; } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, - allow_any: false, - }); + Ok(super::CtPageBlockTextObjectXElementTypeContent::Actions( + helper.finish_element("Actions", values)?, + )) + } + S::Clips(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_clips(&mut values, value)?; } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Action(None); - event + Ok(super::CtPageBlockTextObjectXElementTypeContent::Clips( + helper.finish_element("Clips", values)?, + )) + } + S::FillColor(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_fill_color(&mut values, value)?; } - (S::Action(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Action", - true, - )?; - match self.handle_action(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } + Ok(super::CtPageBlockTextObjectXElementTypeContent::FillColor( + helper.finish_element("FillColor", values)?, + )) + } + S::StrokeColor(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_stroke_color(&mut values, value)?; } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); + Ok( + super::CtPageBlockTextObjectXElementTypeContent::StrokeColor( + helper.finish_element("StrokeColor", values)?, + ), + ) + } + S::CgTransform(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_cg_transform(&mut values, value)?; } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Break(event), false); + Ok( + super::CtPageBlockTextObjectXElementTypeContent::CgTransform( + helper.finish_element("CGTransform", values)?, + ), + ) + } + S::TextCode(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_text_code(&mut values, value)?; } + Ok(super::CtPageBlockTextObjectXElementTypeContent::TextCode( + helper.finish_element("TextCode", values)?, + )) } - }; - if let Some(fallback) = fallback { - *self.state__ = fallback; + S::Done__(data) => Ok(data), + _ => unreachable!(), } - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), - event, - allow_any, - }) } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - CtGraphicUnitActionsXElementTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::CtGraphicUnitActionsXElementType { - action: helper.finish_vec(1usize, None, self.action)?, - }) + fn store_actions( + values: &mut Option, + value: super::CtGraphicUnitActionsXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Actions", + )))?; + } + *values = Some(value); + Ok(()) } - } - #[derive(Debug)] - pub struct CtGraphicUnitClipsXElementTypeDeserializer { - clip: Vec, - state__: Box, - } - #[derive(Debug)] - enum CtGraphicUnitClipsXElementTypeDeserializerState { - Init__, - Clip(Option<::Deserializer>), - Done__, - Unknown__, - } - impl CtGraphicUnitClipsXElementTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - helper.raise_unexpected_attrib_checked(&attrib)?; + fn store_clips( + values: &mut Option, + value: super::CtGraphicUnitClipsXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Clips", + )))?; } - Ok(Self { - clip: Vec::new(), - state__: Box::new(CtGraphicUnitClipsXElementTypeDeserializerState::Init__), - }) + *values = Some(value); + Ok(()) } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: CtGraphicUnitClipsXElementTypeDeserializerState, + fn store_fill_color( + values: &mut Option, + value: super::CtColorXType, ) -> Result<(), Error> { - use CtGraphicUnitClipsXElementTypeDeserializerState as S; - match state { - S::Clip(Some(deserializer)) => self.store_clip(deserializer.finish(helper)?)?, - _ => (), + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"FillColor", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_stroke_color( + values: &mut Option, + value: super::CtColorXType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"StrokeColor", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_cg_transform( + values: &mut Option, + value: super::CtCgTransformXType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"CGTransform", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_text_code( + values: &mut Option, + value: super::CtTextTextCodeXElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"TextCode", + )))?; } + *values = Some(value); Ok(()) } - fn store_clip(&mut self, value: super::CtClipXType) -> Result<(), Error> { - self.clip.push(value); - Ok(()) - } - fn handle_clip<'de>( + fn handle_actions<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtClipXType>, - fallback: &mut Option, + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, ) -> Result, Error> { - use CtGraphicUnitClipsXElementTypeDeserializerState as S; + use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - if self.clip.len() < 1usize { - fallback.get_or_insert(S::Clip(None)); - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } else { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_actions(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_clip(data)?; - *self.state__ = S::Clip(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_actions(&mut values, data)?; + let data = Self::finish_state(helper, S::Actions(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Clip(Some(deserializer))); - *self.state__ = S::Clip(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::Actions(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - } - impl<'de> Deserializer<'de, super::CtGraphicUnitClipsXElementType> - for CtGraphicUnitClipsXElementTypeDeserializer - { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtGraphicUnitClipsXElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, + fn handle_clips<'de>( + &mut self, helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtGraphicUnitClipsXElementType> { - use CtGraphicUnitClipsXElementTypeDeserializerState as S; - let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::Clip(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_clip(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, - allow_any: false, - }); - } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Clip(None); - event - } - (S::Clip(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Clip", - true, - )?; - match self.handle_clip(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Break(event), false); - } - } - }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, + ) -> Result, Error> { + use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, event, allow_any, - }) - } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - CtGraphicUnitClipsXElementTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::CtGraphicUnitClipsXElementType { - clip: helper.finish_vec(1usize, None, self.clip)?, - }) - } - } - #[derive(Debug)] - pub struct CtGouraudShdPointXElementTypeDeserializer { - x: f64, - y: f64, - edge_flag: Option, - color: Option, - state__: Box, - } - #[derive(Debug)] - enum CtGouraudShdPointXElementTypeDeserializerState { - Init__, - Color(Option<::Deserializer>), - Done__, - Unknown__, - } - impl CtGouraudShdPointXElementTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut x: Option = None; - let mut y: Option = None; - let mut edge_flag: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"X") - ) { - helper.read_attrib(&mut x, b"X", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"y") - ) { - helper.read_attrib(&mut y, b"y", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"EdgeFlag") - ) { - helper.read_attrib(&mut edge_flag, b"EdgeFlag", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; - } + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - Ok(Self { - x: x.ok_or_else(|| ErrorKind::MissingAttribute("X".into()))?, - y: y.ok_or_else(|| ErrorKind::MissingAttribute("y".into()))?, - edge_flag: edge_flag, - color: None, - state__: Box::new(CtGouraudShdPointXElementTypeDeserializerState::Init__), - }) - } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: CtGouraudShdPointXElementTypeDeserializerState, - ) -> Result<(), Error> { - use CtGouraudShdPointXElementTypeDeserializerState as S; - match state { - S::Color(Some(deserializer)) => { - self.store_color(deserializer.finish(helper)?)? - } - _ => (), + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_clips(&mut values, data)?; } - Ok(()) - } - fn store_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { - if self.color.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Color", - )))?; + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_clips(&mut values, data)?; + let data = Self::finish_state(helper, S::Clips(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Clips(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } } - self.color = Some(value); - Ok(()) } - fn handle_color<'de>( + fn handle_fill_color<'de>( &mut self, helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::CtColorXType>, - fallback: &mut Option, ) -> Result, Error> { - use CtGouraudShdPointXElementTypeDeserializerState as S; + use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - fallback.get_or_insert(S::Color(None)); - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } else { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_fill_color(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_color(data)?; - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_fill_color(&mut values, data)?; + let data = Self::finish_state(helper, S::FillColor(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Color(Some(deserializer))); - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::FillColor(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - } - impl<'de> Deserializer<'de, super::CtGouraudShdPointXElementType> - for CtGouraudShdPointXElementTypeDeserializer - { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtGouraudShdPointXElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, + fn handle_stroke_color<'de>( + &mut self, helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtGouraudShdPointXElementType> { - use CtGouraudShdPointXElementTypeDeserializerState as S; - let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::Color(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, - allow_any: false, - }); - } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Color(None); - event - } - (S::Color(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Color", - true, - )?; - match self.handle_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Break(event), false); - } - } - }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CtColorXType>, + ) -> Result, Error> { + use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, event, allow_any, - }) - } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - CtGouraudShdPointXElementTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::CtGouraudShdPointXElementType { - x: self.x, - y: self.y, - edge_flag: self.edge_flag, - color: Box::new(helper.finish_element("Color", self.color)?), - }) - } - } - #[derive(Debug)] - pub struct CtImageBorderXElementTypeDeserializer { - line_width: f64, - horizonal_corner_radius: f64, - vertical_corner_radius: f64, - dash_offset: f64, - dash_pattern: Option, - border_color: Option, - state__: Box, - } - #[derive(Debug)] - enum CtImageBorderXElementTypeDeserializerState { - Init__, - BorderColor(Option<::Deserializer>), - Done__, - Unknown__, - } - impl CtImageBorderXElementTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut line_width: Option = None; - let mut horizonal_corner_radius: Option = None; - let mut vertical_corner_radius: Option = None; - let mut dash_offset: Option = None; - let mut dash_pattern: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"LineWidth") - ) { - helper.read_attrib(&mut line_width, b"LineWidth", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"HorizonalCornerRadius") - ) { - helper.read_attrib( - &mut horizonal_corner_radius, - b"HorizonalCornerRadius", - &attrib.value, - )?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"VerticalCornerRadius") - ) { - helper.read_attrib( - &mut vertical_corner_radius, - b"VerticalCornerRadius", - &attrib.value, - )?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashOffset") - ) { - helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashPattern") - ) { - helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; - } + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - Ok(Self { - line_width: line_width - .unwrap_or_else(super::CtImageBorderXElementType::default_line_width), - horizonal_corner_radius: horizonal_corner_radius.unwrap_or_else( - super::CtImageBorderXElementType::default_horizonal_corner_radius, - ), - vertical_corner_radius: vertical_corner_radius.unwrap_or_else( - super::CtImageBorderXElementType::default_vertical_corner_radius, - ), - dash_offset: dash_offset - .unwrap_or_else(super::CtImageBorderXElementType::default_dash_offset), - dash_pattern: dash_pattern, - border_color: None, - state__: Box::new(CtImageBorderXElementTypeDeserializerState::Init__), - }) - } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: CtImageBorderXElementTypeDeserializerState, - ) -> Result<(), Error> { - use CtImageBorderXElementTypeDeserializerState as S; - match state { - S::BorderColor(Some(deserializer)) => { - self.store_border_color(deserializer.finish(helper)?)? - } - _ => (), + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_stroke_color(&mut values, data)?; } - Ok(()) - } - fn store_border_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { - if self.border_color.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"BorderColor", - )))?; + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_stroke_color(&mut values, data)?; + let data = Self::finish_state(helper, S::StrokeColor(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::StrokeColor(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } } - self.border_color = Some(value); - Ok(()) } - fn handle_border_color<'de>( + fn handle_cg_transform<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtColorXType>, - fallback: &mut Option, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::CtCgTransformXType>, ) -> Result, Error> { - use CtImageBorderXElementTypeDeserializerState as S; + use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_cg_transform(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_border_color(data)?; - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_cg_transform(&mut values, data)?; + let data = Self::finish_state(helper, S::CgTransform(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::BorderColor(Some(deserializer))); - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - } - impl<'de> Deserializer<'de, super::CtImageBorderXElementType> - for CtImageBorderXElementTypeDeserializer - { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtImageBorderXElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtImageBorderXElementType> { - use CtImageBorderXElementTypeDeserializerState as S; - let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::BorderColor(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_border_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, - allow_any: false, - }); - } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::BorderColor(None); - event - } - (S::BorderColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"BorderColor", - true, - )?; - match self.handle_border_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Break(event), false); - } - } - }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), - event, - allow_any, - }) - } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - CtImageBorderXElementTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::CtImageBorderXElementType { - line_width: self.line_width, - horizonal_corner_radius: self.horizonal_corner_radius, - vertical_corner_radius: self.vertical_corner_radius, - dash_offset: self.dash_offset, - dash_pattern: self.dash_pattern, - border_color: self.border_color, - }) - } - } - #[derive(Debug)] - pub struct CtLaGouraudShdPointXElementTypeDeserializer { - x: Option, - y: Option, - color: Option, - state__: Box, - } - #[derive(Debug)] - enum CtLaGouraudShdPointXElementTypeDeserializerState { - Init__, - Color(Option<::Deserializer>), - Done__, - Unknown__, - } - impl CtLaGouraudShdPointXElementTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut x: Option = None; - let mut y: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"X") - ) { - helper.read_attrib(&mut x, b"X", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"y") - ) { - helper.read_attrib(&mut y, b"y", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; - } - } - Ok(Self { - x: x, - y: y, - color: None, - state__: Box::new(CtLaGouraudShdPointXElementTypeDeserializerState::Init__), - }) - } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: CtLaGouraudShdPointXElementTypeDeserializerState, - ) -> Result<(), Error> { - use CtLaGouraudShdPointXElementTypeDeserializerState as S; - match state { - S::Color(Some(deserializer)) => { - self.store_color(deserializer.finish(helper)?)? + *self.state__ = S::CgTransform(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } - _ => (), - } - Ok(()) - } - fn store_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { - if self.color.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Color", - )))?; } - self.color = Some(value); - Ok(()) } - fn handle_color<'de>( + fn handle_text_code<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtColorXType>, - fallback: &mut Option, + mut values: Option, + fallback: Option< + ::Deserializer, + >, + output: DeserializerOutput<'de, super::CtTextTextCodeXElementType>, ) -> Result, Error> { - use CtLaGouraudShdPointXElementTypeDeserializerState as S; + use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - fallback.get_or_insert(S::Color(None)); - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } else { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_text_code(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_color(data)?; - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_text_code(&mut values, data)?; + let data = Self::finish_state(helper, S::TextCode(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Color(Some(deserializer))); - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::TextCode(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::CtPageBlockTextObjectXElementTypeContent> + for CtPageBlockTextObjectXElementTypeContentDeserializer + { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::CtPageBlockTextObjectXElementTypeContent> + { + let deserializer = Self { + state__: Box::new( + CtPageBlockTextObjectXElementTypeContentDeserializerState::Init__, + ), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!( + &*x.state__, + CtPageBlockTextObjectXElementTypeContentDeserializerState::Init__ + ) => + { + DeserializerArtifact::None } - } - } - } - impl<'de> Deserializer<'de, super::CtLaGouraudShdPointXElementType> - for CtLaGouraudShdPointXElementTypeDeserializer - { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::CtLaGouraudShdPointXElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + artifact => artifact, + }; + Ok(output) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtLaGouraudShdPointXElementType> { - use CtLaGouraudShdPointXElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtPageBlockTextObjectXElementTypeContent> + { + use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Color(Some(deserializer)), event) => { + (S::Actions(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_actions(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Clips(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_clips(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + (S::FillColor(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_fill_color(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::StrokeColor(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_stroke_color(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::CgTransform(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_cg_transform(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::TextCode(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_text_code(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, } + } + (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), allow_any: false, }); } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Color(None); - event + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Actions(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Actions", + true, + )?; + match self.handle_actions(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } } - (S::Color(None), event @ (Event::Start(_) | Event::Empty(_))) => { + ( + S::Clips(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Color", + b"Clips", true, )?; - match self.handle_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_clips(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::FillColor(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"FillColor", + true, + )?; + match self.handle_fill_color(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::StrokeColor(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"StrokeColor", + true, + )?; + match self.handle_stroke_color(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); + ( + S::CgTransform(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"CGTransform", + false, + )?; + match self.handle_cg_transform(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::TextCode(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"TextCode", + false, + )?; + match self.handle_text_code(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); } (state, event) => { *self.state__ = state; - break (DeserializerEvent::Break(event), false); + break (DeserializerEvent::Continue(event), false); } } }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + artifact, event, allow_any, }) } fn finish( - mut self, + self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - CtLaGouraudShdPointXElementTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::CtLaGouraudShdPointXElementType { - x: self.x, - y: self.y, - color: Box::new(helper.finish_element("Color", self.color)?), - }) + ) -> Result { + Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct CtPageBlockTextObjectXElementTypeDeserializer { + pub struct CtPageBlockPathObjectXElementTypeDeserializer { boundary: String, name: Option, visible: bool, @@ -32360,29 +33872,33 @@ pub mod page { dash_offset: f64, dash_pattern: Option, alpha: i32, - font: u32, - size: f64, stroke: bool, fill: bool, - h_scale: f64, - read_direction: i32, - char_direction: i32, - weight: super::CtTextWeightXType, - italic: bool, + rule: super::CtPathRuleXType, id: u32, - content: Vec, - state__: Box, + actions: Option, + clips: Option, + stroke_color: Option, + fill_color: Option, + abbreviated_data: Option, + state__: Box, } #[derive(Debug)] - enum CtPageBlockTextObjectXElementTypeDeserializerState { + enum CtPageBlockPathObjectXElementTypeDeserializerState { Init__, - Next__, - Content__( - ::Deserializer, + Actions( + Option<::Deserializer>, ), + Clips( + Option<::Deserializer>, + ), + StrokeColor(Option<::Deserializer>), + FillColor(Option<::Deserializer>), + AbbreviatedData(Option<::Deserializer>), + Done__, Unknown__, } - impl CtPageBlockTextObjectXElementTypeDeserializer { + impl CtPageBlockPathObjectXElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -32399,15 +33915,9 @@ pub mod page { let mut dash_offset: Option = None; let mut dash_pattern: Option = None; let mut alpha: Option = None; - let mut font: Option = None; - let mut size: Option = None; let mut stroke: Option = None; let mut fill: Option = None; - let mut h_scale: Option = None; - let mut read_direction: Option = None; - let mut char_direction: Option = None; - let mut weight: Option = None; - let mut italic: Option = None; + let mut rule: Option = None; let mut id: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; @@ -32471,16 +33981,6 @@ pub mod page { Some(b"Alpha") ) { helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Font") - ) { - helper.read_attrib(&mut font, b"Font", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Size") - ) { - helper.read_attrib(&mut size, b"Size", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), Some(b"Stroke") @@ -32493,29 +33993,9 @@ pub mod page { helper.read_attrib(&mut fill, b"Fill", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"HScale") - ) { - helper.read_attrib(&mut h_scale, b"HScale", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"ReadDirection") - ) { - helper.read_attrib(&mut read_direction, b"ReadDirection", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"CharDirection") - ) { - helper.read_attrib(&mut char_direction, b"CharDirection", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Weight") - ) { - helper.read_attrib(&mut weight, b"Weight", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Italic") + Some(b"Rule") ) { - helper.read_attrib(&mut italic, b"Italic", &attrib.value)?; + helper.read_attrib(&mut rule, b"Rule", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), Some(b"ID") @@ -32530,81 +34010,267 @@ pub mod page { .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, name: name, visible: visible - .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_visible), + .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_visible), ctm: ctm, draw_param: draw_param, line_width: line_width.unwrap_or_else( - super::CtPageBlockTextObjectXElementType::default_line_width, + super::CtPageBlockPathObjectXElementType::default_line_width, ), - cap: cap.unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_cap), + cap: cap.unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_cap), join: join - .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_join), + .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_join), miter_limit: miter_limit.unwrap_or_else( - super::CtPageBlockTextObjectXElementType::default_miter_limit, + super::CtPageBlockPathObjectXElementType::default_miter_limit, ), dash_offset: dash_offset.unwrap_or_else( - super::CtPageBlockTextObjectXElementType::default_dash_offset, + super::CtPageBlockPathObjectXElementType::default_dash_offset, ), dash_pattern: dash_pattern, alpha: alpha - .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_alpha), - font: font.ok_or_else(|| ErrorKind::MissingAttribute("Font".into()))?, - size: size.ok_or_else(|| ErrorKind::MissingAttribute("Size".into()))?, + .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_alpha), stroke: stroke - .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_stroke), + .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_stroke), fill: fill - .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_fill), - h_scale: h_scale - .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_h_scale), - read_direction: read_direction.unwrap_or_else( - super::CtPageBlockTextObjectXElementType::default_read_direction, - ), - char_direction: char_direction.unwrap_or_else( - super::CtPageBlockTextObjectXElementType::default_char_direction, - ), - weight: weight - .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_weight), - italic: italic - .unwrap_or_else(super::CtPageBlockTextObjectXElementType::default_italic), + .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_fill), + rule: rule + .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_rule), id: id.ok_or_else(|| ErrorKind::MissingAttribute("ID".into()))?, - content: Vec::new(), - state__: Box::new(CtPageBlockTextObjectXElementTypeDeserializerState::Init__), + actions: None, + clips: None, + stroke_color: None, + fill_color: None, + abbreviated_data: None, + state__: Box::new(CtPageBlockPathObjectXElementTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: CtPageBlockTextObjectXElementTypeDeserializerState, + state: CtPageBlockPathObjectXElementTypeDeserializerState, ) -> Result<(), Error> { - if let CtPageBlockTextObjectXElementTypeDeserializerState::Content__(deserializer) = - state - { - self.store_content(deserializer.finish(helper)?)?; + use CtPageBlockPathObjectXElementTypeDeserializerState as S; + match state { + S::Actions(Some(deserializer)) => { + self.store_actions(deserializer.finish(helper)?)? + } + S::Clips(Some(deserializer)) => { + self.store_clips(deserializer.finish(helper)?)? + } + S::StrokeColor(Some(deserializer)) => { + self.store_stroke_color(deserializer.finish(helper)?)? + } + S::FillColor(Some(deserializer)) => { + self.store_fill_color(deserializer.finish(helper)?)? + } + S::AbbreviatedData(Some(deserializer)) => { + self.store_abbreviated_data(deserializer.finish(helper)?)? + } + _ => (), + } + Ok(()) + } + fn store_actions( + &mut self, + value: super::CtGraphicUnitActionsXElementType, + ) -> Result<(), Error> { + if self.actions.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Actions", + )))?; + } + self.actions = Some(value); + Ok(()) + } + fn store_clips( + &mut self, + value: super::CtGraphicUnitClipsXElementType, + ) -> Result<(), Error> { + if self.clips.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Clips", + )))?; + } + self.clips = Some(value); + Ok(()) + } + fn store_stroke_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { + if self.stroke_color.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"StrokeColor", + )))?; + } + self.stroke_color = Some(value); + Ok(()) + } + fn store_fill_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { + if self.fill_color.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"FillColor", + )))?; + } + self.fill_color = Some(value); + Ok(()) + } + fn store_abbreviated_data(&mut self, value: String) -> Result<(), Error> { + if self.abbreviated_data.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"AbbreviatedData", + )))?; + } + self.abbreviated_data = Some(value); + Ok(()) + } + fn handle_actions<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtPageBlockPathObjectXElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Clips(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_actions(data)?; + *self.state__ = S::Clips(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Actions(Some(deserializer))); + *self.state__ = S::Clips(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_clips<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtPageBlockPathObjectXElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::StrokeColor(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_clips(data)?; + *self.state__ = S::StrokeColor(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Clips(Some(deserializer))); + *self.state__ = S::StrokeColor(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_stroke_color<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtColorXType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtPageBlockPathObjectXElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::FillColor(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_stroke_color(data)?; + *self.state__ = S::FillColor(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::StrokeColor(Some(deserializer))); + *self.state__ = S::FillColor(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } } - Ok(()) } - fn store_content( + fn handle_fill_color<'de>( &mut self, - value: super::CtPageBlockTextObjectXElementTypeContent, - ) -> Result<(), Error> { - self.content.push(value); - Ok(()) + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtColorXType>, + fallback: &mut Option, + ) -> Result, Error> { + use CtPageBlockPathObjectXElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::AbbreviatedData(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_fill_color(data)?; + *self.state__ = S::AbbreviatedData(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::FillColor(Some(deserializer))); + *self.state__ = S::AbbreviatedData(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } } - fn handle_content<'de>( + fn handle_abbreviated_data<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtPageBlockTextObjectXElementTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, String>, + fallback: &mut Option, ) -> Result, Error> { - use CtPageBlockTextObjectXElementTypeDeserializerState as S; + use CtPageBlockPathObjectXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = fallback.take().unwrap_or(S::Next__); - return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); + fallback.get_or_insert(S::AbbreviatedData(None)); + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } else { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } } if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; @@ -32612,73 +34278,215 @@ pub mod page { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_content(data)?; - *self.state__ = S::Next__; + self.store_abbreviated_data(data)?; + *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *fallback = Some(S::Content__(deserializer)); - *self.state__ = S::Next__; + fallback.get_or_insert(S::AbbreviatedData(Some(deserializer))); + *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtPageBlockTextObjectXElementType> - for CtPageBlockTextObjectXElementTypeDeserializer + impl<'de> Deserializer<'de, super::CtPageBlockPathObjectXElementType> + for CtPageBlockPathObjectXElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockTextObjectXElementType> { + ) -> DeserializerResult<'de, super::CtPageBlockPathObjectXElementType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockTextObjectXElementType> { - use CtPageBlockTextObjectXElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtPageBlockPathObjectXElementType> { + use CtPageBlockPathObjectXElementTypeDeserializerState as S; let mut event = event; let mut fallback = None; + let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Content__(deserializer), event) => { + (S::Actions(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_content(helper, output, &mut fallback)? { + match self.handle_actions(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Clips(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_clips(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::StrokeColor(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_stroke_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::FillColor(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_fill_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::AbbreviatedData(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_abbreviated_data(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } return Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), event: DeserializerEvent::None, allow_any: false, }); } - (state @ (S::Init__ | S::Next__), event) => { - fallback.get_or_insert(state); - let output = < super :: CtPageBlockTextObjectXElementTypeContent as WithDeserializer > :: init (helper , event) ? ; - match self.handle_content(helper, output, &mut fallback)? { + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Actions(None); + event + } + (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Actions", + true, + )?; + match self.handle_actions(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Clips(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"Clips", + true, + )?; + match self.handle_clips(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::StrokeColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"StrokeColor", + true, + )?; + match self.handle_stroke_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } + (S::FillColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"FillColor", + true, + )?; + match self.handle_fill_color(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::AbbreviatedData(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_UNNAMED_5), + b"AbbreviatedData", + false, + )?; + match self.handle_abbreviated_data(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } } }; if let Some(fallback) = fallback { *self.state__ = fallback; } - let artifact = DeserializerArtifact::Deserializer(self); Ok(DeserializerOutput { - artifact, + artifact: DeserializerArtifact::Deserializer(self), event, allow_any, }) @@ -32686,13 +34494,13 @@ pub mod page { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - CtPageBlockTextObjectXElementTypeDeserializerState::Unknown__, + CtPageBlockPathObjectXElementTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::CtPageBlockTextObjectXElementType { + Ok(super::CtPageBlockPathObjectXElementType { boundary: self.boundary, name: self.name, visible: self.visible, @@ -32705,716 +34513,529 @@ pub mod page { dash_offset: self.dash_offset, dash_pattern: self.dash_pattern, alpha: self.alpha, - font: self.font, - size: self.size, stroke: self.stroke, fill: self.fill, - h_scale: self.h_scale, - read_direction: self.read_direction, - char_direction: self.char_direction, - weight: self.weight, - italic: self.italic, + rule: self.rule, id: self.id, - content: helper.finish_vec(1usize, None, self.content)?, + actions: self.actions, + clips: self.clips, + stroke_color: self.stroke_color, + fill_color: self.fill_color, + abbreviated_data: helper + .finish_element("AbbreviatedData", self.abbreviated_data)?, }) } } #[derive(Debug)] - pub struct CtPageBlockTextObjectXElementTypeContentDeserializer { - state__: Box, + pub struct CtPageBlockImageObjectXElementTypeDeserializer { + boundary: String, + name: Option, + visible: bool, + ctm: Option, + draw_param: Option, + line_width: f64, + cap: super::CtGraphicUnitCapXType, + join: super::CtGraphicUnitJoinXType, + miter_limit: f64, + dash_offset: f64, + dash_pattern: Option, + alpha: i32, + resource_id: u32, + substitution: Option, + image_mask: Option, + id: u32, + actions: Option, + clips: Option, + border: Option, + state__: Box, } #[derive(Debug)] - pub enum CtPageBlockTextObjectXElementTypeContentDeserializerState { + enum CtPageBlockImageObjectXElementTypeDeserializerState { Init__, Actions( - Option, - Option<::Deserializer>, Option<::Deserializer>, ), Clips( - Option, Option<::Deserializer>, - Option<::Deserializer>, - ), - FillColor( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - StrokeColor( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - CgTransform( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - TextCode( - Option, - Option<::Deserializer>, - Option<::Deserializer>, ), - Done__(super::CtPageBlockTextObjectXElementTypeContent), + Border(Option<::Deserializer>), + Done__, Unknown__, } - impl CtPageBlockTextObjectXElementTypeContentDeserializer { - fn find_suitable<'de>( - &mut self, + impl CtPageBlockImageObjectXElementTypeDeserializer { + fn from_bytes_start( helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> Result, Error> { - if let Event::Start(x) | Event::Empty(x) = &event { + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut boundary: Option = None; + let mut name: Option = None; + let mut visible: Option = None; + let mut ctm: Option = None; + let mut draw_param: Option = None; + let mut line_width: Option = None; + let mut cap: Option = None; + let mut join: Option = None; + let mut miter_limit: Option = None; + let mut dash_offset: Option = None; + let mut dash_pattern: Option = None; + let mut alpha: Option = None; + let mut resource_id: Option = None; + let mut substitution: Option = None; + let mut image_mask: Option = None; + let mut id: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"Actions") + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Boundary") ) { - let output = - ::init( - helper, event, - )?; - return self.handle_actions(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"Clips") + helper.read_attrib(&mut boundary, b"Boundary", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Name") ) { - let output = - ::init( - helper, event, - )?; - return self.handle_clips(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"FillColor") + helper.read_attrib(&mut name, b"Name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Visible") ) { - let output = - ::init(helper, event)?; - return self.handle_fill_color(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"StrokeColor") + helper.read_attrib(&mut visible, b"Visible", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"CTM") ) { - let output = - ::init(helper, event)?; - return self.handle_stroke_color(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"CGTransform") + helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DrawParam") ) { - let output = - ::init(helper, event)?; - return self.handle_cg_transform(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_UNNAMED_5), - Some(b"TextCode") + helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"LineWidth") ) { - let output = ::init( - helper, event, - )?; - return self.handle_text_code(helper, Default::default(), None, output); + helper.read_attrib(&mut line_width, b"LineWidth", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Cap") + ) { + helper.read_attrib(&mut cap, b"Cap", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Join") + ) { + helper.read_attrib(&mut join, b"Join", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"MiterLimit") + ) { + helper.read_attrib(&mut miter_limit, b"MiterLimit", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DashOffset") + ) { + helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"DashPattern") + ) { + helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Alpha") + ) { + helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"ResourceID") + ) { + helper.read_attrib(&mut resource_id, b"ResourceID", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"Substitution") + ) { + helper.read_attrib(&mut substitution, b"Substitution", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"ImageMask") + ) { + helper.read_attrib(&mut image_mask, b"ImageMask", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), + Some(b"ID") + ) { + helper.read_attrib(&mut id, b"ID", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; } } - *self.state__ = CtPageBlockTextObjectXElementTypeContentDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent(event, false)) - } - fn finish_state( - helper: &mut DeserializeHelper, - state: CtPageBlockTextObjectXElementTypeContentDeserializerState, - ) -> Result { - use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; - match state { - S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Actions(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_actions(&mut values, value)?; - } - Ok(super::CtPageBlockTextObjectXElementTypeContent::Actions( - helper.finish_element("Actions", values)?, - )) - } - S::Clips(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_clips(&mut values, value)?; - } - Ok(super::CtPageBlockTextObjectXElementTypeContent::Clips( - helper.finish_element("Clips", values)?, - )) - } - S::FillColor(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_fill_color(&mut values, value)?; - } - Ok(super::CtPageBlockTextObjectXElementTypeContent::FillColor( - helper.finish_element("FillColor", values)?, - )) - } - S::StrokeColor(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_stroke_color(&mut values, value)?; - } - Ok( - super::CtPageBlockTextObjectXElementTypeContent::StrokeColor( - helper.finish_element("StrokeColor", values)?, - ), - ) + Ok(Self { + boundary: boundary + .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, + name: name, + visible: visible + .unwrap_or_else(super::CtPageBlockImageObjectXElementType::default_visible), + ctm: ctm, + draw_param: draw_param, + line_width: line_width.unwrap_or_else( + super::CtPageBlockImageObjectXElementType::default_line_width, + ), + cap: cap.unwrap_or_else(super::CtPageBlockImageObjectXElementType::default_cap), + join: join + .unwrap_or_else(super::CtPageBlockImageObjectXElementType::default_join), + miter_limit: miter_limit.unwrap_or_else( + super::CtPageBlockImageObjectXElementType::default_miter_limit, + ), + dash_offset: dash_offset.unwrap_or_else( + super::CtPageBlockImageObjectXElementType::default_dash_offset, + ), + dash_pattern: dash_pattern, + alpha: alpha + .unwrap_or_else(super::CtPageBlockImageObjectXElementType::default_alpha), + resource_id: resource_id + .ok_or_else(|| ErrorKind::MissingAttribute("ResourceID".into()))?, + substitution: substitution, + image_mask: image_mask, + id: id.ok_or_else(|| ErrorKind::MissingAttribute("ID".into()))?, + actions: None, + clips: None, + border: None, + state__: Box::new(CtPageBlockImageObjectXElementTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: CtPageBlockImageObjectXElementTypeDeserializerState, + ) -> Result<(), Error> { + use CtPageBlockImageObjectXElementTypeDeserializerState as S; + match state { + S::Actions(Some(deserializer)) => { + self.store_actions(deserializer.finish(helper)?)? } - S::CgTransform(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_cg_transform(&mut values, value)?; - } - Ok( - super::CtPageBlockTextObjectXElementTypeContent::CgTransform( - helper.finish_element("CGTransform", values)?, - ), - ) + S::Clips(Some(deserializer)) => { + self.store_clips(deserializer.finish(helper)?)? } - S::TextCode(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_text_code(&mut values, value)?; - } - Ok(super::CtPageBlockTextObjectXElementTypeContent::TextCode( - helper.finish_element("TextCode", values)?, - )) + S::Border(Some(deserializer)) => { + self.store_border(deserializer.finish(helper)?)? } - S::Done__(data) => Ok(data), - _ => unreachable!(), + _ => (), } + Ok(()) } fn store_actions( - values: &mut Option, + &mut self, value: super::CtGraphicUnitActionsXElementType, ) -> Result<(), Error> { - if values.is_some() { + if self.actions.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( b"Actions", )))?; } - *values = Some(value); + self.actions = Some(value); Ok(()) } fn store_clips( - values: &mut Option, + &mut self, value: super::CtGraphicUnitClipsXElementType, ) -> Result<(), Error> { - if values.is_some() { + if self.clips.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( b"Clips", )))?; } - *values = Some(value); - Ok(()) - } - fn store_fill_color( - values: &mut Option, - value: super::CtColorXType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"FillColor", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_stroke_color( - values: &mut Option, - value: super::CtColorXType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"StrokeColor", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_cg_transform( - values: &mut Option, - value: super::CtCgTransformXType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"CGTransform", - )))?; - } - *values = Some(value); + self.clips = Some(value); Ok(()) } - fn store_text_code( - values: &mut Option, - value: super::CtTextTextCodeXElementType, + fn store_border( + &mut self, + value: super::CtImageBorderXElementType, ) -> Result<(), Error> { - if values.is_some() { + if self.border.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"TextCode", + b"Border", )))?; } - *values = Some(value); + self.border = Some(value); Ok(()) } fn handle_actions<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option< - ::Deserializer, - >, output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, + fallback: &mut Option, ) -> Result, Error> { - use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; + use CtPageBlockImageObjectXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + *self.state__ = S::Clips(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_actions(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_actions(&mut values, data)?; - let data = Self::finish_state(helper, S::Actions(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_actions(data)?; + *self.state__ = S::Clips(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Actions(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + fallback.get_or_insert(S::Actions(Some(deserializer))); + *self.state__ = S::Clips(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } fn handle_clips<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option< - ::Deserializer, - >, output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, + fallback: &mut Option, ) -> Result, Error> { - use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_clips(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_clips(&mut values, data)?; - let data = Self::finish_state(helper, S::Clips(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Clips(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_fill_color<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::CtColorXType>, - ) -> Result, Error> { - use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_fill_color(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_fill_color(&mut values, data)?; - let data = Self::finish_state(helper, S::FillColor(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::FillColor(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_stroke_color<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::CtColorXType>, - ) -> Result, Error> { - use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_stroke_color(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_stroke_color(&mut values, data)?; - let data = Self::finish_state(helper, S::StrokeColor(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::StrokeColor(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_cg_transform<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::CtCgTransformXType>, - ) -> Result, Error> { - use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; + use CtPageBlockImageObjectXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + *self.state__ = S::Border(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_cg_transform(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_cg_transform(&mut values, data)?; - let data = Self::finish_state(helper, S::CgTransform(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_clips(data)?; + *self.state__ = S::Border(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::CgTransform(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + fallback.get_or_insert(S::Clips(Some(deserializer))); + *self.state__ = S::Border(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } - fn handle_text_code<'de>( + fn handle_border<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option< - ::Deserializer, - >, - output: DeserializerOutput<'de, super::CtTextTextCodeXElementType>, + output: DeserializerOutput<'de, super::CtImageBorderXElementType>, + fallback: &mut Option, ) -> Result, Error> { - use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; + use CtPageBlockImageObjectXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_text_code(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_text_code(&mut values, data)?; - let data = Self::finish_state(helper, S::TextCode(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_border(data)?; + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::TextCode(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + fallback.get_or_insert(S::Border(Some(deserializer))); + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtPageBlockTextObjectXElementTypeContent> - for CtPageBlockTextObjectXElementTypeContentDeserializer + impl<'de> Deserializer<'de, super::CtPageBlockImageObjectXElementType> + for CtPageBlockImageObjectXElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockTextObjectXElementTypeContent> - { - let deserializer = Self { - state__: Box::new( - CtPageBlockTextObjectXElementTypeContentDeserializerState::Init__, - ), - }; - let mut output = deserializer.next(helper, event)?; - output.artifact = match output.artifact { - DeserializerArtifact::Deserializer(x) - if matches!( - &*x.state__, - CtPageBlockTextObjectXElementTypeContentDeserializerState::Init__ - ) => - { - DeserializerArtifact::None - } - artifact => artifact, - }; - Ok(output) + ) -> DeserializerResult<'de, super::CtPageBlockImageObjectXElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockTextObjectXElementTypeContent> - { - use CtPageBlockTextObjectXElementTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::CtPageBlockImageObjectXElementType> { + use CtPageBlockImageObjectXElementTypeDeserializerState as S; let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Actions(values, fallback, Some(deserializer)), event) => { + (S::Actions(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_actions(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + match self.handle_actions(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Clips(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_clips(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (S::FillColor(values, fallback, Some(deserializer)), event) => { + (S::Clips(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_fill_color(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + match self.handle_clips(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::StrokeColor(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_stroke_color(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (S::CgTransform(values, fallback, Some(deserializer)), event) => { + (S::Border(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_cg_transform(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + match self.handle_border(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::TextCode(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_text_code(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (state, event @ Event::End(_)) => { + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(Self::finish_state( - helper, state, - )?), - event: DeserializerEvent::Continue(event), + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, allow_any: false, }); } - (S::Init__, event) => match self.find_suitable(helper, event)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - }, - ( - S::Actions(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Actions(None); + event + } + (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), b"Actions", true, )?; - match self.handle_actions(helper, values, fallback, output)? { + match self.handle_actions(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - ( - S::Clips(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { + (S::Clips(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), b"Clips", true, )?; - match self.handle_clips(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + match self.handle_clips(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::FillColor(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"FillColor", - true, - )?; - match self.handle_fill_color(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - ( - S::StrokeColor(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { + (S::Border(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"StrokeColor", + b"Border", true, )?; - match self.handle_stroke_color(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::CgTransform(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"CGTransform", - false, - )?; - match self.handle_cg_transform(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + match self.handle_border(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::TextCode(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"TextCode", - false, - )?; - match self.handle_text_code(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (state @ S::Done__(_), event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); } (state, event) => { *self.state__ = state; - break (DeserializerEvent::Continue(event), false); - } - } - }; - let artifact = if matches!(&*self.state__, S::Done__(_)) { - DeserializerArtifact::Data(self.finish(helper)?) - } else { - DeserializerArtifact::Deserializer(self) + break (DeserializerEvent::Break(event), false); + } + } }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } Ok(DeserializerOutput { - artifact, + artifact: DeserializerArtifact::Deserializer(self), event, allow_any, }) } fn finish( - self, + mut self, helper: &mut DeserializeHelper, - ) -> Result { - Self::finish_state(helper, *self.state__) + ) -> Result { + let state = replace( + &mut *self.state__, + CtPageBlockImageObjectXElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::CtPageBlockImageObjectXElementType { + boundary: self.boundary, + name: self.name, + visible: self.visible, + ctm: self.ctm, + draw_param: self.draw_param, + line_width: self.line_width, + cap: self.cap, + join: self.join, + miter_limit: self.miter_limit, + dash_offset: self.dash_offset, + dash_pattern: self.dash_pattern, + alpha: self.alpha, + resource_id: self.resource_id, + substitution: self.substitution, + image_mask: self.image_mask, + id: self.id, + actions: self.actions, + clips: self.clips, + border: self.border, + }) } } #[derive(Debug)] - pub struct CtPageBlockPathObjectXElementTypeDeserializer { + pub struct CtPageBlockCompositeObjectXElementTypeDeserializer { boundary: String, name: Option, visible: bool, @@ -33427,19 +35048,14 @@ pub mod page { dash_offset: f64, dash_pattern: Option, alpha: i32, - stroke: bool, - fill: bool, - rule: super::CtPathRuleXType, + resource_id: u32, id: u32, actions: Option, clips: Option, - stroke_color: Option, - fill_color: Option, - abbreviated_data: Option, - state__: Box, + state__: Box, } #[derive(Debug)] - enum CtPageBlockPathObjectXElementTypeDeserializerState { + enum CtPageBlockCompositeObjectXElementTypeDeserializerState { Init__, Actions( Option<::Deserializer>, @@ -33447,13 +35063,10 @@ pub mod page { Clips( Option<::Deserializer>, ), - StrokeColor(Option<::Deserializer>), - FillColor(Option<::Deserializer>), - AbbreviatedData(Option<::Deserializer>), Done__, Unknown__, } - impl CtPageBlockPathObjectXElementTypeDeserializer { + impl CtPageBlockCompositeObjectXElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -33470,9 +35083,7 @@ pub mod page { let mut dash_offset: Option = None; let mut dash_pattern: Option = None; let mut alpha: Option = None; - let mut stroke: Option = None; - let mut fill: Option = None; - let mut rule: Option = None; + let mut resource_id: Option = None; let mut id: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; @@ -33538,19 +35149,9 @@ pub mod page { helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Stroke") - ) { - helper.read_attrib(&mut stroke, b"Stroke", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Fill") - ) { - helper.read_attrib(&mut fill, b"Fill", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Rule") + Some(b"ResourceID") ) { - helper.read_attrib(&mut rule, b"Rule", &attrib.value)?; + helper.read_attrib(&mut resource_id, b"ResourceID", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), Some(b"ID") @@ -33564,46 +35165,45 @@ pub mod page { boundary: boundary .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, name: name, - visible: visible - .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_visible), + visible: visible.unwrap_or_else( + super::CtPageBlockCompositeObjectXElementType::default_visible, + ), ctm: ctm, draw_param: draw_param, line_width: line_width.unwrap_or_else( - super::CtPageBlockPathObjectXElementType::default_line_width, + super::CtPageBlockCompositeObjectXElementType::default_line_width, + ), + cap: cap + .unwrap_or_else(super::CtPageBlockCompositeObjectXElementType::default_cap), + join: join.unwrap_or_else( + super::CtPageBlockCompositeObjectXElementType::default_join, ), - cap: cap.unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_cap), - join: join - .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_join), miter_limit: miter_limit.unwrap_or_else( - super::CtPageBlockPathObjectXElementType::default_miter_limit, + super::CtPageBlockCompositeObjectXElementType::default_miter_limit, ), dash_offset: dash_offset.unwrap_or_else( - super::CtPageBlockPathObjectXElementType::default_dash_offset, + super::CtPageBlockCompositeObjectXElementType::default_dash_offset, ), dash_pattern: dash_pattern, - alpha: alpha - .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_alpha), - stroke: stroke - .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_stroke), - fill: fill - .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_fill), - rule: rule - .unwrap_or_else(super::CtPageBlockPathObjectXElementType::default_rule), + alpha: alpha.unwrap_or_else( + super::CtPageBlockCompositeObjectXElementType::default_alpha, + ), + resource_id: resource_id + .ok_or_else(|| ErrorKind::MissingAttribute("ResourceID".into()))?, id: id.ok_or_else(|| ErrorKind::MissingAttribute("ID".into()))?, actions: None, clips: None, - stroke_color: None, - fill_color: None, - abbreviated_data: None, - state__: Box::new(CtPageBlockPathObjectXElementTypeDeserializerState::Init__), + state__: Box::new( + CtPageBlockCompositeObjectXElementTypeDeserializerState::Init__, + ), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: CtPageBlockPathObjectXElementTypeDeserializerState, + state: CtPageBlockCompositeObjectXElementTypeDeserializerState, ) -> Result<(), Error> { - use CtPageBlockPathObjectXElementTypeDeserializerState as S; + use CtPageBlockCompositeObjectXElementTypeDeserializerState as S; match state { S::Actions(Some(deserializer)) => { self.store_actions(deserializer.finish(helper)?)? @@ -33611,15 +35211,6 @@ pub mod page { S::Clips(Some(deserializer)) => { self.store_clips(deserializer.finish(helper)?)? } - S::StrokeColor(Some(deserializer)) => { - self.store_stroke_color(deserializer.finish(helper)?)? - } - S::FillColor(Some(deserializer)) => { - self.store_fill_color(deserializer.finish(helper)?)? - } - S::AbbreviatedData(Some(deserializer)) => { - self.store_abbreviated_data(deserializer.finish(helper)?)? - } _ => (), } Ok(()) @@ -33648,40 +35239,13 @@ pub mod page { self.clips = Some(value); Ok(()) } - fn store_stroke_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { - if self.stroke_color.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"StrokeColor", - )))?; - } - self.stroke_color = Some(value); - Ok(()) - } - fn store_fill_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { - if self.fill_color.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"FillColor", - )))?; - } - self.fill_color = Some(value); - Ok(()) - } - fn store_abbreviated_data(&mut self, value: String) -> Result<(), Error> { - if self.abbreviated_data.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"AbbreviatedData", - )))?; - } - self.abbreviated_data = Some(value); - Ok(()) - } fn handle_actions<'de>( &mut self, helper: &mut DeserializeHelper, output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, - fallback: &mut Option, + fallback: &mut Option, ) -> Result, Error> { - use CtPageBlockPathObjectXElementTypeDeserializerState as S; + use CtPageBlockCompositeObjectXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -33697,135 +35261,32 @@ pub mod page { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_actions(data)?; - *self.state__ = S::Clips(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Actions(Some(deserializer))); - *self.state__ = S::Clips(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - fn handle_clips<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtPageBlockPathObjectXElementTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::StrokeColor(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_clips(data)?; - *self.state__ = S::StrokeColor(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Clips(Some(deserializer))); - *self.state__ = S::StrokeColor(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - fn handle_stroke_color<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtColorXType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtPageBlockPathObjectXElementTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::FillColor(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_stroke_color(data)?; - *self.state__ = S::FillColor(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::StrokeColor(Some(deserializer))); - *self.state__ = S::FillColor(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - fn handle_fill_color<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtColorXType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtPageBlockPathObjectXElementTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::AbbreviatedData(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_fill_color(data)?; - *self.state__ = S::AbbreviatedData(None); + self.store_actions(data)?; + *self.state__ = S::Clips(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::FillColor(Some(deserializer))); - *self.state__ = S::AbbreviatedData(None); + fallback.get_or_insert(S::Actions(Some(deserializer))); + *self.state__ = S::Clips(None); Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } - fn handle_abbreviated_data<'de>( + fn handle_clips<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, String>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, + fallback: &mut Option, ) -> Result, Error> { - use CtPageBlockPathObjectXElementTypeDeserializerState as S; + use CtPageBlockCompositeObjectXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - fallback.get_or_insert(S::AbbreviatedData(None)); - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } else { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; @@ -33833,33 +35294,35 @@ pub mod page { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_abbreviated_data(data)?; + self.store_clips(data)?; *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::AbbreviatedData(Some(deserializer))); + fallback.get_or_insert(S::Clips(Some(deserializer))); *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtPageBlockPathObjectXElementType> - for CtPageBlockPathObjectXElementTypeDeserializer + impl<'de> Deserializer<'de, super::CtPageBlockCompositeObjectXElementType> + for CtPageBlockCompositeObjectXElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockPathObjectXElementType> { + ) -> DeserializerResult<'de, super::CtPageBlockCompositeObjectXElementType> + { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockPathObjectXElementType> { - use CtPageBlockPathObjectXElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtPageBlockCompositeObjectXElementType> + { + use CtPageBlockCompositeObjectXElementTypeDeserializerState as S; let mut event = event; let mut fallback = None; let mut allow_any_element = false; @@ -33891,42 +35354,6 @@ pub mod page { } } } - (S::StrokeColor(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_stroke_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::FillColor(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_fill_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::AbbreviatedData(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_abbreviated_data(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } (_, Event::End(_)) => { if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; @@ -33976,57 +35403,6 @@ pub mod page { } } } - (S::StrokeColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"StrokeColor", - true, - )?; - match self.handle_stroke_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::FillColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"FillColor", - true, - )?; - match self.handle_fill_color(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::AbbreviatedData(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"AbbreviatedData", - false, - )?; - match self.handle_abbreviated_data(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } (S::Done__, event) => { *self.state__ = S::Done__; break (DeserializerEvent::Continue(event), allow_any_element); @@ -34049,13 +35425,13 @@ pub mod page { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - CtPageBlockPathObjectXElementTypeDeserializerState::Unknown__, + CtPageBlockCompositeObjectXElementTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::CtPageBlockPathObjectXElementType { + Ok(super::CtPageBlockCompositeObjectXElementType { boundary: self.boundary, name: self.name, visible: self.visible, @@ -34068,325 +35444,125 @@ pub mod page { dash_offset: self.dash_offset, dash_pattern: self.dash_pattern, alpha: self.alpha, - stroke: self.stroke, - fill: self.fill, - rule: self.rule, + resource_id: self.resource_id, id: self.id, actions: self.actions, clips: self.clips, - stroke_color: self.stroke_color, - fill_color: self.fill_color, - abbreviated_data: helper - .finish_element("AbbreviatedData", self.abbreviated_data)?, }) } } #[derive(Debug)] - pub struct CtPageBlockImageObjectXElementTypeDeserializer { - boundary: String, - name: Option, - visible: bool, - ctm: Option, - draw_param: Option, + pub struct CtImageBorderXElementTypeDeserializer { line_width: f64, - cap: super::CtGraphicUnitCapXType, - join: super::CtGraphicUnitJoinXType, - miter_limit: f64, + horizonal_corner_radius: f64, + vertical_corner_radius: f64, dash_offset: f64, dash_pattern: Option, - alpha: i32, - resource_id: u32, - substitution: Option, - image_mask: Option, - id: u32, - actions: Option, - clips: Option, - border: Option, - state__: Box, + border_color: Option, + state__: Box, } #[derive(Debug)] - enum CtPageBlockImageObjectXElementTypeDeserializerState { + enum CtImageBorderXElementTypeDeserializerState { Init__, - Actions( - Option<::Deserializer>, - ), - Clips( - Option<::Deserializer>, - ), - Border(Option<::Deserializer>), + BorderColor(Option<::Deserializer>), Done__, Unknown__, } - impl CtPageBlockImageObjectXElementTypeDeserializer { + impl CtImageBorderXElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut boundary: Option = None; - let mut name: Option = None; - let mut visible: Option = None; - let mut ctm: Option = None; - let mut draw_param: Option = None; let mut line_width: Option = None; - let mut cap: Option = None; - let mut join: Option = None; - let mut miter_limit: Option = None; + let mut horizonal_corner_radius: Option = None; + let mut vertical_corner_radius: Option = None; let mut dash_offset: Option = None; let mut dash_pattern: Option = None; - let mut alpha: Option = None; - let mut resource_id: Option = None; - let mut substitution: Option = None; - let mut image_mask: Option = None; - let mut id: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Boundary") - ) { - helper.read_attrib(&mut boundary, b"Boundary", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Name") - ) { - helper.read_attrib(&mut name, b"Name", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Visible") - ) { - helper.read_attrib(&mut visible, b"Visible", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"CTM") - ) { - helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DrawParam") - ) { - helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; - } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), Some(b"LineWidth") ) { helper.read_attrib(&mut line_width, b"LineWidth", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Cap") - ) { - helper.read_attrib(&mut cap, b"Cap", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Join") - ) { - helper.read_attrib(&mut join, b"Join", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"MiterLimit") - ) { - helper.read_attrib(&mut miter_limit, b"MiterLimit", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashOffset") - ) { - helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashPattern") - ) { - helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Alpha") - ) { - helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"ResourceID") + Some(b"HorizonalCornerRadius") ) { - helper.read_attrib(&mut resource_id, b"ResourceID", &attrib.value)?; + helper.read_attrib( + &mut horizonal_corner_radius, + b"HorizonalCornerRadius", + &attrib.value, + )?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Substitution") + Some(b"VerticalCornerRadius") ) { - helper.read_attrib(&mut substitution, b"Substitution", &attrib.value)?; + helper.read_attrib( + &mut vertical_corner_radius, + b"VerticalCornerRadius", + &attrib.value, + )?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"ImageMask") + Some(b"DashOffset") ) { - helper.read_attrib(&mut image_mask, b"ImageMask", &attrib.value)?; + helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"ID") + Some(b"DashPattern") ) { - helper.read_attrib(&mut id, b"ID", &attrib.value)?; + helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - boundary: boundary - .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, - name: name, - visible: visible - .unwrap_or_else(super::CtPageBlockImageObjectXElementType::default_visible), - ctm: ctm, - draw_param: draw_param, - line_width: line_width.unwrap_or_else( - super::CtPageBlockImageObjectXElementType::default_line_width, - ), - cap: cap.unwrap_or_else(super::CtPageBlockImageObjectXElementType::default_cap), - join: join - .unwrap_or_else(super::CtPageBlockImageObjectXElementType::default_join), - miter_limit: miter_limit.unwrap_or_else( - super::CtPageBlockImageObjectXElementType::default_miter_limit, + line_width: line_width + .unwrap_or_else(super::CtImageBorderXElementType::default_line_width), + horizonal_corner_radius: horizonal_corner_radius.unwrap_or_else( + super::CtImageBorderXElementType::default_horizonal_corner_radius, ), - dash_offset: dash_offset.unwrap_or_else( - super::CtPageBlockImageObjectXElementType::default_dash_offset, + vertical_corner_radius: vertical_corner_radius.unwrap_or_else( + super::CtImageBorderXElementType::default_vertical_corner_radius, ), + dash_offset: dash_offset + .unwrap_or_else(super::CtImageBorderXElementType::default_dash_offset), dash_pattern: dash_pattern, - alpha: alpha - .unwrap_or_else(super::CtPageBlockImageObjectXElementType::default_alpha), - resource_id: resource_id - .ok_or_else(|| ErrorKind::MissingAttribute("ResourceID".into()))?, - substitution: substitution, - image_mask: image_mask, - id: id.ok_or_else(|| ErrorKind::MissingAttribute("ID".into()))?, - actions: None, - clips: None, - border: None, - state__: Box::new(CtPageBlockImageObjectXElementTypeDeserializerState::Init__), + border_color: None, + state__: Box::new(CtImageBorderXElementTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: CtPageBlockImageObjectXElementTypeDeserializerState, + state: CtImageBorderXElementTypeDeserializerState, ) -> Result<(), Error> { - use CtPageBlockImageObjectXElementTypeDeserializerState as S; + use CtImageBorderXElementTypeDeserializerState as S; match state { - S::Actions(Some(deserializer)) => { - self.store_actions(deserializer.finish(helper)?)? - } - S::Clips(Some(deserializer)) => { - self.store_clips(deserializer.finish(helper)?)? - } - S::Border(Some(deserializer)) => { - self.store_border(deserializer.finish(helper)?)? + S::BorderColor(Some(deserializer)) => { + self.store_border_color(deserializer.finish(helper)?)? } _ => (), } Ok(()) } - fn store_actions( - &mut self, - value: super::CtGraphicUnitActionsXElementType, - ) -> Result<(), Error> { - if self.actions.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Actions", - )))?; - } - self.actions = Some(value); - Ok(()) - } - fn store_clips( - &mut self, - value: super::CtGraphicUnitClipsXElementType, - ) -> Result<(), Error> { - if self.clips.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Clips", - )))?; - } - self.clips = Some(value); - Ok(()) - } - fn store_border( - &mut self, - value: super::CtImageBorderXElementType, - ) -> Result<(), Error> { - if self.border.is_some() { + fn store_border_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { + if self.border_color.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Border", + b"BorderColor", )))?; } - self.border = Some(value); + self.border_color = Some(value); Ok(()) } - fn handle_actions<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtPageBlockImageObjectXElementTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::Clips(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_actions(data)?; - *self.state__ = S::Clips(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Actions(Some(deserializer))); - *self.state__ = S::Clips(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - fn handle_clips<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtPageBlockImageObjectXElementTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::Border(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_clips(data)?; - *self.state__ = S::Border(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Clips(Some(deserializer))); - *self.state__ = S::Border(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - fn handle_border<'de>( + fn handle_border_color<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtImageBorderXElementType>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::CtColorXType>, + fallback: &mut Option, ) -> Result, Error> { - use CtPageBlockImageObjectXElementTypeDeserializerState as S; + use CtImageBorderXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -34402,33 +35578,33 @@ pub mod page { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_border(data)?; + self.store_border_color(data)?; *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Border(Some(deserializer))); + fallback.get_or_insert(S::BorderColor(Some(deserializer))); *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtPageBlockImageObjectXElementType> - for CtPageBlockImageObjectXElementTypeDeserializer + impl<'de> Deserializer<'de, super::CtImageBorderXElementType> + for CtImageBorderXElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockImageObjectXElementType> { + ) -> DeserializerResult<'de, super::CtImageBorderXElementType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockImageObjectXElementType> { - use CtPageBlockImageObjectXElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtImageBorderXElementType> { + use CtImageBorderXElementTypeDeserializerState as S; let mut event = event; let mut fallback = None; let mut allow_any_element = false; @@ -34436,33 +35612,9 @@ pub mod page { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Actions(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_actions(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Clips(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_clips(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Border(Some(deserializer)), event) => { + (S::BorderColor(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_border(helper, output, &mut fallback)? { + match self.handle_border_color(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -34484,51 +35636,17 @@ pub mod page { } (S::Init__, event) => { fallback.get_or_insert(S::Init__); - *self.state__ = S::Actions(None); + *self.state__ = S::BorderColor(None); event } - (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Actions", - true, - )?; - match self.handle_actions(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Clips(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Clips", - true, - )?; - match self.handle_clips(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Border(None), event @ (Event::Start(_) | Event::Empty(_))) => { + (S::BorderColor(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Border", + b"BorderColor", true, )?; - match self.handle_border(helper, output, &mut fallback)? { + match self.handle_border_color(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -34560,288 +35678,108 @@ pub mod page { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - CtPageBlockImageObjectXElementTypeDeserializerState::Unknown__, + CtImageBorderXElementTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::CtPageBlockImageObjectXElementType { - boundary: self.boundary, - name: self.name, - visible: self.visible, - ctm: self.ctm, - draw_param: self.draw_param, + Ok(super::CtImageBorderXElementType { line_width: self.line_width, - cap: self.cap, - join: self.join, - miter_limit: self.miter_limit, + horizonal_corner_radius: self.horizonal_corner_radius, + vertical_corner_radius: self.vertical_corner_radius, dash_offset: self.dash_offset, dash_pattern: self.dash_pattern, - alpha: self.alpha, - resource_id: self.resource_id, - substitution: self.substitution, - image_mask: self.image_mask, - id: self.id, - actions: self.actions, - clips: self.clips, - border: self.border, + border_color: self.border_color, }) } } #[derive(Debug)] - pub struct CtPageBlockCompositeObjectXElementTypeDeserializer { - boundary: String, - name: Option, - visible: bool, - ctm: Option, - draw_param: Option, - line_width: f64, - cap: super::CtGraphicUnitCapXType, - join: super::CtGraphicUnitJoinXType, - miter_limit: f64, - dash_offset: f64, - dash_pattern: Option, - alpha: i32, - resource_id: u32, - id: u32, - actions: Option, - clips: Option, - state__: Box, + pub struct CtLaGouraudShdPointXElementTypeDeserializer { + x: Option, + y: Option, + color: Option, + state__: Box, } #[derive(Debug)] - enum CtPageBlockCompositeObjectXElementTypeDeserializerState { + enum CtLaGouraudShdPointXElementTypeDeserializerState { Init__, - Actions( - Option<::Deserializer>, - ), - Clips( - Option<::Deserializer>, - ), + Color(Option<::Deserializer>), Done__, Unknown__, } - impl CtPageBlockCompositeObjectXElementTypeDeserializer { + impl CtLaGouraudShdPointXElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { - let mut boundary: Option = None; - let mut name: Option = None; - let mut visible: Option = None; - let mut ctm: Option = None; - let mut draw_param: Option = None; - let mut line_width: Option = None; - let mut cap: Option = None; - let mut join: Option = None; - let mut miter_limit: Option = None; - let mut dash_offset: Option = None; - let mut dash_pattern: Option = None; - let mut alpha: Option = None; - let mut resource_id: Option = None; - let mut id: Option = None; + let mut x: Option = None; + let mut y: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Boundary") - ) { - helper.read_attrib(&mut boundary, b"Boundary", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Name") - ) { - helper.read_attrib(&mut name, b"Name", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Visible") - ) { - helper.read_attrib(&mut visible, b"Visible", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"CTM") - ) { - helper.read_attrib(&mut ctm, b"CTM", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DrawParam") - ) { - helper.read_attrib(&mut draw_param, b"DrawParam", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"LineWidth") - ) { - helper.read_attrib(&mut line_width, b"LineWidth", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Cap") - ) { - helper.read_attrib(&mut cap, b"Cap", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Join") - ) { - helper.read_attrib(&mut join, b"Join", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"MiterLimit") - ) { - helper.read_attrib(&mut miter_limit, b"MiterLimit", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashOffset") - ) { - helper.read_attrib(&mut dash_offset, b"DashOffset", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"DashPattern") - ) { - helper.read_attrib(&mut dash_pattern, b"DashPattern", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"Alpha") - ) { - helper.read_attrib(&mut alpha, b"Alpha", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"ResourceID") + Some(b"X") ) { - helper.read_attrib(&mut resource_id, b"ResourceID", &attrib.value)?; + helper.read_attrib(&mut x, b"X", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_UNNAMED_5), - Some(b"ID") + Some(b"y") ) { - helper.read_attrib(&mut id, b"ID", &attrib.value)?; + helper.read_attrib(&mut y, b"y", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } - Ok(Self { - boundary: boundary - .ok_or_else(|| ErrorKind::MissingAttribute("Boundary".into()))?, - name: name, - visible: visible.unwrap_or_else( - super::CtPageBlockCompositeObjectXElementType::default_visible, - ), - ctm: ctm, - draw_param: draw_param, - line_width: line_width.unwrap_or_else( - super::CtPageBlockCompositeObjectXElementType::default_line_width, - ), - cap: cap - .unwrap_or_else(super::CtPageBlockCompositeObjectXElementType::default_cap), - join: join.unwrap_or_else( - super::CtPageBlockCompositeObjectXElementType::default_join, - ), - miter_limit: miter_limit.unwrap_or_else( - super::CtPageBlockCompositeObjectXElementType::default_miter_limit, - ), - dash_offset: dash_offset.unwrap_or_else( - super::CtPageBlockCompositeObjectXElementType::default_dash_offset, - ), - dash_pattern: dash_pattern, - alpha: alpha.unwrap_or_else( - super::CtPageBlockCompositeObjectXElementType::default_alpha, - ), - resource_id: resource_id - .ok_or_else(|| ErrorKind::MissingAttribute("ResourceID".into()))?, - id: id.ok_or_else(|| ErrorKind::MissingAttribute("ID".into()))?, - actions: None, - clips: None, - state__: Box::new( - CtPageBlockCompositeObjectXElementTypeDeserializerState::Init__, - ), - }) - } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: CtPageBlockCompositeObjectXElementTypeDeserializerState, - ) -> Result<(), Error> { - use CtPageBlockCompositeObjectXElementTypeDeserializerState as S; - match state { - S::Actions(Some(deserializer)) => { - self.store_actions(deserializer.finish(helper)?)? - } - S::Clips(Some(deserializer)) => { - self.store_clips(deserializer.finish(helper)?)? - } - _ => (), - } - Ok(()) - } - fn store_actions( - &mut self, - value: super::CtGraphicUnitActionsXElementType, - ) -> Result<(), Error> { - if self.actions.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Actions", - )))?; - } - self.actions = Some(value); - Ok(()) - } - fn store_clips( - &mut self, - value: super::CtGraphicUnitClipsXElementType, - ) -> Result<(), Error> { - if self.clips.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"Clips", - )))?; - } - self.clips = Some(value); - Ok(()) - } - fn handle_actions<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitActionsXElementType>, - fallback: &mut Option, - ) -> Result, Error> { - use CtPageBlockCompositeObjectXElementTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::Clips(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_actions(data)?; - *self.state__ = S::Clips(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Actions(Some(deserializer))); - *self.state__ = S::Clips(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } + Ok(Self { + x: x, + y: y, + color: None, + state__: Box::new(CtLaGouraudShdPointXElementTypeDeserializerState::Init__), + }) } - fn handle_clips<'de>( + fn finish_state( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::CtGraphicUnitClipsXElementType>, - fallback: &mut Option, + state: CtLaGouraudShdPointXElementTypeDeserializerState, + ) -> Result<(), Error> { + use CtLaGouraudShdPointXElementTypeDeserializerState as S; + match state { + S::Color(Some(deserializer)) => { + self.store_color(deserializer.finish(helper)?)? + } + _ => (), + } + Ok(()) + } + fn store_color(&mut self, value: super::CtColorXType) -> Result<(), Error> { + if self.color.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"Color", + )))?; + } + self.color = Some(value); + Ok(()) + } + fn handle_color<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::CtColorXType>, + fallback: &mut Option, ) -> Result, Error> { - use CtPageBlockCompositeObjectXElementTypeDeserializerState as S; + use CtLaGouraudShdPointXElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + fallback.get_or_insert(S::Color(None)); + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } else { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } } if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; @@ -34849,35 +35787,33 @@ pub mod page { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_clips(data)?; + self.store_color(data)?; *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Clips(Some(deserializer))); + fallback.get_or_insert(S::Color(Some(deserializer))); *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::CtPageBlockCompositeObjectXElementType> - for CtPageBlockCompositeObjectXElementTypeDeserializer + impl<'de> Deserializer<'de, super::CtLaGouraudShdPointXElementType> + for CtLaGouraudShdPointXElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockCompositeObjectXElementType> - { + ) -> DeserializerResult<'de, super::CtLaGouraudShdPointXElementType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::CtPageBlockCompositeObjectXElementType> - { - use CtPageBlockCompositeObjectXElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::CtLaGouraudShdPointXElementType> { + use CtLaGouraudShdPointXElementTypeDeserializerState as S; let mut event = event; let mut fallback = None; let mut allow_any_element = false; @@ -34885,21 +35821,9 @@ pub mod page { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Actions(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_actions(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Clips(Some(deserializer)), event) => { + (S::Color(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_clips(helper, output, &mut fallback)? { + match self.handle_color(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -34921,34 +35845,17 @@ pub mod page { } (S::Init__, event) => { fallback.get_or_insert(S::Init__); - *self.state__ = S::Actions(None); + *self.state__ = S::Color(None); event } - (S::Actions(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_UNNAMED_5), - b"Actions", - true, - )?; - match self.handle_actions(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Clips(None), event @ (Event::Start(_) | Event::Empty(_))) => { + (S::Color(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_UNNAMED_5), - b"Clips", + b"Color", true, )?; - match self.handle_clips(helper, output, &mut fallback)? { + match self.handle_color(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -34980,29 +35887,16 @@ pub mod page { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - CtPageBlockCompositeObjectXElementTypeDeserializerState::Unknown__, + CtLaGouraudShdPointXElementTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::CtPageBlockCompositeObjectXElementType { - boundary: self.boundary, - name: self.name, - visible: self.visible, - ctm: self.ctm, - draw_param: self.draw_param, - line_width: self.line_width, - cap: self.cap, - join: self.join, - miter_limit: self.miter_limit, - dash_offset: self.dash_offset, - dash_pattern: self.dash_pattern, - alpha: self.alpha, - resource_id: self.resource_id, - id: self.id, - actions: self.actions, - clips: self.clips, + Ok(super::CtLaGouraudShdPointXElementType { + x: self.x, + y: self.y, + color: Box::new(helper.finish_element("Color", self.color)?), }) } } @@ -37707,7 +38601,7 @@ pub mod page { pub mod quick_xml_serialize { use xsd_parser_types::quick_xml::{ BytesEnd, BytesStart, Error, Event, IterSerializer, SerializeHelper, Serializer, - WithSerializer, + WithSerializer, XsiTypeSerializer, }; #[derive(Debug)] pub struct CtAxialShdXTypeSerializer<'ser> { @@ -38284,58 +39178,264 @@ pub mod page { helper.write_attrib_opt(&mut bytes, "Extend", &self.value.extend)?; return Ok(Some(Event::Start(bytes))); } - CtGouraudShdXTypeSerializerState::Point(x) => { + CtGouraudShdXTypeSerializerState::Point(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => { + *self.state = CtGouraudShdXTypeSerializerState::BackColor( + IterSerializer::new( + self.value.back_color.as_deref(), + Some("BackColor"), + false, + ), + ) + } + } + } + CtGouraudShdXTypeSerializerState::BackColor(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = CtGouraudShdXTypeSerializerState::End__, + } + } + CtGouraudShdXTypeSerializerState::End__ => { + *self.state = CtGouraudShdXTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); + } + CtGouraudShdXTypeSerializerState::Done__ => return Ok(None), + CtGouraudShdXTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for CtGouraudShdXTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = CtGouraudShdXTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct CtGraphicUnitXTypeSerializer<'ser> { + pub(super) value: &'ser super::CtGraphicUnitXType, + pub(super) state: Box>, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum CtGraphicUnitXTypeSerializerState<'ser> { + Init__, + CtText( + XsiTypeSerializer<'ser, ::Serializer<'ser>>, + ), + CtPageBlockTextObject( + ::Serializer<'ser>, + ), + CtPath( + XsiTypeSerializer<'ser, ::Serializer<'ser>>, + ), + CtPageBlockPathObject( + ::Serializer<'ser>, + ), + CtImage( + XsiTypeSerializer<'ser, ::Serializer<'ser>>, + ), + CtPageBlockImageObject( + ::Serializer<'ser>, + ), + CtComposite( + XsiTypeSerializer< + 'ser, + ::Serializer<'ser>, + >, + ), + CtPageBlockCompositeObject( + ::Serializer<'ser>, + ), + Done__, + Phantom__(&'ser ()), + } + impl<'ser> CtGraphicUnitXTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + CtGraphicUnitXTypeSerializerState::Init__ => match self.value { + super::CtGraphicUnitXType::CtText(x) => { + *self.state = CtGraphicUnitXTypeSerializerState::CtText( + XsiTypeSerializer::new( + WithSerializer::serializer( + x, + Some("CT_Text"), + self.is_root, + )?, + "CT_GraphicUnit", + self.is_root, + ), + ) + } + super::CtGraphicUnitXType::CtPageBlockTextObject(x) => { + *self.state = + CtGraphicUnitXTypeSerializerState::CtPageBlockTextObject( + WithSerializer::serializer( + x, + Some("CtPageBlockTextObject"), + self.is_root, + )?, + ) + } + super::CtGraphicUnitXType::CtPath(x) => { + *self.state = CtGraphicUnitXTypeSerializerState::CtPath( + XsiTypeSerializer::new( + WithSerializer::serializer( + x, + Some("CT_Path"), + self.is_root, + )?, + "CT_GraphicUnit", + self.is_root, + ), + ) + } + super::CtGraphicUnitXType::CtPageBlockPathObject(x) => { + *self.state = + CtGraphicUnitXTypeSerializerState::CtPageBlockPathObject( + WithSerializer::serializer( + x, + Some("CtPageBlockPathObject"), + self.is_root, + )?, + ) + } + super::CtGraphicUnitXType::CtImage(x) => { + *self.state = CtGraphicUnitXTypeSerializerState::CtImage( + XsiTypeSerializer::new( + WithSerializer::serializer( + x, + Some("CT_Image"), + self.is_root, + )?, + "CT_GraphicUnit", + self.is_root, + ), + ) + } + super::CtGraphicUnitXType::CtPageBlockImageObject(x) => { + *self.state = + CtGraphicUnitXTypeSerializerState::CtPageBlockImageObject( + WithSerializer::serializer( + x, + Some("CtPageBlockImageObject"), + self.is_root, + )?, + ) + } + super::CtGraphicUnitXType::CtComposite(x) => { + *self.state = CtGraphicUnitXTypeSerializerState::CtComposite( + XsiTypeSerializer::new( + WithSerializer::serializer( + x, + Some("CT_Composite"), + self.is_root, + )?, + "CT_GraphicUnit", + self.is_root, + ), + ) + } + super::CtGraphicUnitXType::CtPageBlockCompositeObject(x) => { + *self.state = + CtGraphicUnitXTypeSerializerState::CtPageBlockCompositeObject( + WithSerializer::serializer( + x, + Some("CtPageBlockCompositeObject"), + self.is_root, + )?, + ) + } + }, + CtGraphicUnitXTypeSerializerState::CtText(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = CtGraphicUnitXTypeSerializerState::Done__, + } + } + CtGraphicUnitXTypeSerializerState::CtPageBlockTextObject(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => { - *self.state = CtGouraudShdXTypeSerializerState::BackColor( - IterSerializer::new( - self.value.back_color.as_deref(), - Some("BackColor"), - false, - ), - ) - } + None => *self.state = CtGraphicUnitXTypeSerializerState::Done__, } } - CtGouraudShdXTypeSerializerState::BackColor(x) => { + CtGraphicUnitXTypeSerializerState::CtPath(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = CtGouraudShdXTypeSerializerState::End__, + None => *self.state = CtGraphicUnitXTypeSerializerState::Done__, } } - CtGouraudShdXTypeSerializerState::End__ => { - *self.state = CtGouraudShdXTypeSerializerState::Done__; - helper.end_ns_scope(); - return Ok(Some(Event::End(BytesEnd::new(self.name)))); + CtGraphicUnitXTypeSerializerState::CtPageBlockPathObject(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = CtGraphicUnitXTypeSerializerState::Done__, + } } - CtGouraudShdXTypeSerializerState::Done__ => return Ok(None), - CtGouraudShdXTypeSerializerState::Phantom__(_) => unreachable!(), + CtGraphicUnitXTypeSerializerState::CtImage(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = CtGraphicUnitXTypeSerializerState::Done__, + } + } + CtGraphicUnitXTypeSerializerState::CtPageBlockImageObject(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = CtGraphicUnitXTypeSerializerState::Done__, + } + } + CtGraphicUnitXTypeSerializerState::CtComposite(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = CtGraphicUnitXTypeSerializerState::Done__, + } + } + CtGraphicUnitXTypeSerializerState::CtPageBlockCompositeObject(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = CtGraphicUnitXTypeSerializerState::Done__, + } + } + CtGraphicUnitXTypeSerializerState::Done__ => return Ok(None), + CtGraphicUnitXTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for CtGouraudShdXTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for CtGraphicUnitXTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = CtGouraudShdXTypeSerializerState::Done__; + *self.state = CtGraphicUnitXTypeSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct CtGraphicUnitXTypeSerializer<'ser> { - pub(super) value: &'ser super::CtGraphicUnitXType, - pub(super) state: Box>, + pub struct CtGraphicUnitDynSerializer<'ser> { + pub(super) value: &'ser super::CtGraphicUnitDyn, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum CtGraphicUnitXTypeSerializerState<'ser> { + pub(super) enum CtGraphicUnitDynSerializerState<'ser> { Init__, Actions( IterSerializer< @@ -38355,16 +39455,16 @@ pub mod page { Done__, Phantom__(&'ser ()), } - impl<'ser> CtGraphicUnitXTypeSerializer<'ser> { + impl<'ser> CtGraphicUnitDynSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - CtGraphicUnitXTypeSerializerState::Init__ => { + CtGraphicUnitDynSerializerState::Init__ => { *self.state = - CtGraphicUnitXTypeSerializerState::Actions(IterSerializer::new( + CtGraphicUnitDynSerializerState::Actions(IterSerializer::new( self.value.actions.as_ref(), Some("Actions"), false, @@ -38406,44 +39506,43 @@ pub mod page { helper.write_attrib(&mut bytes, "Alpha", &self.value.alpha)?; return Ok(Some(Event::Start(bytes))); } - CtGraphicUnitXTypeSerializerState::Actions(x) => { + CtGraphicUnitDynSerializerState::Actions(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => { - *self.state = CtGraphicUnitXTypeSerializerState::Clips( - IterSerializer::new( + *self.state = + CtGraphicUnitDynSerializerState::Clips(IterSerializer::new( self.value.clips.as_ref(), Some("Clips"), false, - ), - ) + )) } } } - CtGraphicUnitXTypeSerializerState::Clips(x) => { + CtGraphicUnitDynSerializerState::Clips(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = CtGraphicUnitXTypeSerializerState::End__, + None => *self.state = CtGraphicUnitDynSerializerState::End__, } } - CtGraphicUnitXTypeSerializerState::End__ => { - *self.state = CtGraphicUnitXTypeSerializerState::Done__; + CtGraphicUnitDynSerializerState::End__ => { + *self.state = CtGraphicUnitDynSerializerState::Done__; helper.end_ns_scope(); return Ok(Some(Event::End(BytesEnd::new(self.name)))); } - CtGraphicUnitXTypeSerializerState::Done__ => return Ok(None), - CtGraphicUnitXTypeSerializerState::Phantom__(_) => unreachable!(), + CtGraphicUnitDynSerializerState::Done__ => return Ok(None), + CtGraphicUnitDynSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for CtGraphicUnitXTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for CtGraphicUnitDynSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = CtGraphicUnitXTypeSerializerState::Done__; + *self.state = CtGraphicUnitDynSerializerState::Done__; Some(Err(error)) } } @@ -40097,256 +41196,84 @@ pub mod page { Done__, Phantom__(&'ser ()), } - impl<'ser> CtGraphicUnitClipsXElementTypeSerializer<'ser> { - fn next_event( - &mut self, - helper: &mut SerializeHelper, - ) -> Result>, Error> { - loop { - match &mut *self.state { - CtGraphicUnitClipsXElementTypeSerializerState::Init__ => { - *self.state = CtGraphicUnitClipsXElementTypeSerializerState::Clip( - IterSerializer::new(&self.value.clip[..], Some("Clip"), false), - ); - let mut bytes = BytesStart::new(self.name); - helper.begin_ns_scope(); - helper.write_xmlns_for_tag( - &mut bytes, - self.name, - &super::super::NS_UNNAMED_5, - ); - return Ok(Some(Event::Start(bytes))); - } - CtGraphicUnitClipsXElementTypeSerializerState::Clip(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => { - *self.state = - CtGraphicUnitClipsXElementTypeSerializerState::End__ - } - } - } - CtGraphicUnitClipsXElementTypeSerializerState::End__ => { - *self.state = CtGraphicUnitClipsXElementTypeSerializerState::Done__; - helper.end_ns_scope(); - return Ok(Some(Event::End(BytesEnd::new(self.name)))); - } - CtGraphicUnitClipsXElementTypeSerializerState::Done__ => return Ok(None), - CtGraphicUnitClipsXElementTypeSerializerState::Phantom__(_) => { - unreachable!() - } - } - } - } - } - impl<'ser> Serializer<'ser> for CtGraphicUnitClipsXElementTypeSerializer<'ser> { - fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { - match self.next_event(helper) { - Ok(Some(event)) => Some(Ok(event)), - Ok(None) => None, - Err(error) => { - *self.state = CtGraphicUnitClipsXElementTypeSerializerState::Done__; - Some(Err(error)) - } - } - } - } - #[derive(Debug)] - pub struct CtGouraudShdPointXElementTypeSerializer<'ser> { - pub(super) value: &'ser super::CtGouraudShdPointXElementType, - pub(super) state: Box>, - pub(super) name: &'ser str, - pub(super) is_root: bool, - } - #[derive(Debug)] - pub(super) enum CtGouraudShdPointXElementTypeSerializerState<'ser> { - Init__, - Color(::Serializer<'ser>), - End__, - Done__, - Phantom__(&'ser ()), - } - impl<'ser> CtGouraudShdPointXElementTypeSerializer<'ser> { - fn next_event( - &mut self, - helper: &mut SerializeHelper, - ) -> Result>, Error> { - loop { - match &mut *self.state { - CtGouraudShdPointXElementTypeSerializerState::Init__ => { - *self.state = CtGouraudShdPointXElementTypeSerializerState::Color( - WithSerializer::serializer( - &*self.value.color, - Some("Color"), - false, - )?, - ); - let mut bytes = BytesStart::new(self.name); - helper.begin_ns_scope(); - helper.write_xmlns_for_tag( - &mut bytes, - self.name, - &super::super::NS_UNNAMED_5, - ); - helper.write_attrib(&mut bytes, "X", &self.value.x)?; - helper.write_attrib(&mut bytes, "y", &self.value.y)?; - helper.write_attrib_opt( - &mut bytes, - "EdgeFlag", - &self.value.edge_flag, - )?; - return Ok(Some(Event::Start(bytes))); - } - CtGouraudShdPointXElementTypeSerializerState::Color(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => { - *self.state = - CtGouraudShdPointXElementTypeSerializerState::End__ - } - } - } - CtGouraudShdPointXElementTypeSerializerState::End__ => { - *self.state = CtGouraudShdPointXElementTypeSerializerState::Done__; - helper.end_ns_scope(); - return Ok(Some(Event::End(BytesEnd::new(self.name)))); - } - CtGouraudShdPointXElementTypeSerializerState::Done__ => return Ok(None), - CtGouraudShdPointXElementTypeSerializerState::Phantom__(_) => { - unreachable!() - } - } - } - } - } - impl<'ser> Serializer<'ser> for CtGouraudShdPointXElementTypeSerializer<'ser> { - fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { - match self.next_event(helper) { - Ok(Some(event)) => Some(Ok(event)), - Ok(None) => None, - Err(error) => { - *self.state = CtGouraudShdPointXElementTypeSerializerState::Done__; - Some(Err(error)) - } - } - } - } - #[derive(Debug)] - pub struct CtImageBorderXElementTypeSerializer<'ser> { - pub(super) value: &'ser super::CtImageBorderXElementType, - pub(super) state: Box>, - pub(super) name: &'ser str, - pub(super) is_root: bool, - } - #[derive(Debug)] - pub(super) enum CtImageBorderXElementTypeSerializerState<'ser> { - Init__, - BorderColor( - IterSerializer<'ser, Option<&'ser super::CtColorXType>, super::CtColorXType>, - ), - End__, - Done__, - Phantom__(&'ser ()), - } - impl<'ser> CtImageBorderXElementTypeSerializer<'ser> { - fn next_event( - &mut self, - helper: &mut SerializeHelper, - ) -> Result>, Error> { - loop { - match &mut *self.state { - CtImageBorderXElementTypeSerializerState::Init__ => { - *self.state = CtImageBorderXElementTypeSerializerState::BorderColor( - IterSerializer::new( - self.value.border_color.as_ref(), - Some("BorderColor"), - false, - ), - ); - let mut bytes = BytesStart::new(self.name); - helper.begin_ns_scope(); - helper.write_xmlns_for_tag( - &mut bytes, - self.name, - &super::super::NS_UNNAMED_5, - ); - helper.write_attrib(&mut bytes, "LineWidth", &self.value.line_width)?; - helper.write_attrib( - &mut bytes, - "HorizonalCornerRadius", - &self.value.horizonal_corner_radius, - )?; - helper.write_attrib( - &mut bytes, - "VerticalCornerRadius", - &self.value.vertical_corner_radius, - )?; - helper.write_attrib( - &mut bytes, - "DashOffset", - &self.value.dash_offset, - )?; - helper.write_attrib_opt( + impl<'ser> CtGraphicUnitClipsXElementTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + CtGraphicUnitClipsXElementTypeSerializerState::Init__ => { + *self.state = CtGraphicUnitClipsXElementTypeSerializerState::Clip( + IterSerializer::new(&self.value.clip[..], Some("Clip"), false), + ); + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + helper.write_xmlns_for_tag( &mut bytes, - "DashPattern", - &self.value.dash_pattern, - )?; + self.name, + &super::super::NS_UNNAMED_5, + ); return Ok(Some(Event::Start(bytes))); } - CtImageBorderXElementTypeSerializerState::BorderColor(x) => match x - .next(helper) - .transpose()? - { - Some(event) => return Ok(Some(event)), - None => *self.state = CtImageBorderXElementTypeSerializerState::End__, - }, - CtImageBorderXElementTypeSerializerState::End__ => { - *self.state = CtImageBorderXElementTypeSerializerState::Done__; + CtGraphicUnitClipsXElementTypeSerializerState::Clip(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => { + *self.state = + CtGraphicUnitClipsXElementTypeSerializerState::End__ + } + } + } + CtGraphicUnitClipsXElementTypeSerializerState::End__ => { + *self.state = CtGraphicUnitClipsXElementTypeSerializerState::Done__; helper.end_ns_scope(); return Ok(Some(Event::End(BytesEnd::new(self.name)))); } - CtImageBorderXElementTypeSerializerState::Done__ => return Ok(None), - CtImageBorderXElementTypeSerializerState::Phantom__(_) => unreachable!(), + CtGraphicUnitClipsXElementTypeSerializerState::Done__ => return Ok(None), + CtGraphicUnitClipsXElementTypeSerializerState::Phantom__(_) => { + unreachable!() + } } } } } - impl<'ser> Serializer<'ser> for CtImageBorderXElementTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for CtGraphicUnitClipsXElementTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = CtImageBorderXElementTypeSerializerState::Done__; + *self.state = CtGraphicUnitClipsXElementTypeSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct CtLaGouraudShdPointXElementTypeSerializer<'ser> { - pub(super) value: &'ser super::CtLaGouraudShdPointXElementType, - pub(super) state: Box>, + pub struct CtGouraudShdPointXElementTypeSerializer<'ser> { + pub(super) value: &'ser super::CtGouraudShdPointXElementType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum CtLaGouraudShdPointXElementTypeSerializerState<'ser> { + pub(super) enum CtGouraudShdPointXElementTypeSerializerState<'ser> { Init__, Color(::Serializer<'ser>), End__, Done__, Phantom__(&'ser ()), } - impl<'ser> CtLaGouraudShdPointXElementTypeSerializer<'ser> { + impl<'ser> CtGouraudShdPointXElementTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - CtLaGouraudShdPointXElementTypeSerializerState::Init__ => { - *self.state = CtLaGouraudShdPointXElementTypeSerializerState::Color( + CtGouraudShdPointXElementTypeSerializerState::Init__ => { + *self.state = CtGouraudShdPointXElementTypeSerializerState::Color( WithSerializer::serializer( &*self.value.color, Some("Color"), @@ -40360,39 +41287,44 @@ pub mod page { self.name, &super::super::NS_UNNAMED_5, ); - helper.write_attrib_opt(&mut bytes, "X", &self.value.x)?; - helper.write_attrib_opt(&mut bytes, "y", &self.value.y)?; + helper.write_attrib(&mut bytes, "X", &self.value.x)?; + helper.write_attrib(&mut bytes, "y", &self.value.y)?; + helper.write_attrib_opt( + &mut bytes, + "EdgeFlag", + &self.value.edge_flag, + )?; return Ok(Some(Event::Start(bytes))); } - CtLaGouraudShdPointXElementTypeSerializerState::Color(x) => { + CtGouraudShdPointXElementTypeSerializerState::Color(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => { *self.state = - CtLaGouraudShdPointXElementTypeSerializerState::End__ + CtGouraudShdPointXElementTypeSerializerState::End__ } } } - CtLaGouraudShdPointXElementTypeSerializerState::End__ => { - *self.state = CtLaGouraudShdPointXElementTypeSerializerState::Done__; + CtGouraudShdPointXElementTypeSerializerState::End__ => { + *self.state = CtGouraudShdPointXElementTypeSerializerState::Done__; helper.end_ns_scope(); return Ok(Some(Event::End(BytesEnd::new(self.name)))); } - CtLaGouraudShdPointXElementTypeSerializerState::Done__ => return Ok(None), - CtLaGouraudShdPointXElementTypeSerializerState::Phantom__(_) => { + CtGouraudShdPointXElementTypeSerializerState::Done__ => return Ok(None), + CtGouraudShdPointXElementTypeSerializerState::Phantom__(_) => { unreachable!() } } } } } - impl<'ser> Serializer<'ser> for CtLaGouraudShdPointXElementTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for CtGouraudShdPointXElementTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = CtLaGouraudShdPointXElementTypeSerializerState::Done__; + *self.state = CtGouraudShdPointXElementTypeSerializerState::Done__; Some(Err(error)) } } @@ -41054,6 +41986,173 @@ pub mod page { } } #[derive(Debug)] + pub struct CtImageBorderXElementTypeSerializer<'ser> { + pub(super) value: &'ser super::CtImageBorderXElementType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum CtImageBorderXElementTypeSerializerState<'ser> { + Init__, + BorderColor( + IterSerializer<'ser, Option<&'ser super::CtColorXType>, super::CtColorXType>, + ), + End__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> CtImageBorderXElementTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + CtImageBorderXElementTypeSerializerState::Init__ => { + *self.state = CtImageBorderXElementTypeSerializerState::BorderColor( + IterSerializer::new( + self.value.border_color.as_ref(), + Some("BorderColor"), + false, + ), + ); + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + helper.write_xmlns_for_tag( + &mut bytes, + self.name, + &super::super::NS_UNNAMED_5, + ); + helper.write_attrib(&mut bytes, "LineWidth", &self.value.line_width)?; + helper.write_attrib( + &mut bytes, + "HorizonalCornerRadius", + &self.value.horizonal_corner_radius, + )?; + helper.write_attrib( + &mut bytes, + "VerticalCornerRadius", + &self.value.vertical_corner_radius, + )?; + helper.write_attrib( + &mut bytes, + "DashOffset", + &self.value.dash_offset, + )?; + helper.write_attrib_opt( + &mut bytes, + "DashPattern", + &self.value.dash_pattern, + )?; + return Ok(Some(Event::Start(bytes))); + } + CtImageBorderXElementTypeSerializerState::BorderColor(x) => match x + .next(helper) + .transpose()? + { + Some(event) => return Ok(Some(event)), + None => *self.state = CtImageBorderXElementTypeSerializerState::End__, + }, + CtImageBorderXElementTypeSerializerState::End__ => { + *self.state = CtImageBorderXElementTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); + } + CtImageBorderXElementTypeSerializerState::Done__ => return Ok(None), + CtImageBorderXElementTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for CtImageBorderXElementTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = CtImageBorderXElementTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct CtLaGouraudShdPointXElementTypeSerializer<'ser> { + pub(super) value: &'ser super::CtLaGouraudShdPointXElementType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum CtLaGouraudShdPointXElementTypeSerializerState<'ser> { + Init__, + Color(::Serializer<'ser>), + End__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> CtLaGouraudShdPointXElementTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + CtLaGouraudShdPointXElementTypeSerializerState::Init__ => { + *self.state = CtLaGouraudShdPointXElementTypeSerializerState::Color( + WithSerializer::serializer( + &*self.value.color, + Some("Color"), + false, + )?, + ); + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + helper.write_xmlns_for_tag( + &mut bytes, + self.name, + &super::super::NS_UNNAMED_5, + ); + helper.write_attrib_opt(&mut bytes, "X", &self.value.x)?; + helper.write_attrib_opt(&mut bytes, "y", &self.value.y)?; + return Ok(Some(Event::Start(bytes))); + } + CtLaGouraudShdPointXElementTypeSerializerState::Color(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => { + *self.state = + CtLaGouraudShdPointXElementTypeSerializerState::End__ + } + } + } + CtLaGouraudShdPointXElementTypeSerializerState::End__ => { + *self.state = CtLaGouraudShdPointXElementTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); + } + CtLaGouraudShdPointXElementTypeSerializerState::Done__ => return Ok(None), + CtLaGouraudShdPointXElementTypeSerializerState::Phantom__(_) => { + unreachable!() + } + } + } + } + } + impl<'ser> Serializer<'ser> for CtLaGouraudShdPointXElementTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = CtLaGouraudShdPointXElementTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] pub struct CtPageBlockPageBlockXElementTypeSerializer<'ser> { pub(super) value: &'ser super::CtPageBlockPageBlockXElementType, pub(super) state: Box>, diff --git a/xsd-parser/tests/schema/onix/expected/default.rs b/xsd-parser/tests/schema/onix/expected/default.rs index 27b31d60..57748bfd 100644 --- a/xsd-parser/tests/schema/onix/expected/default.rs +++ b/xsd-parser/tests/schema/onix/expected/default.rs @@ -2,7 +2,7 @@ pub mod onix { use core::ops::Deref; use xsd_parser_types::{ quick_xml::ValidateError, - xml::{Mixed, Text}, + xml::{AnyElement, Mixed, Text}, }; ///Root element – the top level container within an ONIX message ///● Added NoProduct> at revision 3.0.2 @@ -8524,6 +8524,11 @@ pub mod onix { } #[derive(Debug)] pub enum BlockElement { + Heading(AnyElement), + Lists(AnyElement), + Blocktext(AnyElement), + Div(DdElementType), + P(AbbrElementType), H1(AbbrElementType), H2(AbbrElementType), H3(AbbrElementType), @@ -8537,18 +8542,18 @@ pub mod onix { Hr(HrElementType), Pre(PreElementType), Blockquote(BlockquoteElementType), - Div(DdElementType), - P(AbbrElementType), Table(TableElementType), } #[derive(Debug)] pub enum InlineElement { + Special(AnyElement), + Fontstyle(AnyElement), + Phrase(AnyElement), + Gloss(AnyElement), + A(AElementType), Span(AbbrElementType), Bdo(BdoElementType), Br(BrElementType), - Img(ImgElementType), - Map(MapElementType), - Fontstyle(FontstyleElement), Em(AbbrElementType), Strong(AbbrElementType), Dfn(AbbrElementType), @@ -8562,13 +8567,13 @@ pub mod onix { Q(QElementType), Sub(AbbrElementType), Sup(AbbrElementType), - Gloss(GlossElement), - A(AElementType), Tt(AbbrElementType), I(AbbrElementType), B(AbbrElementType), Big(AbbrElementType), Small(AbbrElementType), + Img(ImgElementType), + Map(MapElementType), Ruby(RubyElementType), } #[derive(Debug)] @@ -14096,6 +14101,22 @@ pub mod onix { B220, } #[derive(Debug)] + pub struct DdElementType { + pub id: Option, + pub class: Option, + pub style: Option, + pub title: Option, + pub lang: Option, + pub dir: Option, + pub content: Vec, + } + #[derive(Debug)] + pub enum DdElementTypeContent { + Block(BlockElement), + Inline(InlineElement), + Text(Text), + } + #[derive(Debug)] pub struct AbbrElementType { pub id: Option, pub class: Option, @@ -14188,22 +14209,6 @@ pub mod onix { pub block: Vec, } #[derive(Debug)] - pub struct DdElementType { - pub id: Option, - pub class: Option, - pub style: Option, - pub title: Option, - pub lang: Option, - pub dir: Option, - pub content: Vec, - } - #[derive(Debug)] - pub enum DdElementTypeContent { - Block(BlockElement), - Inline(InlineElement), - Text(Text), - } - #[derive(Debug)] pub struct TableElementType { pub id: Option, pub class: Option, @@ -14225,6 +14230,37 @@ pub mod onix { pub content_49: TableContent49, } #[derive(Debug)] + pub struct AElementType { + pub id: Option, + pub class: Option, + pub style: Option, + pub title: Option, + pub lang: Option, + pub dir: Option, + pub charset: Option, + pub type_: Option, + pub name: Option, + pub href: Option, + pub hreflang: Option, + pub rel: Option, + pub rev: Option, + pub accesskey: Option, + pub shape: Shape, + pub coords: Option, + pub tabindex: Option, + pub onfocus: Option, + pub onblur: Option, + pub content: Vec, + } + #[derive(Debug)] + pub enum AElementTypeContent { + Special(SpecialElement), + Fontstyle(FontstyleElement), + Phrase(PhraseElement), + Gloss(GlossElement), + Text(Text), + } + #[derive(Debug)] pub struct BdoElementType { pub id: Option, pub class: Option, @@ -14243,6 +14279,18 @@ pub mod onix { pub title: Option, } #[derive(Debug)] + pub struct QElementType { + pub id: Option, + pub class: Option, + pub style: Option, + pub title: Option, + pub lang: Option, + pub dir: Option, + pub cite: Option, + pub text_before: Option, + pub inline: Vec>, + } + #[derive(Debug)] pub struct ImgElementType { pub id: Option, pub class: Option, @@ -14275,61 +14323,6 @@ pub mod onix { Area(AreaElementType), } #[derive(Debug)] - pub enum FontstyleElement { - Tt(Box), - I(Box), - B(Box), - Big(Box), - Small(Box), - } - #[derive(Debug)] - pub struct QElementType { - pub id: Option, - pub class: Option, - pub style: Option, - pub title: Option, - pub lang: Option, - pub dir: Option, - pub cite: Option, - pub text_before: Option, - pub inline: Vec>, - } - #[derive(Debug)] - pub enum GlossElement { - Ruby(RubyElementType), - } - #[derive(Debug)] - pub struct AElementType { - pub id: Option, - pub class: Option, - pub style: Option, - pub title: Option, - pub lang: Option, - pub dir: Option, - pub charset: Option, - pub type_: Option, - pub name: Option, - pub href: Option, - pub hreflang: Option, - pub rel: Option, - pub rev: Option, - pub accesskey: Option, - pub shape: Shape, - pub coords: Option, - pub tabindex: Option, - pub onfocus: Option, - pub onblur: Option, - pub content: Vec, - } - #[derive(Debug)] - pub enum AElementTypeContent { - Special(SpecialElement), - Fontstyle(FontstyleElement), - Phrase(PhraseElement), - Gloss(GlossElement), - Text(Text), - } - #[derive(Debug)] pub struct RubyElementType { pub id: Option, pub class: Option, @@ -19878,6 +19871,10 @@ pub mod onix { Sup(Box), } #[derive(Debug)] + pub enum GlossElement { + Ruby(RubyElementType), + } + #[derive(Debug)] pub enum TFrame { Void, Above, @@ -19922,6 +19919,29 @@ pub mod onix { Tr(Vec), } #[derive(Debug)] + pub enum Shape { + Rect, + Circle, + Poly, + Default, + } + #[derive(Debug)] + pub enum SpecialElement { + Span(Box), + Bdo(Box), + Br(BrElementType), + Img(ImgElementType), + Map(Box), + } + #[derive(Debug)] + pub enum FontstyleElement { + Tt(Box), + I(Box), + B(Box), + Big(Box), + Small(Box), + } + #[derive(Debug)] pub enum Ismap { Ismap, } @@ -19940,21 +19960,6 @@ pub mod onix { pub alt: String, } #[derive(Debug)] - pub enum Shape { - Rect, - Circle, - Poly, - Default, - } - #[derive(Debug)] - pub enum SpecialElement { - Span(Box), - Bdo(Box), - Br(BrElementType), - Img(ImgElementType), - Map(Box), - } - #[derive(Debug)] pub struct RubyContent59 { pub rb: RbElementType, pub content_60: RubyContent60, diff --git a/xsd-parser/tests/schema/onix/expected/quick_xml.rs b/xsd-parser/tests/schema/onix/expected/quick_xml.rs index b689e09f..ebd5faa8 100644 --- a/xsd-parser/tests/schema/onix/expected/quick_xml.rs +++ b/xsd-parser/tests/schema/onix/expected/quick_xml.rs @@ -16,7 +16,7 @@ pub mod onix { SerializeHelper, ValidateError, WithDeserializer, WithDeserializerFromBytes, WithSerializeToBytes, WithSerializer, }, - xml::{Mixed, Text}, + xml::{AnyElement, Mixed, Text}, }; ///Root element – the top level container within an ONIX message ///● Added NoProduct> at revision 3.0.2 @@ -20340,6 +20340,11 @@ pub mod onix { impl WithDeserializerFromBytes for List34 {} #[derive(Debug)] pub enum BlockElement { + Heading(AnyElement), + Lists(AnyElement), + Blocktext(AnyElement), + Div(DdElementType), + P(AbbrElementType), H1(AbbrElementType), H2(AbbrElementType), H3(AbbrElementType), @@ -20353,8 +20358,6 @@ pub mod onix { Hr(HrElementType), Pre(PreElementType), Blockquote(BlockquoteElementType), - Div(DdElementType), - P(AbbrElementType), Table(TableElementType), } impl WithSerializer for BlockElement { @@ -20377,12 +20380,14 @@ pub mod onix { } #[derive(Debug)] pub enum InlineElement { + Special(AnyElement), + Fontstyle(AnyElement), + Phrase(AnyElement), + Gloss(AnyElement), + A(AElementType), Span(AbbrElementType), Bdo(BdoElementType), Br(BrElementType), - Img(ImgElementType), - Map(MapElementType), - Fontstyle(FontstyleElement), Em(AbbrElementType), Strong(AbbrElementType), Dfn(AbbrElementType), @@ -20396,13 +20401,13 @@ pub mod onix { Q(QElementType), Sub(AbbrElementType), Sup(AbbrElementType), - Gloss(GlossElement), - A(AElementType), Tt(AbbrElementType), I(AbbrElementType), B(AbbrElementType), Big(AbbrElementType), Small(AbbrElementType), + Img(ImgElementType), + Map(MapElementType), Ruby(RubyElementType), } impl WithSerializer for InlineElement { @@ -35903,260 +35908,6 @@ pub mod onix { } impl WithDeserializerFromBytes for ExtentUnitShortname {} #[derive(Debug)] - pub struct AbbrElementType { - pub id: Option, - pub class: Option, - pub style: Option, - pub title: Option, - pub lang: Option, - pub dir: Option, - pub text_before: Option, - pub inline: Vec>, - } - impl WithSerializer for AbbrElementType { - type Serializer<'x> = quick_xml_serialize::AbbrElementTypeSerializer<'x>; - fn serializer<'ser>( - &'ser self, - name: Option<&'ser str>, - is_root: bool, - ) -> Result, Error> { - Ok(quick_xml_serialize::AbbrElementTypeSerializer { - value: self, - state: Box::new(quick_xml_serialize::AbbrElementTypeSerializerState::Init__), - name: name.unwrap_or("abbr"), - is_root, - }) - } - } - impl WithDeserializer for AbbrElementType { - type Deserializer = quick_xml_deserialize::AbbrElementTypeDeserializer; - } - #[derive(Debug)] - pub struct UlElementType { - pub id: Option, - pub class: Option, - pub style: Option, - pub title: Option, - pub lang: Option, - pub dir: Option, - pub li: Vec, - } - impl WithSerializer for UlElementType { - type Serializer<'x> = quick_xml_serialize::UlElementTypeSerializer<'x>; - fn serializer<'ser>( - &'ser self, - name: Option<&'ser str>, - is_root: bool, - ) -> Result, Error> { - Ok(quick_xml_serialize::UlElementTypeSerializer { - value: self, - state: Box::new(quick_xml_serialize::UlElementTypeSerializerState::Init__), - name: name.unwrap_or("ul"), - is_root, - }) - } - } - impl WithDeserializer for UlElementType { - type Deserializer = quick_xml_deserialize::UlElementTypeDeserializer; - } - #[derive(Debug)] - pub struct OlElementType { - pub id: Option, - pub class: Option, - pub style: Option, - pub title: Option, - pub lang: Option, - pub dir: Option, - pub type_: Option, - pub start: Option, - pub li: Vec, - } - impl WithSerializer for OlElementType { - type Serializer<'x> = quick_xml_serialize::OlElementTypeSerializer<'x>; - fn serializer<'ser>( - &'ser self, - name: Option<&'ser str>, - is_root: bool, - ) -> Result, Error> { - Ok(quick_xml_serialize::OlElementTypeSerializer { - value: self, - state: Box::new(quick_xml_serialize::OlElementTypeSerializerState::Init__), - name: name.unwrap_or("ol"), - is_root, - }) - } - } - impl WithDeserializer for OlElementType { - type Deserializer = quick_xml_deserialize::OlElementTypeDeserializer; - } - #[derive(Debug)] - pub struct DlElementType { - pub id: Option, - pub class: Option, - pub style: Option, - pub title: Option, - pub lang: Option, - pub dir: Option, - pub content: Vec, - } - #[derive(Debug)] - pub enum DlElementTypeContent { - Dt(AbbrElementType), - Dd(DdElementType), - } - impl WithSerializer for DlElementType { - type Serializer<'x> = quick_xml_serialize::DlElementTypeSerializer<'x>; - fn serializer<'ser>( - &'ser self, - name: Option<&'ser str>, - is_root: bool, - ) -> Result, Error> { - Ok(quick_xml_serialize::DlElementTypeSerializer { - value: self, - state: Box::new(quick_xml_serialize::DlElementTypeSerializerState::Init__), - name: name.unwrap_or("dl"), - is_root, - }) - } - } - impl WithSerializer for DlElementTypeContent { - type Serializer<'x> = quick_xml_serialize::DlElementTypeContentSerializer<'x>; - fn serializer<'ser>( - &'ser self, - name: Option<&'ser str>, - is_root: bool, - ) -> Result, Error> { - let _name = name; - let _is_root = is_root; - Ok(quick_xml_serialize::DlElementTypeContentSerializer { - value: self, - state: Box::new(quick_xml_serialize::DlElementTypeContentSerializerState::Init__), - }) - } - } - impl WithDeserializer for DlElementType { - type Deserializer = quick_xml_deserialize::DlElementTypeDeserializer; - } - impl WithDeserializer for DlElementTypeContent { - type Deserializer = quick_xml_deserialize::DlElementTypeContentDeserializer; - } - #[derive(Debug)] - pub struct HrElementType { - pub id: Option, - pub class: Option, - pub style: Option, - pub title: Option, - pub lang: Option, - pub dir: Option, - } - impl WithSerializer for HrElementType { - type Serializer<'x> = quick_xml_serialize::HrElementTypeSerializer<'x>; - fn serializer<'ser>( - &'ser self, - name: Option<&'ser str>, - is_root: bool, - ) -> Result, Error> { - Ok(quick_xml_serialize::HrElementTypeSerializer { - value: self, - state: Box::new(quick_xml_serialize::HrElementTypeSerializerState::Init__), - name: name.unwrap_or("hr"), - is_root, - }) - } - } - impl WithDeserializer for HrElementType { - type Deserializer = quick_xml_deserialize::HrElementTypeDeserializer; - } - #[derive(Debug)] - pub struct PreElementType { - pub id: Option, - pub class: Option, - pub style: Option, - pub title: Option, - pub lang: Option, - pub dir: Option, - pub content: Vec, - } - #[derive(Debug)] - pub enum PreElementTypeContent { - A(AElementType), - Br(BrElementType), - Span(AbbrElementType), - Bdo(BdoElementType), - Map(MapElementType), - Tt(AbbrElementType), - I(AbbrElementType), - B(AbbrElementType), - Phrase(PhraseElement), - Gloss(GlossElement), - Text(Text), - } - impl WithSerializer for PreElementType { - type Serializer<'x> = quick_xml_serialize::PreElementTypeSerializer<'x>; - fn serializer<'ser>( - &'ser self, - name: Option<&'ser str>, - is_root: bool, - ) -> Result, Error> { - Ok(quick_xml_serialize::PreElementTypeSerializer { - value: self, - state: Box::new(quick_xml_serialize::PreElementTypeSerializerState::Init__), - name: name.unwrap_or("pre"), - is_root, - }) - } - } - impl WithSerializer for PreElementTypeContent { - type Serializer<'x> = quick_xml_serialize::PreElementTypeContentSerializer<'x>; - fn serializer<'ser>( - &'ser self, - name: Option<&'ser str>, - is_root: bool, - ) -> Result, Error> { - let _name = name; - let _is_root = is_root; - Ok(quick_xml_serialize::PreElementTypeContentSerializer { - value: self, - state: Box::new(quick_xml_serialize::PreElementTypeContentSerializerState::Init__), - }) - } - } - impl WithDeserializer for PreElementType { - type Deserializer = quick_xml_deserialize::PreElementTypeDeserializer; - } - impl WithDeserializer for PreElementTypeContent { - type Deserializer = quick_xml_deserialize::PreElementTypeContentDeserializer; - } - #[derive(Debug)] - pub struct BlockquoteElementType { - pub id: Option, - pub class: Option, - pub style: Option, - pub title: Option, - pub lang: Option, - pub dir: Option, - pub cite: Option, - pub block: Vec, - } - impl WithSerializer for BlockquoteElementType { - type Serializer<'x> = quick_xml_serialize::BlockquoteElementTypeSerializer<'x>; - fn serializer<'ser>( - &'ser self, - name: Option<&'ser str>, - is_root: bool, - ) -> Result, Error> { - Ok(quick_xml_serialize::BlockquoteElementTypeSerializer { - value: self, - state: Box::new(quick_xml_serialize::BlockquoteElementTypeSerializerState::Init__), - name: name.unwrap_or("blockquote"), - is_root, - }) - } - } - impl WithDeserializer for BlockquoteElementType { - type Deserializer = quick_xml_deserialize::BlockquoteElementTypeDeserializer; - } - #[derive(Debug)] pub struct DdElementType { pub id: Option, pub class: Option, @@ -36209,212 +35960,232 @@ pub mod onix { type Deserializer = quick_xml_deserialize::DdElementTypeContentDeserializer; } #[derive(Debug)] - pub struct TableElementType { + pub struct AbbrElementType { pub id: Option, pub class: Option, pub style: Option, pub title: Option, pub lang: Option, pub dir: Option, - pub summary: Option, - pub width: Option, - pub border: Option, - pub frame: Option, - pub rules: Option, - pub cellspacing: Option, - pub cellpadding: Option, - pub caption: Option, - pub content_48: Option, - pub thead: Option, - pub tfoot: Option, - pub content_49: TableContent49, + pub text_before: Option, + pub inline: Vec>, } - impl WithSerializer for TableElementType { - type Serializer<'x> = quick_xml_serialize::TableElementTypeSerializer<'x>; + impl WithSerializer for AbbrElementType { + type Serializer<'x> = quick_xml_serialize::AbbrElementTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::TableElementTypeSerializer { + Ok(quick_xml_serialize::AbbrElementTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::TableElementTypeSerializerState::Init__), - name: name.unwrap_or("table"), + state: Box::new(quick_xml_serialize::AbbrElementTypeSerializerState::Init__), + name: name.unwrap_or("abbr"), is_root, }) } } - impl WithDeserializer for TableElementType { - type Deserializer = quick_xml_deserialize::TableElementTypeDeserializer; + impl WithDeserializer for AbbrElementType { + type Deserializer = quick_xml_deserialize::AbbrElementTypeDeserializer; } #[derive(Debug)] - pub struct BdoElementType { + pub struct UlElementType { pub id: Option, pub class: Option, pub style: Option, pub title: Option, pub lang: Option, - pub dir: Dir, - pub text_before: Option, - pub inline: Vec>, + pub dir: Option, + pub li: Vec, } - impl WithSerializer for BdoElementType { - type Serializer<'x> = quick_xml_serialize::BdoElementTypeSerializer<'x>; + impl WithSerializer for UlElementType { + type Serializer<'x> = quick_xml_serialize::UlElementTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::BdoElementTypeSerializer { + Ok(quick_xml_serialize::UlElementTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::BdoElementTypeSerializerState::Init__), - name: name.unwrap_or("bdo"), + state: Box::new(quick_xml_serialize::UlElementTypeSerializerState::Init__), + name: name.unwrap_or("ul"), is_root, }) } } - impl WithDeserializer for BdoElementType { - type Deserializer = quick_xml_deserialize::BdoElementTypeDeserializer; + impl WithDeserializer for UlElementType { + type Deserializer = quick_xml_deserialize::UlElementTypeDeserializer; } #[derive(Debug)] - pub struct BrElementType { + pub struct OlElementType { pub id: Option, pub class: Option, pub style: Option, pub title: Option, + pub lang: Option, + pub dir: Option, + pub type_: Option, + pub start: Option, + pub li: Vec, } - impl WithSerializer for BrElementType { - type Serializer<'x> = quick_xml_serialize::BrElementTypeSerializer<'x>; + impl WithSerializer for OlElementType { + type Serializer<'x> = quick_xml_serialize::OlElementTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::BrElementTypeSerializer { + Ok(quick_xml_serialize::OlElementTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::BrElementTypeSerializerState::Init__), - name: name.unwrap_or("br"), + state: Box::new(quick_xml_serialize::OlElementTypeSerializerState::Init__), + name: name.unwrap_or("ol"), is_root, }) } } - impl WithDeserializer for BrElementType { - type Deserializer = quick_xml_deserialize::BrElementTypeDeserializer; + impl WithDeserializer for OlElementType { + type Deserializer = quick_xml_deserialize::OlElementTypeDeserializer; } #[derive(Debug)] - pub struct ImgElementType { + pub struct DlElementType { pub id: Option, pub class: Option, pub style: Option, pub title: Option, pub lang: Option, pub dir: Option, - pub src: String, - pub alt: String, - pub longdesc: Option, - pub height: Option, - pub width: Option, - pub usemap: Option, - pub ismap: Option, + pub content: Vec, } - impl WithSerializer for ImgElementType { - type Serializer<'x> = quick_xml_serialize::ImgElementTypeSerializer<'x>; + #[derive(Debug)] + pub enum DlElementTypeContent { + Dt(AbbrElementType), + Dd(DdElementType), + } + impl WithSerializer for DlElementType { + type Serializer<'x> = quick_xml_serialize::DlElementTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::ImgElementTypeSerializer { + Ok(quick_xml_serialize::DlElementTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::ImgElementTypeSerializerState::Init__), - name: name.unwrap_or("img"), + state: Box::new(quick_xml_serialize::DlElementTypeSerializerState::Init__), + name: name.unwrap_or("dl"), is_root, }) } } - impl WithDeserializer for ImgElementType { - type Deserializer = quick_xml_deserialize::ImgElementTypeDeserializer; + impl WithSerializer for DlElementTypeContent { + type Serializer<'x> = quick_xml_serialize::DlElementTypeContentSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + let _name = name; + let _is_root = is_root; + Ok(quick_xml_serialize::DlElementTypeContentSerializer { + value: self, + state: Box::new(quick_xml_serialize::DlElementTypeContentSerializerState::Init__), + }) + } + } + impl WithDeserializer for DlElementType { + type Deserializer = quick_xml_deserialize::DlElementTypeDeserializer; + } + impl WithDeserializer for DlElementTypeContent { + type Deserializer = quick_xml_deserialize::DlElementTypeContentDeserializer; } #[derive(Debug)] - pub struct MapElementType { - pub lang: Option, - pub dir: Option, - pub id: String, + pub struct HrElementType { + pub id: Option, pub class: Option, pub style: Option, pub title: Option, - pub name: Option, - pub content: Vec, - } - #[derive(Debug)] - pub enum MapElementTypeContent { - Block(BlockElement), - Area(AreaElementType), + pub lang: Option, + pub dir: Option, } - impl WithSerializer for MapElementType { - type Serializer<'x> = quick_xml_serialize::MapElementTypeSerializer<'x>; + impl WithSerializer for HrElementType { + type Serializer<'x> = quick_xml_serialize::HrElementTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::MapElementTypeSerializer { + Ok(quick_xml_serialize::HrElementTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::MapElementTypeSerializerState::Init__), - name: name.unwrap_or("map"), + state: Box::new(quick_xml_serialize::HrElementTypeSerializerState::Init__), + name: name.unwrap_or("hr"), is_root, }) } } - impl WithSerializer for MapElementTypeContent { - type Serializer<'x> = quick_xml_serialize::MapElementTypeContentSerializer<'x>; + impl WithDeserializer for HrElementType { + type Deserializer = quick_xml_deserialize::HrElementTypeDeserializer; + } + #[derive(Debug)] + pub struct PreElementType { + pub id: Option, + pub class: Option, + pub style: Option, + pub title: Option, + pub lang: Option, + pub dir: Option, + pub content: Vec, + } + #[derive(Debug)] + pub enum PreElementTypeContent { + A(AElementType), + Br(BrElementType), + Span(AbbrElementType), + Bdo(BdoElementType), + Map(MapElementType), + Tt(AbbrElementType), + I(AbbrElementType), + B(AbbrElementType), + Phrase(PhraseElement), + Gloss(GlossElement), + Text(Text), + } + impl WithSerializer for PreElementType { + type Serializer<'x> = quick_xml_serialize::PreElementTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - let _name = name; - let _is_root = is_root; - Ok(quick_xml_serialize::MapElementTypeContentSerializer { + Ok(quick_xml_serialize::PreElementTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::MapElementTypeContentSerializerState::Init__), + state: Box::new(quick_xml_serialize::PreElementTypeSerializerState::Init__), + name: name.unwrap_or("pre"), + is_root, }) } } - impl WithDeserializer for MapElementType { - type Deserializer = quick_xml_deserialize::MapElementTypeDeserializer; - } - impl WithDeserializer for MapElementTypeContent { - type Deserializer = quick_xml_deserialize::MapElementTypeContentDeserializer; - } - #[derive(Debug)] - pub enum FontstyleElement { - Tt(Box), - I(Box), - B(Box), - Big(Box), - Small(Box), - } - impl WithSerializer for FontstyleElement { - type Serializer<'x> = quick_xml_serialize::FontstyleElementSerializer<'x>; + impl WithSerializer for PreElementTypeContent { + type Serializer<'x> = quick_xml_serialize::PreElementTypeContentSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { let _name = name; - Ok(quick_xml_serialize::FontstyleElementSerializer { + let _is_root = is_root; + Ok(quick_xml_serialize::PreElementTypeContentSerializer { value: self, - state: Box::new(quick_xml_serialize::FontstyleElementSerializerState::Init__), - is_root, + state: Box::new(quick_xml_serialize::PreElementTypeContentSerializerState::Init__), }) } } - impl WithDeserializer for FontstyleElement { - type Deserializer = quick_xml_deserialize::FontstyleElementDeserializer; + impl WithDeserializer for PreElementType { + type Deserializer = quick_xml_deserialize::PreElementTypeDeserializer; + } + impl WithDeserializer for PreElementTypeContent { + type Deserializer = quick_xml_deserialize::PreElementTypeContentDeserializer; } #[derive(Debug)] - pub struct QElementType { + pub struct BlockquoteElementType { pub id: Option, pub class: Option, pub style: Option, @@ -36422,48 +36193,64 @@ pub mod onix { pub lang: Option, pub dir: Option, pub cite: Option, - pub text_before: Option, - pub inline: Vec>, + pub block: Vec, } - impl WithSerializer for QElementType { - type Serializer<'x> = quick_xml_serialize::QElementTypeSerializer<'x>; + impl WithSerializer for BlockquoteElementType { + type Serializer<'x> = quick_xml_serialize::BlockquoteElementTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::QElementTypeSerializer { + Ok(quick_xml_serialize::BlockquoteElementTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::QElementTypeSerializerState::Init__), - name: name.unwrap_or("q"), + state: Box::new(quick_xml_serialize::BlockquoteElementTypeSerializerState::Init__), + name: name.unwrap_or("blockquote"), is_root, }) } } - impl WithDeserializer for QElementType { - type Deserializer = quick_xml_deserialize::QElementTypeDeserializer; + impl WithDeserializer for BlockquoteElementType { + type Deserializer = quick_xml_deserialize::BlockquoteElementTypeDeserializer; } #[derive(Debug)] - pub enum GlossElement { - Ruby(RubyElementType), + pub struct TableElementType { + pub id: Option, + pub class: Option, + pub style: Option, + pub title: Option, + pub lang: Option, + pub dir: Option, + pub summary: Option, + pub width: Option, + pub border: Option, + pub frame: Option, + pub rules: Option, + pub cellspacing: Option, + pub cellpadding: Option, + pub caption: Option, + pub content_48: Option, + pub thead: Option, + pub tfoot: Option, + pub content_49: TableContent49, } - impl WithSerializer for GlossElement { - type Serializer<'x> = quick_xml_serialize::GlossElementSerializer<'x>; + impl WithSerializer for TableElementType { + type Serializer<'x> = quick_xml_serialize::TableElementTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - let _name = name; - Ok(quick_xml_serialize::GlossElementSerializer { + Ok(quick_xml_serialize::TableElementTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::GlossElementSerializerState::Init__), + state: Box::new(quick_xml_serialize::TableElementTypeSerializerState::Init__), + name: name.unwrap_or("table"), is_root, }) } } - impl WithDeserializer for GlossElement { - type Deserializer = quick_xml_deserialize::GlossElementDeserializer; + impl WithDeserializer for TableElementType { + type Deserializer = quick_xml_deserialize::TableElementTypeDeserializer; } #[derive(Debug)] pub struct AElementType { @@ -36539,6 +36326,176 @@ pub mod onix { type Deserializer = quick_xml_deserialize::AElementTypeContentDeserializer; } #[derive(Debug)] + pub struct BdoElementType { + pub id: Option, + pub class: Option, + pub style: Option, + pub title: Option, + pub lang: Option, + pub dir: Dir, + pub text_before: Option, + pub inline: Vec>, + } + impl WithSerializer for BdoElementType { + type Serializer<'x> = quick_xml_serialize::BdoElementTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::BdoElementTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::BdoElementTypeSerializerState::Init__), + name: name.unwrap_or("bdo"), + is_root, + }) + } + } + impl WithDeserializer for BdoElementType { + type Deserializer = quick_xml_deserialize::BdoElementTypeDeserializer; + } + #[derive(Debug)] + pub struct BrElementType { + pub id: Option, + pub class: Option, + pub style: Option, + pub title: Option, + } + impl WithSerializer for BrElementType { + type Serializer<'x> = quick_xml_serialize::BrElementTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::BrElementTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::BrElementTypeSerializerState::Init__), + name: name.unwrap_or("br"), + is_root, + }) + } + } + impl WithDeserializer for BrElementType { + type Deserializer = quick_xml_deserialize::BrElementTypeDeserializer; + } + #[derive(Debug)] + pub struct QElementType { + pub id: Option, + pub class: Option, + pub style: Option, + pub title: Option, + pub lang: Option, + pub dir: Option, + pub cite: Option, + pub text_before: Option, + pub inline: Vec>, + } + impl WithSerializer for QElementType { + type Serializer<'x> = quick_xml_serialize::QElementTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::QElementTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::QElementTypeSerializerState::Init__), + name: name.unwrap_or("q"), + is_root, + }) + } + } + impl WithDeserializer for QElementType { + type Deserializer = quick_xml_deserialize::QElementTypeDeserializer; + } + #[derive(Debug)] + pub struct ImgElementType { + pub id: Option, + pub class: Option, + pub style: Option, + pub title: Option, + pub lang: Option, + pub dir: Option, + pub src: String, + pub alt: String, + pub longdesc: Option, + pub height: Option, + pub width: Option, + pub usemap: Option, + pub ismap: Option, + } + impl WithSerializer for ImgElementType { + type Serializer<'x> = quick_xml_serialize::ImgElementTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::ImgElementTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::ImgElementTypeSerializerState::Init__), + name: name.unwrap_or("img"), + is_root, + }) + } + } + impl WithDeserializer for ImgElementType { + type Deserializer = quick_xml_deserialize::ImgElementTypeDeserializer; + } + #[derive(Debug)] + pub struct MapElementType { + pub lang: Option, + pub dir: Option, + pub id: String, + pub class: Option, + pub style: Option, + pub title: Option, + pub name: Option, + pub content: Vec, + } + #[derive(Debug)] + pub enum MapElementTypeContent { + Block(BlockElement), + Area(AreaElementType), + } + impl WithSerializer for MapElementType { + type Serializer<'x> = quick_xml_serialize::MapElementTypeSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + Ok(quick_xml_serialize::MapElementTypeSerializer { + value: self, + state: Box::new(quick_xml_serialize::MapElementTypeSerializerState::Init__), + name: name.unwrap_or("map"), + is_root, + }) + } + } + impl WithSerializer for MapElementTypeContent { + type Serializer<'x> = quick_xml_serialize::MapElementTypeContentSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + let _name = name; + let _is_root = is_root; + Ok(quick_xml_serialize::MapElementTypeContentSerializer { + value: self, + state: Box::new(quick_xml_serialize::MapElementTypeContentSerializerState::Init__), + }) + } + } + impl WithDeserializer for MapElementType { + type Deserializer = quick_xml_deserialize::MapElementTypeDeserializer; + } + impl WithDeserializer for MapElementTypeContent { + type Deserializer = quick_xml_deserialize::MapElementTypeContentDeserializer; + } + #[derive(Debug)] pub struct RubyElementType { pub id: Option, pub class: Option, @@ -53161,6 +53118,28 @@ pub mod onix { type Deserializer = quick_xml_deserialize::PhraseElementDeserializer; } #[derive(Debug)] + pub enum GlossElement { + Ruby(RubyElementType), + } + impl WithSerializer for GlossElement { + type Serializer<'x> = quick_xml_serialize::GlossElementSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + let _name = name; + Ok(quick_xml_serialize::GlossElementSerializer { + value: self, + state: Box::new(quick_xml_serialize::GlossElementSerializerState::Init__), + is_root, + }) + } + } + impl WithDeserializer for GlossElement { + type Deserializer = quick_xml_deserialize::GlossElementDeserializer; + } + #[derive(Debug)] pub enum TFrame { Void, Above, @@ -53327,129 +53306,155 @@ pub mod onix { type Deserializer = quick_xml_deserialize::TableContent49Deserializer; } #[derive(Debug)] - pub enum Ismap { - Ismap, + pub enum Shape { + Rect, + Circle, + Poly, + Default, } - impl SerializeBytes for Ismap { + impl SerializeBytes for Shape { fn serialize_bytes( &self, helper: &mut SerializeHelper, ) -> Result>, Error> { match self { - Self::Ismap => Ok(Some(Cow::Borrowed("ismap"))), + Self::Rect => Ok(Some(Cow::Borrowed("rect"))), + Self::Circle => Ok(Some(Cow::Borrowed("circle"))), + Self::Poly => Ok(Some(Cow::Borrowed("poly"))), + Self::Default => Ok(Some(Cow::Borrowed("default"))), } } } - impl WithSerializeToBytes for Ismap {} - impl DeserializeBytes for Ismap { + impl WithSerializeToBytes for Shape {} + impl DeserializeBytes for Shape { fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result { match bytes { - b"ismap" => Ok(Self::Ismap), + b"rect" => Ok(Self::Rect), + b"circle" => Ok(Self::Circle), + b"poly" => Ok(Self::Poly), + b"default" => Ok(Self::Default), x => Err(Error::from(ErrorKind::UnknownOrInvalidValue( RawByteStr::from_slice(x), ))), } } } - impl WithDeserializerFromBytes for Ismap {} + impl WithDeserializerFromBytes for Shape {} #[derive(Debug)] - pub struct AreaElementType { - pub id: Option, - pub class: Option, - pub style: Option, - pub title: Option, - pub lang: Option, - pub dir: Option, - pub shape: Shape, - pub coords: Option, - pub href: Option, - pub nohref: Option, - pub alt: String, + pub enum SpecialElement { + Span(Box), + Bdo(Box), + Br(BrElementType), + Img(ImgElementType), + Map(Box), } - impl AreaElementType { - #[must_use] - pub fn default_shape() -> Shape { - Shape::Rect + impl WithSerializer for SpecialElement { + type Serializer<'x> = quick_xml_serialize::SpecialElementSerializer<'x>; + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + let _name = name; + Ok(quick_xml_serialize::SpecialElementSerializer { + value: self, + state: Box::new(quick_xml_serialize::SpecialElementSerializerState::Init__), + is_root, + }) } } - impl WithSerializer for AreaElementType { - type Serializer<'x> = quick_xml_serialize::AreaElementTypeSerializer<'x>; + impl WithDeserializer for SpecialElement { + type Deserializer = quick_xml_deserialize::SpecialElementDeserializer; + } + #[derive(Debug)] + pub enum FontstyleElement { + Tt(Box), + I(Box), + B(Box), + Big(Box), + Small(Box), + } + impl WithSerializer for FontstyleElement { + type Serializer<'x> = quick_xml_serialize::FontstyleElementSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - Ok(quick_xml_serialize::AreaElementTypeSerializer { + let _name = name; + Ok(quick_xml_serialize::FontstyleElementSerializer { value: self, - state: Box::new(quick_xml_serialize::AreaElementTypeSerializerState::Init__), - name: name.unwrap_or("area"), + state: Box::new(quick_xml_serialize::FontstyleElementSerializerState::Init__), is_root, }) } } - impl WithDeserializer for AreaElementType { - type Deserializer = quick_xml_deserialize::AreaElementTypeDeserializer; + impl WithDeserializer for FontstyleElement { + type Deserializer = quick_xml_deserialize::FontstyleElementDeserializer; } #[derive(Debug)] - pub enum Shape { - Rect, - Circle, - Poly, - Default, + pub enum Ismap { + Ismap, } - impl SerializeBytes for Shape { + impl SerializeBytes for Ismap { fn serialize_bytes( &self, helper: &mut SerializeHelper, ) -> Result>, Error> { match self { - Self::Rect => Ok(Some(Cow::Borrowed("rect"))), - Self::Circle => Ok(Some(Cow::Borrowed("circle"))), - Self::Poly => Ok(Some(Cow::Borrowed("poly"))), - Self::Default => Ok(Some(Cow::Borrowed("default"))), + Self::Ismap => Ok(Some(Cow::Borrowed("ismap"))), } } } - impl WithSerializeToBytes for Shape {} - impl DeserializeBytes for Shape { + impl WithSerializeToBytes for Ismap {} + impl DeserializeBytes for Ismap { fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result { match bytes { - b"rect" => Ok(Self::Rect), - b"circle" => Ok(Self::Circle), - b"poly" => Ok(Self::Poly), - b"default" => Ok(Self::Default), + b"ismap" => Ok(Self::Ismap), x => Err(Error::from(ErrorKind::UnknownOrInvalidValue( RawByteStr::from_slice(x), ))), } } } - impl WithDeserializerFromBytes for Shape {} + impl WithDeserializerFromBytes for Ismap {} #[derive(Debug)] - pub enum SpecialElement { - Span(Box), - Bdo(Box), - Br(BrElementType), - Img(ImgElementType), - Map(Box), + pub struct AreaElementType { + pub id: Option, + pub class: Option, + pub style: Option, + pub title: Option, + pub lang: Option, + pub dir: Option, + pub shape: Shape, + pub coords: Option, + pub href: Option, + pub nohref: Option, + pub alt: String, } - impl WithSerializer for SpecialElement { - type Serializer<'x> = quick_xml_serialize::SpecialElementSerializer<'x>; + impl AreaElementType { + #[must_use] + pub fn default_shape() -> Shape { + Shape::Rect + } + } + impl WithSerializer for AreaElementType { + type Serializer<'x> = quick_xml_serialize::AreaElementTypeSerializer<'x>; fn serializer<'ser>( &'ser self, name: Option<&'ser str>, is_root: bool, ) -> Result, Error> { - let _name = name; - Ok(quick_xml_serialize::SpecialElementSerializer { + Ok(quick_xml_serialize::AreaElementTypeSerializer { value: self, - state: Box::new(quick_xml_serialize::SpecialElementSerializerState::Init__), + state: Box::new(quick_xml_serialize::AreaElementTypeSerializerState::Init__), + name: name.unwrap_or("area"), is_root, }) } } - impl WithDeserializer for SpecialElement { - type Deserializer = quick_xml_deserialize::SpecialElementDeserializer; + impl WithDeserializer for AreaElementType { + type Deserializer = quick_xml_deserialize::AreaElementTypeDeserializer; } #[derive(Debug)] pub struct RubyContent59 { @@ -71976,7 +71981,7 @@ pub mod onix { DeserializerArtifact, DeserializerEvent, DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event, RawByteStr, WithDeserializer, }, - xml::{Mixed, Text}, + xml::{AnyElement, Mixed, Text}, }; #[derive(Debug)] pub struct OnixMessageElementTypeDeserializer { @@ -88381,7 +88386,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"IllustrationsNote", - false, + true, )?; match self.handle_illustrations_note(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -89076,7 +89081,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"AudienceDescription", - false, + true, )?; match self.handle_audience_description(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -90593,7 +90598,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"EventDescription", - false, + true, )?; match self.handle_event_description(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -95509,7 +95514,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"MarketPublishingStatusNote", - false, + true, )?; match self.handle_market_publishing_status_note( helper, @@ -95550,7 +95555,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"PromotionCampaign", - false, + true, )?; match self.handle_promotion_campaign(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -95567,7 +95572,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"InitialPrintRun", - false, + true, )?; match self.handle_initial_print_run(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -95584,7 +95589,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"ReprintDetail", - false, + true, )?; match self.handle_reprint_detail(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -95601,7 +95606,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"CopiesSold", - false, + true, )?; match self.handle_copies_sold(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -95621,7 +95626,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"BookClubAdoption", - false, + true, )?; match self.handle_book_club_adoption(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -104556,7 +104561,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"TitleStatement", - false, + true, )?; match self.handle_title_statement(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -105195,7 +105200,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"ContributorStatement", - false, + true, )?; match self.handle_contributor_statement( helper, @@ -109302,7 +109307,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"AncillaryContentDescription", - false, + true, )?; match self.handle_ancillary_content_description( helper, @@ -113547,7 +113552,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"Text", - false, + true, )?; match self.handle_text(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -113625,7 +113630,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"TextSourceDescription", - false, + true, )?; match self.handle_text_source_description( helper, @@ -114563,7 +114568,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"CitationNote", - false, + true, )?; match self.handle_citation_note(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -116289,7 +116294,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"PrizeStatement", - false, + true, )?; match self.handle_prize_statement(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -116306,7 +116311,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"PrizeJury", - false, + true, )?; match self.handle_prize_jury(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -119078,7 +119083,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"EventDescription", - false, + true, )?; match self.handle_event_description(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -120131,7 +120136,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"WebsiteDescription", - false, + true, )?; match self.handle_website_description(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -121997,7 +122002,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"CopyrightStatementText", - false, + true, )?; match self.handle_copyright_statement_text( helper, @@ -123953,7 +123958,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"PublishingStatusNote", - false, + true, )?; match self.handle_publishing_status_note( helper, @@ -128276,7 +128281,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"SalesRestrictionNote", - false, + true, )?; match self.handle_sales_restriction_note( helper, @@ -146100,7 +146105,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"BiographicalNote", - false, + true, )?; match self.handle_biographical_note(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -146137,7 +146142,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"ContributorDescription", - false, + true, )?; match self.handle_contributor_description( helper, @@ -148216,7 +148221,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"EditionStatement", - false, + true, )?; match self.handle_edition_statement(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -150981,6 +150986,31 @@ pub mod onix { #[derive(Debug)] pub enum BlockElementDeserializerState { Init__, + Heading( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Lists( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Blocktext( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Div( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + P( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), H1( Option, Option<::Deserializer>, @@ -151046,16 +151076,6 @@ pub mod onix { Option<::Deserializer>, Option<::Deserializer>, ), - Div( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - P( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), Table( Option, Option<::Deserializer>, @@ -151071,6 +151091,43 @@ pub mod onix { event: Event<'de>, ) -> Result, Error> { if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"heading") + ) { + let output = ::init(helper, event)?; + return self.handle_heading(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"lists") + ) { + let output = ::init(helper, event)?; + return self.handle_lists(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"blocktext") + ) { + let output = ::init(helper, event)?; + return self.handle_blocktext(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"div") + ) { + let output = + ::init(helper, event)?; + return self.handle_div(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"p") + ) { + let output = + ::init(helper, event)?; + return self.handle_p(helper, Default::default(), None, output); + } if matches!( helper.resolve_local_name(x.name(), &super::super::NS_ONIX), Some(b"h1") @@ -151176,22 +151233,6 @@ pub mod onix { )?; return self.handle_blockquote(helper, Default::default(), None, output); } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"div") - ) { - let output = - ::init(helper, event)?; - return self.handle_div(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"p") - ) { - let output = - ::init(helper, event)?; - return self.handle_p(helper, Default::default(), None, output); - } if matches!( helper.resolve_local_name(x.name(), &super::super::NS_ONIX), Some(b"table") @@ -151211,6 +151252,49 @@ pub mod onix { use BlockElementDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Heading(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_heading(&mut values, value)?; + } + Ok(super::BlockElement::Heading( + helper.finish_element("heading", values)?, + )) + } + S::Lists(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_lists(&mut values, value)?; + } + Ok(super::BlockElement::Lists( + helper.finish_element("lists", values)?, + )) + } + S::Blocktext(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_blocktext(&mut values, value)?; + } + Ok(super::BlockElement::Blocktext( + helper.finish_element("blocktext", values)?, + )) + } + S::Div(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_div(&mut values, value)?; + } + Ok(super::BlockElement::Div( + helper.finish_element("div", values)?, + )) + } + S::P(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_p(&mut values, value)?; + } + Ok(super::BlockElement::P(helper.finish_element("p", values)?)) + } S::H1(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; @@ -151328,22 +151412,6 @@ pub mod onix { helper.finish_element("blockquote", values)?, )) } - S::Div(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_div(&mut values, value)?; - } - Ok(super::BlockElement::Div( - helper.finish_element("div", values)?, - )) - } - S::P(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_p(&mut values, value)?; - } - Ok(super::BlockElement::P(helper.finish_element("p", values)?)) - } S::Table(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; @@ -151357,6 +151425,62 @@ pub mod onix { _ => unreachable!(), } } + fn store_heading( + values: &mut Option, + value: AnyElement, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"heading", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_lists( + values: &mut Option, + value: AnyElement, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"lists", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_blocktext( + values: &mut Option, + value: AnyElement, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"blocktext", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_div( + values: &mut Option, + value: super::DdElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"div")))?; + } + *values = Some(value); + Ok(()) + } + fn store_p( + values: &mut Option, + value: super::AbbrElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"p")))?; + } + *values = Some(value); + Ok(()) + } fn store_h1( values: &mut Option, value: super::AbbrElementType, @@ -151491,26 +151615,6 @@ pub mod onix { *values = Some(value); Ok(()) } - fn store_div( - values: &mut Option, - value: super::DdElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"div")))?; - } - *values = Some(value); - Ok(()) - } - fn store_p( - values: &mut Option, - value: super::AbbrElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"p")))?; - } - *values = Some(value); - Ok(()) - } fn store_table( values: &mut Option, value: super::TableElementType, @@ -151523,6 +151627,176 @@ pub mod onix { *values = Some(value); Ok(()) } + fn handle_heading<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, AnyElement>, + ) -> Result, Error> { + use BlockElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_heading(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_heading(&mut values, data)?; + let data = Self::finish_state(helper, S::Heading(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Heading(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_lists<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, AnyElement>, + ) -> Result, Error> { + use BlockElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_lists(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_lists(&mut values, data)?; + let data = Self::finish_state(helper, S::Lists(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Lists(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_blocktext<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, AnyElement>, + ) -> Result, Error> { + use BlockElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_blocktext(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_blocktext(&mut values, data)?; + let data = Self::finish_state(helper, S::Blocktext(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Blocktext(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_div<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::DdElementType>, + ) -> Result, Error> { + use BlockElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_div(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_div(&mut values, data)?; + let data = Self::finish_state(helper, S::Div(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Div(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_p<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AbbrElementType>, + ) -> Result, Error> { + use BlockElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_p(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_p(&mut values, data)?; + let data = Self::finish_state(helper, S::P(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::P(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } fn handle_h1<'de>( &mut self, helper: &mut DeserializeHelper, @@ -151965,74 +152239,6 @@ pub mod onix { } } } - fn handle_div<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::DdElementType>, - ) -> Result, Error> { - use BlockElementDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_div(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_div(&mut values, data)?; - let data = Self::finish_state(helper, S::Div(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Div(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_p<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AbbrElementType>, - ) -> Result, Error> { - use BlockElementDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_p(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_p(&mut values, data)?; - let data = Self::finish_state(helper, S::P(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::P(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } fn handle_table<'de>( &mut self, helper: &mut DeserializeHelper, @@ -152098,6 +152304,51 @@ pub mod onix { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), + (S::Heading(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_heading(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Lists(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_lists(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Blocktext(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_blocktext(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Div(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_div(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::P(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_p(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } (S::H1(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; match self.handle_h1(helper, values, fallback, output)? { @@ -152215,24 +152466,6 @@ pub mod onix { ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Div(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_div(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::P(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_p(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } (S::Table(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; match self.handle_table(helper, values, fallback, output)? { @@ -152257,6 +152490,91 @@ pub mod onix { } ElementHandlerOutput::Continue { event, .. } => event, }, + ( + S::Heading(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"heading", + true, + )?; + match self.handle_heading(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Lists(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"lists", + true, + )?; + match self.handle_lists(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Blocktext(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"blocktext", + true, + )?; + match self.handle_blocktext(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Div(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"div", + true, + )?; + match self.handle_div(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::P(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"p", + true, + )?; + match self.handle_p(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } ( S::H1(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), @@ -152265,7 +152583,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"h1", - false, + true, )?; match self.handle_h1(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152282,7 +152600,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"h2", - false, + true, )?; match self.handle_h2(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152299,7 +152617,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"h3", - false, + true, )?; match self.handle_h3(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152316,7 +152634,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"h4", - false, + true, )?; match self.handle_h4(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152333,7 +152651,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"h5", - false, + true, )?; match self.handle_h5(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152350,7 +152668,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"h6", - false, + true, )?; match self.handle_h6(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152367,7 +152685,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"ul", - false, + true, )?; match self.handle_ul(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152384,7 +152702,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"ol", - false, + true, )?; match self.handle_ol(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152401,7 +152719,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"dl", - false, + true, )?; match self.handle_dl(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152418,7 +152736,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"address", - false, + true, )?; match self.handle_address(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152452,7 +152770,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"pre", - false, + true, )?; match self.handle_pre(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152469,7 +152787,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"blockquote", - false, + true, )?; match self.handle_blockquote(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152478,40 +152796,6 @@ pub mod onix { ElementHandlerOutput::Continue { event, .. } => event, } } - ( - S::Div(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_ONIX), - b"div", - false, - )?; - match self.handle_div(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::P(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_ONIX), - b"p", - false, - )?; - match self.handle_p(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } ( S::Table(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), @@ -152520,7 +152804,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"table", - false, + true, )?; match self.handle_table(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -152561,6 +152845,31 @@ pub mod onix { #[derive(Debug)] pub enum InlineElementDeserializerState { Init__, + Special( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Fontstyle( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Phrase( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Gloss( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + A( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), Span( Option, Option<::Deserializer>, @@ -152576,21 +152885,6 @@ pub mod onix { Option<::Deserializer>, Option<::Deserializer>, ), - Img( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Map( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Fontstyle( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), Em( Option, Option<::Deserializer>, @@ -152656,16 +152950,6 @@ pub mod onix { Option<::Deserializer>, Option<::Deserializer>, ), - Gloss( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - A( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), Tt( Option, Option<::Deserializer>, @@ -152691,6 +152975,16 @@ pub mod onix { Option<::Deserializer>, Option<::Deserializer>, ), + Img( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Map( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), Ruby( Option, Option<::Deserializer>, @@ -152705,48 +152999,66 @@ pub mod onix { helper: &mut DeserializeHelper, event: Event<'de>, ) -> Result, Error> { - let mut event = event; - let mut allow_any_element = false; if let Event::Start(x) | Event::Empty(x) = &event { if matches!( helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"span") + Some(b"special") ) { - let output = - ::init(helper, event)?; - return self.handle_span(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_special(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"bdo") + Some(b"fontstyle") + ) { + let output = ::init(helper, event)?; + return self.handle_fontstyle(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"phrase") + ) { + let output = ::init(helper, event)?; + return self.handle_phrase(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"gloss") + ) { + let output = ::init(helper, event)?; + return self.handle_gloss(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"a") ) { let output = - ::init(helper, event)?; - return self.handle_bdo(helper, Default::default(), None, output); + ::init(helper, event)?; + return self.handle_a(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"br") + Some(b"span") ) { let output = - ::init(helper, event)?; - return self.handle_br(helper, Default::default(), None, output); + ::init(helper, event)?; + return self.handle_span(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"img") + Some(b"bdo") ) { let output = - ::init(helper, event)?; - return self.handle_img(helper, Default::default(), None, output); + ::init(helper, event)?; + return self.handle_bdo(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"map") + Some(b"br") ) { let output = - ::init(helper, event)?; - return self.handle_map(helper, Default::default(), None, output); + ::init(helper, event)?; + return self.handle_br(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::super::NS_ONIX), @@ -152852,14 +153164,6 @@ pub mod onix { ::init(helper, event)?; return self.handle_sup(helper, Default::default(), None, output); } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"a") - ) { - let output = - ::init(helper, event)?; - return self.handle_a(helper, Default::default(), None, output); - } if matches!( helper.resolve_local_name(x.name(), &super::super::NS_ONIX), Some(b"tt") @@ -152900,6 +153204,22 @@ pub mod onix { ::init(helper, event)?; return self.handle_small(helper, Default::default(), None, output); } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"img") + ) { + let output = + ::init(helper, event)?; + return self.handle_img(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"map") + ) { + let output = + ::init(helper, event)?; + return self.handle_map(helper, Default::default(), None, output); + } if matches!( helper.resolve_local_name(x.name(), &super::super::NS_ONIX), Some(b"ruby") @@ -152908,38 +153228,9 @@ pub mod onix { ::init(helper, event)?; return self.handle_ruby(helper, Default::default(), None, output); } - event = { - let output = - ::init(helper, event)?; - match self.handle_fontstyle(helper, Default::default(), None, output)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - output => { - return Ok(output); - } - } - }; - event = { - let output = - ::init(helper, event)?; - match self.handle_gloss(helper, Default::default(), None, output)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - output => { - return Ok(output); - } - } - }; } *self.state__ = InlineElementDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent( - event, - allow_any_element, - )) + Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( helper: &mut DeserializeHelper, @@ -152948,58 +153239,74 @@ pub mod onix { use InlineElementDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Span(mut values, None, deserializer) => { + S::Special(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_span(&mut values, value)?; + Self::store_special(&mut values, value)?; } - Ok(super::InlineElement::Span( - helper.finish_element("span", values)?, + Ok(super::InlineElement::Special( + helper.finish_element("special", values)?, )) } - S::Bdo(mut values, None, deserializer) => { + S::Fontstyle(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_bdo(&mut values, value)?; + Self::store_fontstyle(&mut values, value)?; } - Ok(super::InlineElement::Bdo( - helper.finish_element("bdo", values)?, + Ok(super::InlineElement::Fontstyle( + helper.finish_element("fontstyle", values)?, )) } - S::Br(mut values, None, deserializer) => { + S::Phrase(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_br(&mut values, value)?; + Self::store_phrase(&mut values, value)?; } - Ok(super::InlineElement::Br( - helper.finish_element("br", values)?, + Ok(super::InlineElement::Phrase( + helper.finish_element("phrase", values)?, )) } - S::Img(mut values, None, deserializer) => { + S::Gloss(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_img(&mut values, value)?; + Self::store_gloss(&mut values, value)?; } - Ok(super::InlineElement::Img( - helper.finish_element("img", values)?, + Ok(super::InlineElement::Gloss( + helper.finish_element("gloss", values)?, )) } - S::Map(mut values, None, deserializer) => { + S::A(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_map(&mut values, value)?; + Self::store_a(&mut values, value)?; } - Ok(super::InlineElement::Map( - helper.finish_element("map", values)?, + Ok(super::InlineElement::A(helper.finish_element("a", values)?)) + } + S::Span(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_span(&mut values, value)?; + } + Ok(super::InlineElement::Span( + helper.finish_element("span", values)?, )) } - S::Fontstyle(mut values, None, deserializer) => { + S::Bdo(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_fontstyle(&mut values, value)?; + Self::store_bdo(&mut values, value)?; } - Ok(super::InlineElement::Fontstyle( - helper.finish_element("fontstyle", values)?, + Ok(super::InlineElement::Bdo( + helper.finish_element("bdo", values)?, + )) + } + S::Br(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_br(&mut values, value)?; + } + Ok(super::InlineElement::Br( + helper.finish_element("br", values)?, )) } S::Em(mut values, None, deserializer) => { @@ -153117,22 +153424,6 @@ pub mod onix { helper.finish_element("sup", values)?, )) } - S::Gloss(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_gloss(&mut values, value)?; - } - Ok(super::InlineElement::Gloss( - helper.finish_element("gloss", values)?, - )) - } - S::A(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_a(&mut values, value)?; - } - Ok(super::InlineElement::A(helper.finish_element("a", values)?)) - } S::Tt(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; @@ -153174,6 +153465,24 @@ pub mod onix { helper.finish_element("small", values)?, )) } + S::Img(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_img(&mut values, value)?; + } + Ok(super::InlineElement::Img( + helper.finish_element("img", values)?, + )) + } + S::Map(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_map(&mut values, value)?; + } + Ok(super::InlineElement::Map( + helper.finish_element("map", values)?, + )) + } S::Ruby(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; @@ -153187,64 +153496,90 @@ pub mod onix { _ => unreachable!(), } } - fn store_span( - values: &mut Option, - value: super::AbbrElementType, + fn store_special( + values: &mut Option, + value: AnyElement, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"span")))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"special", + )))?; } *values = Some(value); Ok(()) } - fn store_bdo( - values: &mut Option, - value: super::BdoElementType, + fn store_fontstyle( + values: &mut Option, + value: AnyElement, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"bdo")))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"fontstyle", + )))?; } *values = Some(value); Ok(()) } - fn store_br( - values: &mut Option, - value: super::BrElementType, + fn store_phrase( + values: &mut Option, + value: AnyElement, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"br")))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"phrase", + )))?; } *values = Some(value); Ok(()) } - fn store_img( - values: &mut Option, - value: super::ImgElementType, + fn store_gloss( + values: &mut Option, + value: AnyElement, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"img")))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"gloss", + )))?; } *values = Some(value); Ok(()) } - fn store_map( - values: &mut Option, - value: super::MapElementType, + fn store_a( + values: &mut Option, + value: super::AElementType, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"map")))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"a")))?; } *values = Some(value); Ok(()) } - fn store_fontstyle( - values: &mut Option, - value: super::FontstyleElement, + fn store_span( + values: &mut Option, + value: super::AbbrElementType, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"fontstyle", - )))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"span")))?; + } + *values = Some(value); + Ok(()) + } + fn store_bdo( + values: &mut Option, + value: super::BdoElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"bdo")))?; + } + *values = Some(value); + Ok(()) + } + fn store_br( + values: &mut Option, + value: super::BrElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"br")))?; } *values = Some(value); Ok(()) @@ -153383,28 +153718,6 @@ pub mod onix { *values = Some(value); Ok(()) } - fn store_gloss( - values: &mut Option, - value: super::GlossElement, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"gloss", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_a( - values: &mut Option, - value: super::AElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"a")))?; - } - *values = Some(value); - Ok(()) - } fn store_tt( values: &mut Option, value: super::AbbrElementType, @@ -153457,6 +153770,26 @@ pub mod onix { *values = Some(value); Ok(()) } + fn store_img( + values: &mut Option, + value: super::ImgElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"img")))?; + } + *values = Some(value); + Ok(()) + } + fn store_map( + values: &mut Option, + value: super::MapElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"map")))?; + } + *values = Some(value); + Ok(()) + } fn store_ruby( values: &mut Option, value: super::RubyElementType, @@ -153467,12 +153800,12 @@ pub mod onix { *values = Some(value); Ok(()) } - fn handle_span<'de>( + fn handle_special<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AbbrElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, AnyElement>, ) -> Result, Error> { use InlineElementDeserializerState as S; let DeserializerOutput { @@ -153485,28 +153818,28 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_span(&mut values, data)?; + Self::store_special(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_span(&mut values, data)?; - let data = Self::finish_state(helper, S::Span(values, None, None))?; + Self::store_special(&mut values, data)?; + let data = Self::finish_state(helper, S::Special(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Span(values, None, Some(deserializer)); + *self.state__ = S::Special(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_bdo<'de>( + fn handle_fontstyle<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::BdoElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, AnyElement>, ) -> Result, Error> { use InlineElementDeserializerState as S; let DeserializerOutput { @@ -153519,28 +153852,28 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_bdo(&mut values, data)?; + Self::store_fontstyle(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_bdo(&mut values, data)?; - let data = Self::finish_state(helper, S::Bdo(values, None, None))?; + Self::store_fontstyle(&mut values, data)?; + let data = Self::finish_state(helper, S::Fontstyle(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Bdo(values, None, Some(deserializer)); + *self.state__ = S::Fontstyle(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_br<'de>( + fn handle_phrase<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::BrElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, AnyElement>, ) -> Result, Error> { use InlineElementDeserializerState as S; let DeserializerOutput { @@ -153553,28 +153886,28 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_br(&mut values, data)?; + Self::store_phrase(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_br(&mut values, data)?; - let data = Self::finish_state(helper, S::Br(values, None, None))?; + Self::store_phrase(&mut values, data)?; + let data = Self::finish_state(helper, S::Phrase(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Br(values, None, Some(deserializer)); + *self.state__ = S::Phrase(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_img<'de>( + fn handle_gloss<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::ImgElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, AnyElement>, ) -> Result, Error> { use InlineElementDeserializerState as S; let DeserializerOutput { @@ -153587,28 +153920,28 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_img(&mut values, data)?; + Self::store_gloss(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_img(&mut values, data)?; - let data = Self::finish_state(helper, S::Img(values, None, None))?; + Self::store_gloss(&mut values, data)?; + let data = Self::finish_state(helper, S::Gloss(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Img(values, None, Some(deserializer)); + *self.state__ = S::Gloss(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_map<'de>( + fn handle_a<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::MapElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AElementType>, ) -> Result, Error> { use InlineElementDeserializerState as S; let DeserializerOutput { @@ -153621,28 +153954,28 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_map(&mut values, data)?; + Self::store_a(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_map(&mut values, data)?; - let data = Self::finish_state(helper, S::Map(values, None, None))?; + Self::store_a(&mut values, data)?; + let data = Self::finish_state(helper, S::A(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Map(values, None, Some(deserializer)); + *self.state__ = S::A(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_fontstyle<'de>( + fn handle_span<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FontstyleElement>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AbbrElementType>, ) -> Result, Error> { use InlineElementDeserializerState as S; let DeserializerOutput { @@ -153651,22 +153984,90 @@ pub mod onix { allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_fontstyle(&mut values, data)?; + Self::store_span(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_fontstyle(&mut values, data)?; - let data = Self::finish_state(helper, S::Fontstyle(values, None, None))?; + Self::store_span(&mut values, data)?; + let data = Self::finish_state(helper, S::Span(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Fontstyle(values, None, Some(deserializer)); + *self.state__ = S::Span(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_bdo<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::BdoElementType>, + ) -> Result, Error> { + use InlineElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_bdo(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_bdo(&mut values, data)?; + let data = Self::finish_state(helper, S::Bdo(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Bdo(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_br<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::BrElementType>, + ) -> Result, Error> { + use InlineElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_br(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_br(&mut values, data)?; + let data = Self::finish_state(helper, S::Br(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Br(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } @@ -154113,12 +154514,12 @@ pub mod onix { } } } - fn handle_gloss<'de>( + fn handle_tt<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GlossElement>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AbbrElementType>, ) -> Result, Error> { use InlineElementDeserializerState as S; let DeserializerOutput { @@ -154127,32 +154528,32 @@ pub mod onix { allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_gloss(&mut values, data)?; + Self::store_tt(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_gloss(&mut values, data)?; - let data = Self::finish_state(helper, S::Gloss(values, None, None))?; + Self::store_tt(&mut values, data)?; + let data = Self::finish_state(helper, S::Tt(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Gloss(values, None, Some(deserializer)); + *self.state__ = S::Tt(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_a<'de>( + fn handle_i<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AbbrElementType>, ) -> Result, Error> { use InlineElementDeserializerState as S; let DeserializerOutput { @@ -154165,23 +154566,23 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_a(&mut values, data)?; + Self::store_i(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_a(&mut values, data)?; - let data = Self::finish_state(helper, S::A(values, None, None))?; + Self::store_i(&mut values, data)?; + let data = Self::finish_state(helper, S::I(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::A(values, None, Some(deserializer)); + *self.state__ = S::I(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_tt<'de>( + fn handle_b<'de>( &mut self, helper: &mut DeserializeHelper, mut values: Option, @@ -154199,23 +154600,23 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_tt(&mut values, data)?; + Self::store_b(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_tt(&mut values, data)?; - let data = Self::finish_state(helper, S::Tt(values, None, None))?; + Self::store_b(&mut values, data)?; + let data = Self::finish_state(helper, S::B(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Tt(values, None, Some(deserializer)); + *self.state__ = S::B(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_i<'de>( + fn handle_big<'de>( &mut self, helper: &mut DeserializeHelper, mut values: Option, @@ -154233,23 +154634,23 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_i(&mut values, data)?; + Self::store_big(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_i(&mut values, data)?; - let data = Self::finish_state(helper, S::I(values, None, None))?; + Self::store_big(&mut values, data)?; + let data = Self::finish_state(helper, S::Big(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::I(values, None, Some(deserializer)); + *self.state__ = S::Big(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_b<'de>( + fn handle_small<'de>( &mut self, helper: &mut DeserializeHelper, mut values: Option, @@ -154267,28 +154668,28 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_b(&mut values, data)?; + Self::store_small(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_b(&mut values, data)?; - let data = Self::finish_state(helper, S::B(values, None, None))?; + Self::store_small(&mut values, data)?; + let data = Self::finish_state(helper, S::Small(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::B(values, None, Some(deserializer)); + *self.state__ = S::Small(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_big<'de>( + fn handle_img<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AbbrElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ImgElementType>, ) -> Result, Error> { use InlineElementDeserializerState as S; let DeserializerOutput { @@ -154301,28 +154702,28 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_big(&mut values, data)?; + Self::store_img(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_big(&mut values, data)?; - let data = Self::finish_state(helper, S::Big(values, None, None))?; + Self::store_img(&mut values, data)?; + let data = Self::finish_state(helper, S::Img(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Big(values, None, Some(deserializer)); + *self.state__ = S::Img(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_small<'de>( + fn handle_map<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AbbrElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::MapElementType>, ) -> Result, Error> { use InlineElementDeserializerState as S; let DeserializerOutput { @@ -154335,18 +154736,18 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_small(&mut values, data)?; + Self::store_map(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_small(&mut values, data)?; - let data = Self::finish_state(helper, S::Small(values, None, None))?; + Self::store_map(&mut values, data)?; + let data = Self::finish_state(helper, S::Map(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Small(values, None, Some(deserializer)); + *self.state__ = S::Map(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } @@ -154416,54 +154817,72 @@ pub mod onix { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Span(values, fallback, Some(deserializer)), event) => { + (S::Special(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_span(helper, values, fallback, output)? { + match self.handle_special(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Bdo(values, fallback, Some(deserializer)), event) => { + (S::Fontstyle(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_bdo(helper, values, fallback, output)? { + match self.handle_fontstyle(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Br(values, fallback, Some(deserializer)), event) => { + (S::Phrase(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_br(helper, values, fallback, output)? { + match self.handle_phrase(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Img(values, fallback, Some(deserializer)), event) => { + (S::Gloss(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_img(helper, values, fallback, output)? { + match self.handle_gloss(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Map(values, fallback, Some(deserializer)), event) => { + (S::A(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_map(helper, values, fallback, output)? { + match self.handle_a(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Fontstyle(values, fallback, Some(deserializer)), event) => { + (S::Span(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_fontstyle(helper, values, fallback, output)? { + match self.handle_span(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Bdo(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_bdo(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Br(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_br(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -154587,63 +155006,63 @@ pub mod onix { ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Gloss(values, fallback, Some(deserializer)), event) => { + (S::Tt(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_gloss(helper, values, fallback, output)? { + match self.handle_tt(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::A(values, fallback, Some(deserializer)), event) => { + (S::I(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_a(helper, values, fallback, output)? { + match self.handle_i(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Tt(values, fallback, Some(deserializer)), event) => { + (S::B(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_tt(helper, values, fallback, output)? { + match self.handle_b(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::I(values, fallback, Some(deserializer)), event) => { + (S::Big(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_i(helper, values, fallback, output)? { + match self.handle_big(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::B(values, fallback, Some(deserializer)), event) => { + (S::Small(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_b(helper, values, fallback, output)? { + match self.handle_small(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Big(values, fallback, Some(deserializer)), event) => { + (S::Img(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_big(helper, values, fallback, output)? { + match self.handle_img(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Small(values, fallback, Some(deserializer)), event) => { + (S::Map(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_small(helper, values, fallback, output)? { + match self.handle_map(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -154675,16 +155094,16 @@ pub mod onix { ElementHandlerOutput::Continue { event, .. } => event, }, ( - S::Span(values, fallback, None), + S::Special(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_ONIX), - b"span", - false, + b"special", + true, )?; - match self.handle_span(helper, values, fallback, output)? { + match self.handle_special(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -154692,16 +155111,16 @@ pub mod onix { } } ( - S::Bdo(values, fallback, None), + S::Fontstyle(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_ONIX), - b"bdo", - false, + b"fontstyle", + true, )?; - match self.handle_bdo(helper, values, fallback, output)? { + match self.handle_fontstyle(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -154709,16 +155128,16 @@ pub mod onix { } } ( - S::Br(values, fallback, None), + S::Phrase(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_ONIX), - b"br", - false, + b"phrase", + true, )?; - match self.handle_br(helper, values, fallback, output)? { + match self.handle_phrase(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -154726,16 +155145,16 @@ pub mod onix { } } ( - S::Img(values, fallback, None), + S::Gloss(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_ONIX), - b"img", - false, + b"gloss", + true, )?; - match self.handle_img(helper, values, fallback, output)? { + match self.handle_gloss(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -154743,16 +155162,16 @@ pub mod onix { } } ( - S::Map(values, fallback, None), + S::A(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_ONIX), - b"map", - false, + b"a", + true, )?; - match self.handle_map(helper, values, fallback, output)? { + match self.handle_a(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -154760,12 +155179,50 @@ pub mod onix { } } ( - S::Fontstyle(values, fallback, None), + S::Span(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = - ::init(helper, event)?; - match self.handle_fontstyle(helper, values, fallback, output)? { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"span", + true, + )?; + match self.handle_span(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Bdo(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"bdo", + true, + )?; + match self.handle_bdo(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Br(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"br", + false, + )?; + match self.handle_br(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -154780,7 +155237,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"em", - false, + true, )?; match self.handle_em(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154797,7 +155254,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"strong", - false, + true, )?; match self.handle_strong(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154814,7 +155271,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"dfn", - false, + true, )?; match self.handle_dfn(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154831,7 +155288,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"code", - false, + true, )?; match self.handle_code(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154848,7 +155305,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"samp", - false, + true, )?; match self.handle_samp(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154865,7 +155322,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"kbd", - false, + true, )?; match self.handle_kbd(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154882,7 +155339,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"var", - false, + true, )?; match self.handle_var(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154899,7 +155356,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"cite", - false, + true, )?; match self.handle_cite(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154916,7 +155373,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"abbr", - false, + true, )?; match self.handle_abbr(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154933,7 +155390,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"acronym", - false, + true, )?; match self.handle_acronym(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154950,7 +155407,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"q", - false, + true, )?; match self.handle_q(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154967,7 +155424,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"sub", - false, + true, )?; match self.handle_sub(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154984,7 +155441,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"sup", - false, + true, )?; match self.handle_sup(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -154994,12 +155451,16 @@ pub mod onix { } } ( - S::Gloss(values, fallback, None), + S::Tt(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = - ::init(helper, event)?; - match self.handle_gloss(helper, values, fallback, output)? { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"tt", + true, + )?; + match self.handle_tt(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -155007,16 +155468,16 @@ pub mod onix { } } ( - S::A(values, fallback, None), + S::I(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_ONIX), - b"a", - false, + b"i", + true, )?; - match self.handle_a(helper, values, fallback, output)? { + match self.handle_i(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -155024,16 +155485,16 @@ pub mod onix { } } ( - S::Tt(values, fallback, None), + S::B(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_ONIX), - b"tt", - false, + b"b", + true, )?; - match self.handle_tt(helper, values, fallback, output)? { + match self.handle_b(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -155041,16 +155502,16 @@ pub mod onix { } } ( - S::I(values, fallback, None), + S::Big(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_ONIX), - b"i", - false, + b"big", + true, )?; - match self.handle_i(helper, values, fallback, output)? { + match self.handle_big(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -155058,16 +155519,16 @@ pub mod onix { } } ( - S::B(values, fallback, None), + S::Small(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_ONIX), - b"b", - false, + b"small", + true, )?; - match self.handle_b(helper, values, fallback, output)? { + match self.handle_small(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -155075,16 +155536,16 @@ pub mod onix { } } ( - S::Big(values, fallback, None), + S::Img(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_ONIX), - b"big", + b"img", false, )?; - match self.handle_big(helper, values, fallback, output)? { + match self.handle_img(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -155092,16 +155553,16 @@ pub mod onix { } } ( - S::Small(values, fallback, None), + S::Map(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::super::NS_ONIX), - b"small", - false, + b"map", + true, )?; - match self.handle_small(helper, values, fallback, output)? { + match self.handle_map(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -155116,7 +155577,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"ruby", - false, + true, )?; match self.handle_ruby(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -166270,7 +166731,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"FeatureNote", - false, + true, )?; match self.handle_feature_note(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -170060,7 +170521,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"ContributorStatement", - false, + true, )?; match self.handle_contributor_statement( helper, @@ -170904,7 +171365,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"VenueNote", - false, + true, )?; match self.handle_venue_note(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -201192,7 +201653,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"ReligiousTextFeatureDescription", - false, + true, )?; match self.handle_religious_text_feature_description( helper, @@ -201703,26 +202164,24 @@ pub mod onix { } } #[derive(Debug)] - pub struct AbbrElementTypeDeserializer { + pub struct DdElementTypeDeserializer { id: Option, class: Option, style: Option, title: Option, lang: Option, dir: Option, - text_before: Option, - inline: Vec>, - state__: Box, + content: Vec, + state__: Box, } #[derive(Debug)] - enum AbbrElementTypeDeserializerState { + enum DdElementTypeDeserializerState { Init__, - TextBefore(Option<::Deserializer>), - Inline(Option< as WithDeserializer>::Deserializer>), - Done__, + Next__, + Content__(::Deserializer), Unknown__, } - impl AbbrElementTypeDeserializer { + impl DdElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -201776,256 +202235,847 @@ pub mod onix { title: title, lang: lang, dir: dir, - text_before: None, - inline: Vec::new(), - state__: Box::new(AbbrElementTypeDeserializerState::Init__), + content: Vec::new(), + state__: Box::new(DdElementTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: AbbrElementTypeDeserializerState, + state: DdElementTypeDeserializerState, ) -> Result<(), Error> { - use AbbrElementTypeDeserializerState as S; + if let DdElementTypeDeserializerState::Content__(deserializer) = state { + self.store_content(deserializer.finish(helper)?)?; + } + Ok(()) + } + fn store_content(&mut self, value: super::DdElementTypeContent) -> Result<(), Error> { + self.content.push(value); + Ok(()) + } + fn handle_content<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::DdElementTypeContent>, + fallback: &mut Option, + ) -> Result, Error> { + use DdElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = fallback.take().unwrap_or(S::Next__); + return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_content(data)?; + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *fallback = Some(S::Content__(deserializer)); + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::DdElementType> for DdElementTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DdElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::DdElementType> { + use DdElementTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Content__(deserializer), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (_, Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (state @ (S::Init__ | S::Next__), event) => { + fallback.get_or_insert(state); + let output = ::init( + helper, event, + )?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + let artifact = DeserializerArtifact::Deserializer(self); + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + DdElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::DdElementType { + id: self.id, + class: self.class, + style: self.style, + title: self.title, + lang: self.lang, + dir: self.dir, + content: helper.finish_vec(0usize, None, self.content)?, + }) + } + } + #[derive(Debug)] + pub struct DdElementTypeContentDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum DdElementTypeContentDeserializerState { + Init__, + Block( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Inline( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Text( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::DdElementTypeContent), + Unknown__, + } + impl DdElementTypeContentDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + let mut event = event; + let mut allow_any_element = false; + if let Event::Start(_) | Event::Empty(_) = &event { + event = { + let output = + ::init(helper, event)?; + match self.handle_block(helper, Default::default(), None, output)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + output => { + return Ok(output); + } + } + }; + event = { + let output = + ::init(helper, event)?; + match self.handle_inline(helper, Default::default(), None, output)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + output => { + return Ok(output); + } + } + }; + } + event = { + let output = ::init(helper, event)?; + match self.handle_text(helper, Default::default(), None, output)? { + ElementHandlerOutput::Continue { event, .. } => event, + output => { + return Ok(output); + } + } + }; + *self.state__ = DdElementTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent( + event, + allow_any_element, + )) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: DdElementTypeContentDeserializerState, + ) -> Result { + use DdElementTypeContentDeserializerState as S; match state { - S::TextBefore(Some(deserializer)) => { - self.store_text_before(deserializer.finish(helper)?)? + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Block(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_block(&mut values, value)?; + } + Ok(super::DdElementTypeContent::Block( + helper.finish_element("block", values)?, + )) } - S::Inline(Some(deserializer)) => { - self.store_inline(deserializer.finish(helper)?)? + S::Inline(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_inline(&mut values, value)?; + } + Ok(super::DdElementTypeContent::Inline( + helper.finish_element("inline", values)?, + )) } - _ => (), + S::Text(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_text(&mut values, value)?; + } + Ok(super::DdElementTypeContent::Text( + helper.finish_element("text", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_block( + values: &mut Option, + value: super::BlockElement, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"block", + )))?; } + *values = Some(value); Ok(()) } - fn store_text_before(&mut self, value: Text) -> Result<(), Error> { - if self.text_before.is_some() { + fn store_inline( + values: &mut Option, + value: super::InlineElement, + ) -> Result<(), Error> { + if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"text_before", + b"inline", )))?; } - self.text_before = Some(value); + *values = Some(value); Ok(()) } - fn store_inline(&mut self, value: Mixed) -> Result<(), Error> { - self.inline.push(value); + fn store_text(values: &mut Option, value: Text) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"text")))?; + } + *values = Some(value); Ok(()) } - fn handle_text_before<'de>( + fn handle_block<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, Text>, - fallback: &mut Option, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::BlockElement>, ) -> Result, Error> { - use AbbrElementTypeDeserializerState as S; + use DdElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Inline(None); return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_block(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_text_before(data)?; - *self.state__ = S::Inline(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_block(&mut values, data)?; + let data = Self::finish_state(helper, S::Block(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::TextBefore(Some(deserializer))); - *self.state__ = S::Inline(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::Block(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } fn handle_inline<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, Mixed>, - fallback: &mut Option, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::InlineElement>, ) -> Result, Error> { - use AbbrElementTypeDeserializerState as S; + use DdElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Done__; return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_inline(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_inline(data)?; - *self.state__ = S::Inline(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_inline(&mut values, data)?; + let data = Self::finish_state(helper, S::Inline(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Inline(Some(deserializer))); - *self.state__ = S::Inline(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::Inline(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_text<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, Text>, + ) -> Result, Error> { + use DdElementTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_text(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_text(&mut values, data)?; + let data = Self::finish_state(helper, S::Text(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Text(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::AbbrElementType> for AbbrElementTypeDeserializer { + impl<'de> Deserializer<'de, super::DdElementTypeContent> for DdElementTypeContentDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AbbrElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + ) -> DeserializerResult<'de, super::DdElementTypeContent> { + let deserializer = Self { + state__: Box::new(DdElementTypeContentDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, DdElementTypeContentDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AbbrElementType> { - use AbbrElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::DdElementTypeContent> { + use DdElementTypeContentDeserializerState as S; let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::TextBefore(Some(deserializer)), event) => { + (S::Block(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_text_before(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_block(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Inline(Some(deserializer)), event) => { + (S::Inline(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_inline(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_inline(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + (S::Text(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_text(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, } + } + (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), allow_any: false, }); } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::TextBefore(None); - event - } - (S::TextBefore(None), event) => { - let output = ::init(helper, event)?; - match self.handle_text_before(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Block(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = + ::init(helper, event)?; + match self.handle_block(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Inline(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = as WithDeserializer>::init( - helper, event, - )?; - match self.handle_inline(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + ( + S::Inline(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = + ::init(helper, event)?; + match self.handle_inline(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); + ( + S::Text(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = ::init(helper, event)?; + match self.handle_text(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } } - (state, Event::Text(_) | Event::CData(_)) => { + (state @ S::Done__(_), event) => { *self.state__ = state; - break (DeserializerEvent::None, false); + break (DeserializerEvent::Continue(event), false); } (state, event) => { *self.state__ = state; - break (DeserializerEvent::Break(event), false); + break (DeserializerEvent::Continue(event), false); } } }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + artifact, event, allow_any, }) } fn finish( - mut self, + self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - AbbrElementTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::AbbrElementType { - id: self.id, - class: self.class, - style: self.style, - title: self.title, - lang: self.lang, - dir: self.dir, - text_before: self.text_before, - inline: self.inline, - }) + ) -> Result { + Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct UlElementTypeDeserializer { + pub struct AbbrElementTypeDeserializer { id: Option, class: Option, style: Option, title: Option, lang: Option, dir: Option, - li: Vec, - state__: Box, + text_before: Option, + inline: Vec>, + state__: Box, } #[derive(Debug)] - enum UlElementTypeDeserializerState { + enum AbbrElementTypeDeserializerState { Init__, - Li(Option<::Deserializer>), + TextBefore(Option<::Deserializer>), + Inline(Option< as WithDeserializer>::Deserializer>), Done__, Unknown__, } - impl UlElementTypeDeserializer { + impl AbbrElementTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut class: Option = None; + let mut style: Option = None; + let mut title: Option = None; + let mut lang: Option = None; + let mut dir: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"class") + ) { + helper.read_attrib(&mut class, b"class", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"style") + ) { + helper.read_attrib(&mut style, b"style", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"title") + ) { + helper.read_attrib(&mut title, b"title", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"lang") + ) { + helper.read_attrib(&mut lang, b"lang", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"dir") + ) { + helper.read_attrib(&mut dir, b"dir", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id, + class: class, + style: style, + title: title, + lang: lang, + dir: dir, + text_before: None, + inline: Vec::new(), + state__: Box::new(AbbrElementTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: AbbrElementTypeDeserializerState, + ) -> Result<(), Error> { + use AbbrElementTypeDeserializerState as S; + match state { + S::TextBefore(Some(deserializer)) => { + self.store_text_before(deserializer.finish(helper)?)? + } + S::Inline(Some(deserializer)) => { + self.store_inline(deserializer.finish(helper)?)? + } + _ => (), + } + Ok(()) + } + fn store_text_before(&mut self, value: Text) -> Result<(), Error> { + if self.text_before.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"text_before", + )))?; + } + self.text_before = Some(value); + Ok(()) + } + fn store_inline(&mut self, value: Mixed) -> Result<(), Error> { + self.inline.push(value); + Ok(()) + } + fn handle_text_before<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, Text>, + fallback: &mut Option, + ) -> Result, Error> { + use AbbrElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Inline(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_text_before(data)?; + *self.state__ = S::Inline(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::TextBefore(Some(deserializer))); + *self.state__ = S::Inline(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_inline<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, Mixed>, + fallback: &mut Option, + ) -> Result, Error> { + use AbbrElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_inline(data)?; + *self.state__ = S::Inline(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Inline(Some(deserializer))); + *self.state__ = S::Inline(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::AbbrElementType> for AbbrElementTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AbbrElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AbbrElementType> { + use AbbrElementTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::TextBefore(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_text_before(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Inline(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_inline(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::TextBefore(None); + event + } + (S::TextBefore(None), event) => { + let output = ::init(helper, event)?; + match self.handle_text_before(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Inline(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = as WithDeserializer>::init( + helper, event, + )?; + match self.handle_inline(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, Event::Text(_) | Event::CData(_)) => { + *self.state__ = state; + break (DeserializerEvent::None, false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + AbbrElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::AbbrElementType { + id: self.id, + class: self.class, + style: self.style, + title: self.title, + lang: self.lang, + dir: self.dir, + text_before: self.text_before, + inline: self.inline, + }) + } + } + #[derive(Debug)] + pub struct UlElementTypeDeserializer { + id: Option, + class: Option, + style: Option, + title: Option, + lang: Option, + dir: Option, + li: Vec, + state__: Box, + } + #[derive(Debug)] + enum UlElementTypeDeserializerState { + Init__, + Li(Option<::Deserializer>), + Done__, + Unknown__, + } + impl UlElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -202196,7 +203246,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"li", - false, + true, )?; match self.handle_li(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -202452,7 +203502,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"li", - false, + true, )?; match self.handle_li(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -202944,7 +203994,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"dt", - false, + true, )?; match self.handle_dt(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -202961,7 +204011,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"dd", - false, + true, )?; match self.handle_dd(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -204257,7 +205307,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"a", - false, + true, )?; match self.handle_a(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -204291,7 +205341,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"span", - false, + true, )?; match self.handle_span(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -204308,7 +205358,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"bdo", - false, + true, )?; match self.handle_bdo(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -204325,7 +205375,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"map", - false, + true, )?; match self.handle_map(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -204342,7 +205392,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"tt", - false, + true, )?; match self.handle_tt(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -204359,7 +205409,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"i", - false, + true, )?; match self.handle_i(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -204376,7 +205426,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"b", - false, + true, )?; match self.handle_b(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -204688,595 +205738,6 @@ pub mod onix { } } #[derive(Debug)] - pub struct DdElementTypeDeserializer { - id: Option, - class: Option, - style: Option, - title: Option, - lang: Option, - dir: Option, - content: Vec, - state__: Box, - } - #[derive(Debug)] - enum DdElementTypeDeserializerState { - Init__, - Next__, - Content__(::Deserializer), - Unknown__, - } - impl DdElementTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut id: Option = None; - let mut class: Option = None; - let mut style: Option = None; - let mut title: Option = None; - let mut lang: Option = None; - let mut dir: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"id") - ) { - helper.read_attrib(&mut id, b"id", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"class") - ) { - helper.read_attrib(&mut class, b"class", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"style") - ) { - helper.read_attrib(&mut style, b"style", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"title") - ) { - helper.read_attrib(&mut title, b"title", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"lang") - ) { - helper.read_attrib(&mut lang, b"lang", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"dir") - ) { - helper.read_attrib(&mut dir, b"dir", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; - } - } - Ok(Self { - id: id, - class: class, - style: style, - title: title, - lang: lang, - dir: dir, - content: Vec::new(), - state__: Box::new(DdElementTypeDeserializerState::Init__), - }) - } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: DdElementTypeDeserializerState, - ) -> Result<(), Error> { - if let DdElementTypeDeserializerState::Content__(deserializer) = state { - self.store_content(deserializer.finish(helper)?)?; - } - Ok(()) - } - fn store_content(&mut self, value: super::DdElementTypeContent) -> Result<(), Error> { - self.content.push(value); - Ok(()) - } - fn handle_content<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::DdElementTypeContent>, - fallback: &mut Option, - ) -> Result, Error> { - use DdElementTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = fallback.take().unwrap_or(S::Next__); - return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_content(data)?; - *self.state__ = S::Next__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *fallback = Some(S::Content__(deserializer)); - *self.state__ = S::Next__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - } - impl<'de> Deserializer<'de, super::DdElementType> for DdElementTypeDeserializer { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::DdElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::DdElementType> { - use DdElementTypeDeserializerState as S; - let mut event = event; - let mut fallback = None; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::Content__(deserializer), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_content(helper, output, &mut fallback)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (_, Event::End(_)) => { - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, - allow_any: false, - }); - } - (state @ (S::Init__ | S::Next__), event) => { - fallback.get_or_insert(state); - let output = ::init( - helper, event, - )?; - match self.handle_content(helper, output, &mut fallback)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - } - }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } - let artifact = DeserializerArtifact::Deserializer(self); - Ok(DeserializerOutput { - artifact, - event, - allow_any, - }) - } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - DdElementTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::DdElementType { - id: self.id, - class: self.class, - style: self.style, - title: self.title, - lang: self.lang, - dir: self.dir, - content: helper.finish_vec(0usize, None, self.content)?, - }) - } - } - #[derive(Debug)] - pub struct DdElementTypeContentDeserializer { - state__: Box, - } - #[derive(Debug)] - pub enum DdElementTypeContentDeserializerState { - Init__, - Block( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Inline( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Text( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Done__(super::DdElementTypeContent), - Unknown__, - } - impl DdElementTypeContentDeserializer { - fn find_suitable<'de>( - &mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> Result, Error> { - let mut event = event; - let mut allow_any_element = false; - if let Event::Start(_) | Event::Empty(_) = &event { - event = { - let output = - ::init(helper, event)?; - match self.handle_block(helper, Default::default(), None, output)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - output => { - return Ok(output); - } - } - }; - event = { - let output = - ::init(helper, event)?; - match self.handle_inline(helper, Default::default(), None, output)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - output => { - return Ok(output); - } - } - }; - } - event = { - let output = ::init(helper, event)?; - match self.handle_text(helper, Default::default(), None, output)? { - ElementHandlerOutput::Continue { event, .. } => event, - output => { - return Ok(output); - } - } - }; - *self.state__ = DdElementTypeContentDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent( - event, - allow_any_element, - )) - } - fn finish_state( - helper: &mut DeserializeHelper, - state: DdElementTypeContentDeserializerState, - ) -> Result { - use DdElementTypeContentDeserializerState as S; - match state { - S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Block(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_block(&mut values, value)?; - } - Ok(super::DdElementTypeContent::Block( - helper.finish_element("block", values)?, - )) - } - S::Inline(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_inline(&mut values, value)?; - } - Ok(super::DdElementTypeContent::Inline( - helper.finish_element("inline", values)?, - )) - } - S::Text(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_text(&mut values, value)?; - } - Ok(super::DdElementTypeContent::Text( - helper.finish_element("text", values)?, - )) - } - S::Done__(data) => Ok(data), - _ => unreachable!(), - } - } - fn store_block( - values: &mut Option, - value: super::BlockElement, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"block", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_inline( - values: &mut Option, - value: super::InlineElement, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"inline", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_text(values: &mut Option, value: Text) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"text")))?; - } - *values = Some(value); - Ok(()) - } - fn handle_block<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::BlockElement>, - ) -> Result, Error> { - use DdElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_block(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_block(&mut values, data)?; - let data = Self::finish_state(helper, S::Block(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Block(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_inline<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::InlineElement>, - ) -> Result, Error> { - use DdElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_inline(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_inline(&mut values, data)?; - let data = Self::finish_state(helper, S::Inline(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Inline(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_text<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, Text>, - ) -> Result, Error> { - use DdElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_text(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_text(&mut values, data)?; - let data = Self::finish_state(helper, S::Text(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Text(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - } - impl<'de> Deserializer<'de, super::DdElementTypeContent> for DdElementTypeContentDeserializer { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::DdElementTypeContent> { - let deserializer = Self { - state__: Box::new(DdElementTypeContentDeserializerState::Init__), - }; - let mut output = deserializer.next(helper, event)?; - output.artifact = match output.artifact { - DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, DdElementTypeContentDeserializerState::Init__) => - { - DeserializerArtifact::None - } - artifact => artifact, - }; - Ok(output) - } - fn next( - mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::DdElementTypeContent> { - use DdElementTypeContentDeserializerState as S; - let mut event = event; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::Block(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_block(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Inline(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_inline(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Text(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_text(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (state, event @ Event::End(_)) => { - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(Self::finish_state( - helper, state, - )?), - event: DeserializerEvent::Continue(event), - allow_any: false, - }); - } - (S::Init__, event) => match self.find_suitable(helper, event)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - }, - ( - S::Block(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = - ::init(helper, event)?; - match self.handle_block(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::Inline(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = - ::init(helper, event)?; - match self.handle_inline(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::Text(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = ::init(helper, event)?; - match self.handle_text(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (state @ S::Done__(_), event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); - } - } - }; - let artifact = if matches!(&*self.state__, S::Done__(_)) { - DeserializerArtifact::Data(self.finish(helper)?) - } else { - DeserializerArtifact::Deserializer(self) - }; - Ok(DeserializerOutput { - artifact, - event, - allow_any, - }) - } - fn finish( - self, - helper: &mut DeserializeHelper, - ) -> Result { - Self::finish_state(helper, *self.state__) - } - } - #[derive(Debug)] pub struct TableElementTypeDeserializer { id: Option, class: Option, @@ -205761,7 +206222,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"caption", - false, + true, )?; match self.handle_caption(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -205791,7 +206252,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"thead", - false, + true, )?; match self.handle_thead(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -205808,7 +206269,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"tfoot", - false, + true, )?; match self.handle_tfoot(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -205884,26 +206345,37 @@ pub mod onix { } } #[derive(Debug)] - pub struct BdoElementTypeDeserializer { + pub struct AElementTypeDeserializer { id: Option, class: Option, style: Option, title: Option, lang: Option, - dir: super::Dir, - text_before: Option, - inline: Vec>, - state__: Box, + dir: Option, + charset: Option, + type_: Option, + name: Option, + href: Option, + hreflang: Option, + rel: Option, + rev: Option, + accesskey: Option, + shape: super::Shape, + coords: Option, + tabindex: Option, + onfocus: Option, + onblur: Option, + content: Vec, + state__: Box, } #[derive(Debug)] - enum BdoElementTypeDeserializerState { + enum AElementTypeDeserializerState { Init__, - TextBefore(Option<::Deserializer>), - Inline(Option< as WithDeserializer>::Deserializer>), - Done__, + Next__, + Content__(::Deserializer), Unknown__, } - impl BdoElementTypeDeserializer { + impl AElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -205914,6 +206386,19 @@ pub mod onix { let mut title: Option = None; let mut lang: Option = None; let mut dir: Option = None; + let mut charset: Option = None; + let mut type_: Option = None; + let mut name: Option = None; + let mut href: Option = None; + let mut hreflang: Option = None; + let mut rel: Option = None; + let mut rev: Option = None; + let mut accesskey: Option = None; + let mut shape: Option = None; + let mut coords: Option = None; + let mut tabindex: Option = None; + let mut onfocus: Option = None; + let mut onblur: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( @@ -205946,462 +206431,71 @@ pub mod onix { Some(b"dir") ) { helper.read_attrib(&mut dir, b"dir", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; - } - } - Ok(Self { - id: id, - class: class, - style: style, - title: title, - lang: lang, - dir: dir.ok_or_else(|| ErrorKind::MissingAttribute("dir".into()))?, - text_before: None, - inline: Vec::new(), - state__: Box::new(BdoElementTypeDeserializerState::Init__), - }) - } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: BdoElementTypeDeserializerState, - ) -> Result<(), Error> { - use BdoElementTypeDeserializerState as S; - match state { - S::TextBefore(Some(deserializer)) => { - self.store_text_before(deserializer.finish(helper)?)? - } - S::Inline(Some(deserializer)) => { - self.store_inline(deserializer.finish(helper)?)? - } - _ => (), - } - Ok(()) - } - fn store_text_before(&mut self, value: Text) -> Result<(), Error> { - if self.text_before.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"text_before", - )))?; - } - self.text_before = Some(value); - Ok(()) - } - fn store_inline(&mut self, value: Mixed) -> Result<(), Error> { - self.inline.push(value); - Ok(()) - } - fn handle_text_before<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, Text>, - fallback: &mut Option, - ) -> Result, Error> { - use BdoElementTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::Inline(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_text_before(data)?; - *self.state__ = S::Inline(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::TextBefore(Some(deserializer))); - *self.state__ = S::Inline(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - fn handle_inline<'de>( - &mut self, - helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, Mixed>, - fallback: &mut Option, - ) -> Result, Error> { - use BdoElementTypeDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_inline(data)?; - *self.state__ = S::Inline(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Inline(Some(deserializer))); - *self.state__ = S::Inline(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - } - } - } - impl<'de> Deserializer<'de, super::BdoElementType> for BdoElementTypeDeserializer { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::BdoElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::BdoElementType> { - use BdoElementTypeDeserializerState as S; - let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::TextBefore(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_text_before(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Inline(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_inline(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, - allow_any: false, - }); - } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::TextBefore(None); - event - } - (S::TextBefore(None), event) => { - let output = ::init(helper, event)?; - match self.handle_text_before(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Inline(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = as WithDeserializer>::init( - helper, event, - )?; - match self.handle_inline(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); - } - (state, Event::Text(_) | Event::CData(_)) => { - *self.state__ = state; - break (DeserializerEvent::None, false); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Break(event), false); - } - } - }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), - event, - allow_any, - }) - } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - BdoElementTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::BdoElementType { - id: self.id, - class: self.class, - style: self.style, - title: self.title, - lang: self.lang, - dir: self.dir, - text_before: self.text_before, - inline: self.inline, - }) - } - } - #[derive(Debug)] - pub struct BrElementTypeDeserializer { - id: Option, - class: Option, - style: Option, - title: Option, - state__: Box, - } - #[derive(Debug)] - enum BrElementTypeDeserializerState { - Init__, - Unknown__, - } - impl BrElementTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut id: Option = None; - let mut class: Option = None; - let mut style: Option = None; - let mut title: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"id") - ) { - helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"class") - ) { - helper.read_attrib(&mut class, b"class", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"style") - ) { - helper.read_attrib(&mut style, b"style", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"title") - ) { - helper.read_attrib(&mut title, b"title", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; - } - } - Ok(Self { - id: id, - class: class, - style: style, - title: title, - state__: Box::new(BrElementTypeDeserializerState::Init__), - }) - } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: BrElementTypeDeserializerState, - ) -> Result<(), Error> { - Ok(()) - } - } - impl<'de> Deserializer<'de, super::BrElementType> for BrElementTypeDeserializer { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::BrElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::BrElementType> { - if let Event::End(_) = &event { - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, - allow_any: false, - }) - } else { - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), - event: DeserializerEvent::Break(event), - allow_any: false, - }) - } - } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - BrElementTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::BrElementType { - id: self.id, - class: self.class, - style: self.style, - title: self.title, - }) - } - } - #[derive(Debug)] - pub struct ImgElementTypeDeserializer { - id: Option, - class: Option, - style: Option, - title: Option, - lang: Option, - dir: Option, - src: String, - alt: String, - longdesc: Option, - height: Option, - width: Option, - usemap: Option, - ismap: Option, - state__: Box, - } - #[derive(Debug)] - enum ImgElementTypeDeserializerState { - Init__, - Unknown__, - } - impl ImgElementTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut id: Option = None; - let mut class: Option = None; - let mut style: Option = None; - let mut title: Option = None; - let mut lang: Option = None; - let mut dir: Option = None; - let mut src: Option = None; - let mut alt: Option = None; - let mut longdesc: Option = None; - let mut height: Option = None; - let mut width: Option = None; - let mut usemap: Option = None; - let mut ismap: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"id") + Some(b"charset") ) { - helper.read_attrib(&mut id, b"id", &attrib.value)?; + helper.read_attrib(&mut charset, b"charset", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"class") + Some(b"type") ) { - helper.read_attrib(&mut class, b"class", &attrib.value)?; + helper.read_attrib(&mut type_, b"type", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"style") + Some(b"name") ) { - helper.read_attrib(&mut style, b"style", &attrib.value)?; + helper.read_attrib(&mut name, b"name", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"title") + Some(b"href") ) { - helper.read_attrib(&mut title, b"title", &attrib.value)?; + helper.read_attrib(&mut href, b"href", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"lang") + Some(b"hreflang") ) { - helper.read_attrib(&mut lang, b"lang", &attrib.value)?; + helper.read_attrib(&mut hreflang, b"hreflang", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"dir") + Some(b"rel") ) { - helper.read_attrib(&mut dir, b"dir", &attrib.value)?; + helper.read_attrib(&mut rel, b"rel", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"src") + Some(b"rev") ) { - helper.read_attrib(&mut src, b"src", &attrib.value)?; + helper.read_attrib(&mut rev, b"rev", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"alt") + Some(b"accesskey") ) { - helper.read_attrib(&mut alt, b"alt", &attrib.value)?; + helper.read_attrib(&mut accesskey, b"accesskey", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"longdesc") + Some(b"shape") ) { - helper.read_attrib(&mut longdesc, b"longdesc", &attrib.value)?; + helper.read_attrib(&mut shape, b"shape", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"height") + Some(b"coords") ) { - helper.read_attrib(&mut height, b"height", &attrib.value)?; + helper.read_attrib(&mut coords, b"coords", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"width") + Some(b"tabindex") ) { - helper.read_attrib(&mut width, b"width", &attrib.value)?; + helper.read_attrib(&mut tabindex, b"tabindex", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"usemap") + Some(b"onfocus") ) { - helper.read_attrib(&mut usemap, b"usemap", &attrib.value)?; + helper.read_attrib(&mut onfocus, b"onfocus", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"ismap") + Some(b"onblur") ) { - helper.read_attrib(&mut ismap, b"ismap", &attrib.value)?; + helper.read_attrib(&mut onblur, b"onblur", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } @@ -206413,181 +206507,44 @@ pub mod onix { title: title, lang: lang, dir: dir, - src: src.ok_or_else(|| ErrorKind::MissingAttribute("src".into()))?, - alt: alt.ok_or_else(|| ErrorKind::MissingAttribute("alt".into()))?, - longdesc: longdesc, - height: height, - width: width, - usemap: usemap, - ismap: ismap, - state__: Box::new(ImgElementTypeDeserializerState::Init__), - }) - } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: ImgElementTypeDeserializerState, - ) -> Result<(), Error> { - Ok(()) - } - } - impl<'de> Deserializer<'de, super::ImgElementType> for ImgElementTypeDeserializer { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::ImgElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::ImgElementType> { - if let Event::End(_) = &event { - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, - allow_any: false, - }) - } else { - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), - event: DeserializerEvent::Break(event), - allow_any: false, - }) - } - } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - ImgElementTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::ImgElementType { - id: self.id, - class: self.class, - style: self.style, - title: self.title, - lang: self.lang, - dir: self.dir, - src: self.src, - alt: self.alt, - longdesc: self.longdesc, - height: self.height, - width: self.width, - usemap: self.usemap, - ismap: self.ismap, - }) - } - } - #[derive(Debug)] - pub struct MapElementTypeDeserializer { - lang: Option, - dir: Option, - id: String, - class: Option, - style: Option, - title: Option, - name: Option, - content: Vec, - state__: Box, - } - #[derive(Debug)] - enum MapElementTypeDeserializerState { - Init__, - Next__, - Content__(::Deserializer), - Unknown__, - } - impl MapElementTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut lang: Option = None; - let mut dir: Option = None; - let mut id: Option = None; - let mut class: Option = None; - let mut style: Option = None; - let mut title: Option = None; - let mut name: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"lang") - ) { - helper.read_attrib(&mut lang, b"lang", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"dir") - ) { - helper.read_attrib(&mut dir, b"dir", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"id") - ) { - helper.read_attrib(&mut id, b"id", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"class") - ) { - helper.read_attrib(&mut class, b"class", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"style") - ) { - helper.read_attrib(&mut style, b"style", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"title") - ) { - helper.read_attrib(&mut title, b"title", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"name") - ) { - helper.read_attrib(&mut name, b"name", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; - } - } - Ok(Self { - lang: lang, - dir: dir, - id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, - class: class, - style: style, - title: title, + charset: charset, + type_: type_, name: name, + href: href, + hreflang: hreflang, + rel: rel, + rev: rev, + accesskey: accesskey, + shape: shape.unwrap_or_else(super::AElementType::default_shape), + coords: coords, + tabindex: tabindex, + onfocus: onfocus, + onblur: onblur, content: Vec::new(), - state__: Box::new(MapElementTypeDeserializerState::Init__), + state__: Box::new(AElementTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: MapElementTypeDeserializerState, + state: AElementTypeDeserializerState, ) -> Result<(), Error> { - if let MapElementTypeDeserializerState::Content__(deserializer) = state { + if let AElementTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content(&mut self, value: super::MapElementTypeContent) -> Result<(), Error> { + fn store_content(&mut self, value: super::AElementTypeContent) -> Result<(), Error> { self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::MapElementTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::AElementTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use MapElementTypeDeserializerState as S; + use AElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -206615,19 +206572,19 @@ pub mod onix { } } } - impl<'de> Deserializer<'de, super::MapElementType> for MapElementTypeDeserializer { + impl<'de> Deserializer<'de, super::AElementType> for AElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::MapElementType> { + ) -> DeserializerResult<'de, super::AElementType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::MapElementType> { - use MapElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::AElementType> { + use AElementTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -206652,7 +206609,7 @@ pub mod onix { } (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); - let output = ::init( + let output = ::init( helper, event, )?; match self.handle_content(helper, output, &mut fallback)? { @@ -206677,45 +206634,69 @@ pub mod onix { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - MapElementTypeDeserializerState::Unknown__, - ); + ) -> Result { + let state = replace(&mut *self.state__, AElementTypeDeserializerState::Unknown__); self.finish_state(helper, state)?; - Ok(super::MapElementType { - lang: self.lang, - dir: self.dir, + Ok(super::AElementType { id: self.id, class: self.class, style: self.style, title: self.title, + lang: self.lang, + dir: self.dir, + charset: self.charset, + type_: self.type_, name: self.name, - content: helper.finish_vec(1usize, None, self.content)?, + href: self.href, + hreflang: self.hreflang, + rel: self.rel, + rev: self.rev, + accesskey: self.accesskey, + shape: self.shape, + coords: self.coords, + tabindex: self.tabindex, + onfocus: self.onfocus, + onblur: self.onblur, + content: helper.finish_vec(0usize, None, self.content)?, }) } } #[derive(Debug)] - pub struct MapElementTypeContentDeserializer { - state__: Box, + pub struct AElementTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - pub enum MapElementTypeContentDeserializerState { + pub enum AElementTypeContentDeserializerState { Init__, - Block( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Special( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Area( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Fontstyle( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Done__(super::MapElementTypeContent), + Phrase( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Gloss( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Text( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::AElementTypeContent), Unknown__, } - impl MapElementTypeContentDeserializer { + impl AElementTypeContentDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, @@ -206723,19 +206704,11 @@ pub mod onix { ) -> Result, Error> { let mut event = event; let mut allow_any_element = false; - if let Event::Start(x) | Event::Empty(x) = &event { - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"area") - ) { - let output = - ::init(helper, event)?; - return self.handle_area(helper, Default::default(), None, output); - } + if let Event::Start(_) | Event::Empty(_) = &event { event = { let output = - ::init(helper, event)?; - match self.handle_block(helper, Default::default(), None, output)? { + ::init(helper, event)?; + match self.handle_special(helper, Default::default(), None, output)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -206745,634 +206718,355 @@ pub mod onix { } } }; - } - *self.state__ = MapElementTypeContentDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent( - event, - allow_any_element, - )) - } - fn finish_state( - helper: &mut DeserializeHelper, - state: MapElementTypeContentDeserializerState, - ) -> Result { - use MapElementTypeContentDeserializerState as S; - match state { - S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Block(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_block(&mut values, value)?; - } - Ok(super::MapElementTypeContent::Block( - helper.finish_element("block", values)?, - )) - } - S::Area(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_area(&mut values, value)?; - } - Ok(super::MapElementTypeContent::Area( - helper.finish_element("area", values)?, - )) - } - S::Done__(data) => Ok(data), - _ => unreachable!(), - } - } - fn store_block( - values: &mut Option, - value: super::BlockElement, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"block", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_area( - values: &mut Option, - value: super::AreaElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"area")))?; - } - *values = Some(value); - Ok(()) - } - fn handle_block<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::BlockElement>, - ) -> Result, Error> { - use MapElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_block(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_block(&mut values, data)?; - let data = Self::finish_state(helper, S::Block(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Block(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_area<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AreaElementType>, - ) -> Result, Error> { - use MapElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_area(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_area(&mut values, data)?; - let data = Self::finish_state(helper, S::Area(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Area(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - } - impl<'de> Deserializer<'de, super::MapElementTypeContent> for MapElementTypeContentDeserializer { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::MapElementTypeContent> { - let deserializer = Self { - state__: Box::new(MapElementTypeContentDeserializerState::Init__), - }; - let mut output = deserializer.next(helper, event)?; - output.artifact = match output.artifact { - DeserializerArtifact::Deserializer(x) - if matches!( - &*x.state__, - MapElementTypeContentDeserializerState::Init__ - ) => - { - DeserializerArtifact::None - } - artifact => artifact, - }; - Ok(output) - } - fn next( - mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::MapElementTypeContent> { - use MapElementTypeContentDeserializerState as S; - let mut event = event; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::Block(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_block(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, + event = { + let output = + ::init(helper, event)?; + match self.handle_fontstyle(helper, Default::default(), None, output)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - } - (S::Area(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_area(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, + output => { + return Ok(output); } } - (state, event @ Event::End(_)) => { - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(Self::finish_state( - helper, state, - )?), - event: DeserializerEvent::Continue(event), - allow_any: false, - }); - } - (S::Init__, event) => match self.find_suitable(helper, event)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + }; + event = { + let output = + ::init(helper, event)?; + match self.handle_phrase(helper, Default::default(), None, output)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - }, - ( - S::Block(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = - ::init(helper, event)?; - match self.handle_block(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, + output => { + return Ok(output); } } - ( - S::Area(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_ONIX), - b"area", - false, - )?; - match self.handle_area(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, + }; + event = { + let output = + ::init(helper, event)?; + match self.handle_gloss(helper, Default::default(), None, output)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + output => { + return Ok(output); } } - (state @ S::Done__(_), event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); + }; + } + event = { + let output = ::init(helper, event)?; + match self.handle_text(helper, Default::default(), None, output)? { + ElementHandlerOutput::Continue { event, .. } => event, + output => { + return Ok(output); } } }; - let artifact = if matches!(&*self.state__, S::Done__(_)) { - DeserializerArtifact::Data(self.finish(helper)?) - } else { - DeserializerArtifact::Deserializer(self) - }; - Ok(DeserializerOutput { - artifact, + *self.state__ = AElementTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent( event, - allow_any, - }) - } - fn finish( - self, - helper: &mut DeserializeHelper, - ) -> Result { - Self::finish_state(helper, *self.state__) - } - } - #[derive(Debug)] - pub struct FontstyleElementDeserializer { - state__: Box, - } - #[derive(Debug)] - pub enum FontstyleElementDeserializerState { - Init__, - Tt( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - I( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - B( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Big( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Small( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Done__(super::FontstyleElement), - Unknown__, - } - impl FontstyleElementDeserializer { - fn find_suitable<'de>( - &mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> Result, Error> { - if let Event::Start(x) | Event::Empty(x) = &event { - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"tt") - ) { - let output = - ::init(helper, event)?; - return self.handle_tt(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"i") - ) { - let output = - ::init(helper, event)?; - return self.handle_i(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"b") - ) { - let output = - ::init(helper, event)?; - return self.handle_b(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"big") - ) { - let output = - ::init(helper, event)?; - return self.handle_big(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"small") - ) { - let output = - ::init(helper, event)?; - return self.handle_small(helper, Default::default(), None, output); - } - } - *self.state__ = FontstyleElementDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent(event, false)) + allow_any_element, + )) } fn finish_state( helper: &mut DeserializeHelper, - state: FontstyleElementDeserializerState, - ) -> Result { - use FontstyleElementDeserializerState as S; + state: AElementTypeContentDeserializerState, + ) -> Result { + use AElementTypeContentDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Tt(mut values, None, deserializer) => { + S::Special(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_tt(&mut values, value)?; + Self::store_special(&mut values, value)?; } - Ok(super::FontstyleElement::Tt(Box::new( - helper.finish_element("tt", values)?, - ))) + Ok(super::AElementTypeContent::Special( + helper.finish_element("special", values)?, + )) } - S::I(mut values, None, deserializer) => { + S::Fontstyle(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_i(&mut values, value)?; + Self::store_fontstyle(&mut values, value)?; } - Ok(super::FontstyleElement::I(Box::new( - helper.finish_element("i", values)?, - ))) + Ok(super::AElementTypeContent::Fontstyle( + helper.finish_element("fontstyle", values)?, + )) } - S::B(mut values, None, deserializer) => { + S::Phrase(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_b(&mut values, value)?; + Self::store_phrase(&mut values, value)?; } - Ok(super::FontstyleElement::B(Box::new( - helper.finish_element("b", values)?, - ))) + Ok(super::AElementTypeContent::Phrase( + helper.finish_element("phrase", values)?, + )) } - S::Big(mut values, None, deserializer) => { + S::Gloss(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_big(&mut values, value)?; + Self::store_gloss(&mut values, value)?; } - Ok(super::FontstyleElement::Big(Box::new( - helper.finish_element("big", values)?, - ))) + Ok(super::AElementTypeContent::Gloss( + helper.finish_element("gloss", values)?, + )) } - S::Small(mut values, None, deserializer) => { + S::Text(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_small(&mut values, value)?; + Self::store_text(&mut values, value)?; } - Ok(super::FontstyleElement::Small(Box::new( - helper.finish_element("small", values)?, - ))) + Ok(super::AElementTypeContent::Text( + helper.finish_element("text", values)?, + )) } S::Done__(data) => Ok(data), _ => unreachable!(), } } - fn store_tt( - values: &mut Option, - value: super::AbbrElementType, + fn store_special( + values: &mut Option, + value: super::SpecialElement, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"tt")))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"special", + )))?; } *values = Some(value); Ok(()) } - fn store_i( - values: &mut Option, - value: super::AbbrElementType, + fn store_fontstyle( + values: &mut Option, + value: super::FontstyleElement, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"i")))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"fontstyle", + )))?; } *values = Some(value); Ok(()) } - fn store_b( - values: &mut Option, - value: super::AbbrElementType, + fn store_phrase( + values: &mut Option, + value: super::PhraseElement, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"b")))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"phrase", + )))?; } *values = Some(value); Ok(()) } - fn store_big( - values: &mut Option, - value: super::AbbrElementType, + fn store_gloss( + values: &mut Option, + value: super::GlossElement, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"big")))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"gloss", + )))?; } *values = Some(value); Ok(()) } - fn store_small( - values: &mut Option, - value: super::AbbrElementType, - ) -> Result<(), Error> { + fn store_text(values: &mut Option, value: Text) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"small", - )))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"text")))?; } *values = Some(value); Ok(()) } - fn handle_tt<'de>( + fn handle_special<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AbbrElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::SpecialElement>, ) -> Result, Error> { - use FontstyleElementDeserializerState as S; + use AElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_tt(&mut values, data)?; + Self::store_special(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_tt(&mut values, data)?; - let data = Self::finish_state(helper, S::Tt(values, None, None))?; + Self::store_special(&mut values, data)?; + let data = Self::finish_state(helper, S::Special(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Tt(values, None, Some(deserializer)); + *self.state__ = S::Special(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_i<'de>( + fn handle_fontstyle<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AbbrElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FontstyleElement>, ) -> Result, Error> { - use FontstyleElementDeserializerState as S; + use AElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_i(&mut values, data)?; + Self::store_fontstyle(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_i(&mut values, data)?; - let data = Self::finish_state(helper, S::I(values, None, None))?; + Self::store_fontstyle(&mut values, data)?; + let data = Self::finish_state(helper, S::Fontstyle(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::I(values, None, Some(deserializer)); + *self.state__ = S::Fontstyle(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_b<'de>( + fn handle_phrase<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AbbrElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::PhraseElement>, ) -> Result, Error> { - use FontstyleElementDeserializerState as S; + use AElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_b(&mut values, data)?; + Self::store_phrase(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_b(&mut values, data)?; - let data = Self::finish_state(helper, S::B(values, None, None))?; + Self::store_phrase(&mut values, data)?; + let data = Self::finish_state(helper, S::Phrase(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::B(values, None, Some(deserializer)); + *self.state__ = S::Phrase(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_big<'de>( + fn handle_gloss<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AbbrElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::GlossElement>, ) -> Result, Error> { - use FontstyleElementDeserializerState as S; + use AElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_big(&mut values, data)?; + Self::store_gloss(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_big(&mut values, data)?; - let data = Self::finish_state(helper, S::Big(values, None, None))?; + Self::store_gloss(&mut values, data)?; + let data = Self::finish_state(helper, S::Gloss(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Big(values, None, Some(deserializer)); + *self.state__ = S::Gloss(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_small<'de>( + fn handle_text<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AbbrElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, Text>, ) -> Result, Error> { - use FontstyleElementDeserializerState as S; + use AElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_small(&mut values, data)?; + Self::store_text(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_small(&mut values, data)?; - let data = Self::finish_state(helper, S::Small(values, None, None))?; + Self::store_text(&mut values, data)?; + let data = Self::finish_state(helper, S::Text(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Small(values, None, Some(deserializer)); + *self.state__ = S::Text(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::FontstyleElement> for FontstyleElementDeserializer { + impl<'de> Deserializer<'de, super::AElementTypeContent> for AElementTypeContentDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::FontstyleElement> { + ) -> DeserializerResult<'de, super::AElementTypeContent> { let deserializer = Self { - state__: Box::new(FontstyleElementDeserializerState::Init__), + state__: Box::new(AElementTypeContentDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, FontstyleElementDeserializerState::Init__) => + if matches!(&*x.state__, AElementTypeContentDeserializerState::Init__) => { DeserializerArtifact::None } @@ -207384,52 +207078,52 @@ pub mod onix { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::FontstyleElement> { - use FontstyleElementDeserializerState as S; + ) -> DeserializerResult<'de, super::AElementTypeContent> { + use AElementTypeContentDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Tt(values, fallback, Some(deserializer)), event) => { + (S::Special(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_tt(helper, values, fallback, output)? { + match self.handle_special(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::I(values, fallback, Some(deserializer)), event) => { + (S::Fontstyle(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_i(helper, values, fallback, output)? { + match self.handle_fontstyle(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::B(values, fallback, Some(deserializer)), event) => { + (S::Phrase(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_b(helper, values, fallback, output)? { + match self.handle_phrase(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Big(values, fallback, Some(deserializer)), event) => { + (S::Gloss(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_big(helper, values, fallback, output)? { + match self.handle_gloss(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Small(values, fallback, Some(deserializer)), event) => { + (S::Text(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_small(helper, values, fallback, output)? { + match self.handle_text(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -207452,16 +207146,12 @@ pub mod onix { ElementHandlerOutput::Continue { event, .. } => event, }, ( - S::Tt(values, fallback, None), + S::Special(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_ONIX), - b"tt", - false, - )?; - match self.handle_tt(helper, values, fallback, output)? { + let output = + ::init(helper, event)?; + match self.handle_special(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -207469,16 +207159,12 @@ pub mod onix { } } ( - S::I(values, fallback, None), + S::Fontstyle(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_ONIX), - b"i", - false, - )?; - match self.handle_i(helper, values, fallback, output)? { + let output = + ::init(helper, event)?; + match self.handle_fontstyle(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -207486,16 +207172,12 @@ pub mod onix { } } ( - S::B(values, fallback, None), + S::Phrase(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_ONIX), - b"b", - false, - )?; - match self.handle_b(helper, values, fallback, output)? { + let output = + ::init(helper, event)?; + match self.handle_phrase(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -207503,16 +207185,12 @@ pub mod onix { } } ( - S::Big(values, fallback, None), + S::Gloss(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_ONIX), - b"big", - false, - )?; - match self.handle_big(helper, values, fallback, output)? { + let output = + ::init(helper, event)?; + match self.handle_gloss(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -207520,48 +207198,455 @@ pub mod onix { } } ( - S::Small(values, fallback, None), + S::Text(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_ONIX), - b"small", - false, - )?; - match self.handle_small(helper, values, fallback, output)? { + let output = ::init(helper, event)?; + match self.handle_text(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (state @ S::Done__(_), event) => { + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + } + }; + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish( + self, + helper: &mut DeserializeHelper, + ) -> Result { + Self::finish_state(helper, *self.state__) + } + } + #[derive(Debug)] + pub struct BdoElementTypeDeserializer { + id: Option, + class: Option, + style: Option, + title: Option, + lang: Option, + dir: super::Dir, + text_before: Option, + inline: Vec>, + state__: Box, + } + #[derive(Debug)] + enum BdoElementTypeDeserializerState { + Init__, + TextBefore(Option<::Deserializer>), + Inline(Option< as WithDeserializer>::Deserializer>), + Done__, + Unknown__, + } + impl BdoElementTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut class: Option = None; + let mut style: Option = None; + let mut title: Option = None; + let mut lang: Option = None; + let mut dir: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"class") + ) { + helper.read_attrib(&mut class, b"class", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"style") + ) { + helper.read_attrib(&mut style, b"style", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"title") + ) { + helper.read_attrib(&mut title, b"title", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"lang") + ) { + helper.read_attrib(&mut lang, b"lang", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"dir") + ) { + helper.read_attrib(&mut dir, b"dir", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id, + class: class, + style: style, + title: title, + lang: lang, + dir: dir.ok_or_else(|| ErrorKind::MissingAttribute("dir".into()))?, + text_before: None, + inline: Vec::new(), + state__: Box::new(BdoElementTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: BdoElementTypeDeserializerState, + ) -> Result<(), Error> { + use BdoElementTypeDeserializerState as S; + match state { + S::TextBefore(Some(deserializer)) => { + self.store_text_before(deserializer.finish(helper)?)? + } + S::Inline(Some(deserializer)) => { + self.store_inline(deserializer.finish(helper)?)? + } + _ => (), + } + Ok(()) + } + fn store_text_before(&mut self, value: Text) -> Result<(), Error> { + if self.text_before.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"text_before", + )))?; + } + self.text_before = Some(value); + Ok(()) + } + fn store_inline(&mut self, value: Mixed) -> Result<(), Error> { + self.inline.push(value); + Ok(()) + } + fn handle_text_before<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, Text>, + fallback: &mut Option, + ) -> Result, Error> { + use BdoElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Inline(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_text_before(data)?; + *self.state__ = S::Inline(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::TextBefore(Some(deserializer))); + *self.state__ = S::Inline(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_inline<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, Mixed>, + fallback: &mut Option, + ) -> Result, Error> { + use BdoElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_inline(data)?; + *self.state__ = S::Inline(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Inline(Some(deserializer))); + *self.state__ = S::Inline(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::BdoElementType> for BdoElementTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::BdoElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::BdoElementType> { + use BdoElementTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::TextBefore(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_text_before(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Inline(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_inline(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::TextBefore(None); + event + } + (S::TextBefore(None), event) => { + let output = ::init(helper, event)?; + match self.handle_text_before(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Inline(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = as WithDeserializer>::init( + helper, event, + )?; + match self.handle_inline(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, Event::Text(_) | Event::CData(_)) => { *self.state__ = state; - break (DeserializerEvent::Continue(event), false); + break (DeserializerEvent::None, false); } (state, event) => { *self.state__ = state; - break (DeserializerEvent::Continue(event), false); + break (DeserializerEvent::Break(event), false); } } }; - let artifact = if matches!(&*self.state__, S::Done__(_)) { - DeserializerArtifact::Data(self.finish(helper)?) - } else { - DeserializerArtifact::Deserializer(self) - }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } Ok(DeserializerOutput { - artifact, + artifact: DeserializerArtifact::Deserializer(self), event, allow_any, }) } fn finish( - self, + mut self, helper: &mut DeserializeHelper, - ) -> Result { - Self::finish_state(helper, *self.state__) + ) -> Result { + let state = replace( + &mut *self.state__, + BdoElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::BdoElementType { + id: self.id, + class: self.class, + style: self.style, + title: self.title, + lang: self.lang, + dir: self.dir, + text_before: self.text_before, + inline: self.inline, + }) + } + } + #[derive(Debug)] + pub struct BrElementTypeDeserializer { + id: Option, + class: Option, + style: Option, + title: Option, + state__: Box, + } + #[derive(Debug)] + enum BrElementTypeDeserializerState { + Init__, + Unknown__, + } + impl BrElementTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut class: Option = None; + let mut style: Option = None; + let mut title: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"class") + ) { + helper.read_attrib(&mut class, b"class", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"style") + ) { + helper.read_attrib(&mut style, b"style", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"title") + ) { + helper.read_attrib(&mut title, b"title", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id, + class: class, + style: style, + title: title, + state__: Box::new(BrElementTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: BrElementTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::BrElementType> for BrElementTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::BrElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::BrElementType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + BrElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::BrElementType { + id: self.id, + class: self.class, + style: self.style, + title: self.title, + }) } } #[derive(Debug)] @@ -207876,232 +207961,28 @@ pub mod onix { } } #[derive(Debug)] - pub struct GlossElementDeserializer { - state__: Box, - } - #[derive(Debug)] - pub enum GlossElementDeserializerState { - Init__, - Ruby( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Done__(super::GlossElement), - Unknown__, - } - impl GlossElementDeserializer { - fn find_suitable<'de>( - &mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> Result, Error> { - if let Event::Start(x) | Event::Empty(x) = &event { - if matches!( - helper.resolve_local_name(x.name(), &super::super::NS_ONIX), - Some(b"ruby") - ) { - let output = - ::init(helper, event)?; - return self.handle_ruby(helper, Default::default(), None, output); - } - } - *self.state__ = GlossElementDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent(event, false)) - } - fn finish_state( - helper: &mut DeserializeHelper, - state: GlossElementDeserializerState, - ) -> Result { - use GlossElementDeserializerState as S; - match state { - S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Ruby(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_ruby(&mut values, value)?; - } - Ok(super::GlossElement::Ruby( - helper.finish_element("ruby", values)?, - )) - } - S::Done__(data) => Ok(data), - _ => unreachable!(), - } - } - fn store_ruby( - values: &mut Option, - value: super::RubyElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"ruby")))?; - } - *values = Some(value); - Ok(()) - } - fn handle_ruby<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::RubyElementType>, - ) -> Result, Error> { - use GlossElementDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_ruby(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_ruby(&mut values, data)?; - let data = Self::finish_state(helper, S::Ruby(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Ruby(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - } - impl<'de> Deserializer<'de, super::GlossElement> for GlossElementDeserializer { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::GlossElement> { - let deserializer = Self { - state__: Box::new(GlossElementDeserializerState::Init__), - }; - let mut output = deserializer.next(helper, event)?; - output.artifact = match output.artifact { - DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, GlossElementDeserializerState::Init__) => - { - DeserializerArtifact::None - } - artifact => artifact, - }; - Ok(output) - } - fn next( - mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::GlossElement> { - use GlossElementDeserializerState as S; - let mut event = event; - let (event, allow_any) = loop { - let state = replace(&mut *self.state__, S::Unknown__); - event = match (state, event) { - (S::Unknown__, _) => unreachable!(), - (S::Ruby(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_ruby(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (state, event @ Event::End(_)) => { - return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(Self::finish_state( - helper, state, - )?), - event: DeserializerEvent::Continue(event), - allow_any: false, - }); - } - (S::Init__, event) => match self.find_suitable(helper, event)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - }, - ( - S::Ruby(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::super::NS_ONIX), - b"ruby", - false, - )?; - match self.handle_ruby(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (state @ S::Done__(_), event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); - } - } - }; - let artifact = if matches!(&*self.state__, S::Done__(_)) { - DeserializerArtifact::Data(self.finish(helper)?) - } else { - DeserializerArtifact::Deserializer(self) - }; - Ok(DeserializerOutput { - artifact, - event, - allow_any, - }) - } - fn finish(self, helper: &mut DeserializeHelper) -> Result { - Self::finish_state(helper, *self.state__) - } - } - #[derive(Debug)] - pub struct AElementTypeDeserializer { + pub struct ImgElementTypeDeserializer { id: Option, class: Option, style: Option, title: Option, lang: Option, dir: Option, - charset: Option, - type_: Option, - name: Option, - href: Option, - hreflang: Option, - rel: Option, - rev: Option, - accesskey: Option, - shape: super::Shape, - coords: Option, - tabindex: Option, - onfocus: Option, - onblur: Option, - content: Vec, - state__: Box, + src: String, + alt: String, + longdesc: Option, + height: Option, + width: Option, + usemap: Option, + ismap: Option, + state__: Box, } #[derive(Debug)] - enum AElementTypeDeserializerState { + enum ImgElementTypeDeserializerState { Init__, - Next__, - Content__(::Deserializer), Unknown__, } - impl AElementTypeDeserializer { + impl ImgElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -208112,19 +207993,13 @@ pub mod onix { let mut title: Option = None; let mut lang: Option = None; let mut dir: Option = None; - let mut charset: Option = None; - let mut type_: Option = None; - let mut name: Option = None; - let mut href: Option = None; - let mut hreflang: Option = None; - let mut rel: Option = None; - let mut rev: Option = None; - let mut accesskey: Option = None; - let mut shape: Option = None; - let mut coords: Option = None; - let mut tabindex: Option = None; - let mut onfocus: Option = None; - let mut onblur: Option = None; + let mut src: Option = None; + let mut alt: Option = None; + let mut longdesc: Option = None; + let mut height: Option = None; + let mut width: Option = None; + let mut usemap: Option = None; + let mut ismap: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( @@ -208159,118 +208034,225 @@ pub mod onix { helper.read_attrib(&mut dir, b"dir", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"charset") + Some(b"src") ) { - helper.read_attrib(&mut charset, b"charset", &attrib.value)?; + helper.read_attrib(&mut src, b"src", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"type") + Some(b"alt") ) { - helper.read_attrib(&mut type_, b"type", &attrib.value)?; + helper.read_attrib(&mut alt, b"alt", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"name") + Some(b"longdesc") ) { - helper.read_attrib(&mut name, b"name", &attrib.value)?; + helper.read_attrib(&mut longdesc, b"longdesc", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"href") + Some(b"height") ) { - helper.read_attrib(&mut href, b"href", &attrib.value)?; + helper.read_attrib(&mut height, b"height", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"hreflang") + Some(b"width") ) { - helper.read_attrib(&mut hreflang, b"hreflang", &attrib.value)?; + helper.read_attrib(&mut width, b"width", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"rel") + Some(b"usemap") ) { - helper.read_attrib(&mut rel, b"rel", &attrib.value)?; + helper.read_attrib(&mut usemap, b"usemap", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"rev") + Some(b"ismap") ) { - helper.read_attrib(&mut rev, b"rev", &attrib.value)?; + helper.read_attrib(&mut ismap, b"ismap", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id, + class: class, + style: style, + title: title, + lang: lang, + dir: dir, + src: src.ok_or_else(|| ErrorKind::MissingAttribute("src".into()))?, + alt: alt.ok_or_else(|| ErrorKind::MissingAttribute("alt".into()))?, + longdesc: longdesc, + height: height, + width: width, + usemap: usemap, + ismap: ismap, + state__: Box::new(ImgElementTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: ImgElementTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::ImgElementType> for ImgElementTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ImgElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::ImgElementType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + ImgElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::ImgElementType { + id: self.id, + class: self.class, + style: self.style, + title: self.title, + lang: self.lang, + dir: self.dir, + src: self.src, + alt: self.alt, + longdesc: self.longdesc, + height: self.height, + width: self.width, + usemap: self.usemap, + ismap: self.ismap, + }) + } + } + #[derive(Debug)] + pub struct MapElementTypeDeserializer { + lang: Option, + dir: Option, + id: String, + class: Option, + style: Option, + title: Option, + name: Option, + content: Vec, + state__: Box, + } + #[derive(Debug)] + enum MapElementTypeDeserializerState { + Init__, + Next__, + Content__(::Deserializer), + Unknown__, + } + impl MapElementTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut lang: Option = None; + let mut dir: Option = None; + let mut id: Option = None; + let mut class: Option = None; + let mut style: Option = None; + let mut title: Option = None; + let mut name: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"lang") + ) { + helper.read_attrib(&mut lang, b"lang", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"accesskey") + Some(b"dir") ) { - helper.read_attrib(&mut accesskey, b"accesskey", &attrib.value)?; + helper.read_attrib(&mut dir, b"dir", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"shape") + Some(b"id") ) { - helper.read_attrib(&mut shape, b"shape", &attrib.value)?; + helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"coords") + Some(b"class") ) { - helper.read_attrib(&mut coords, b"coords", &attrib.value)?; + helper.read_attrib(&mut class, b"class", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"tabindex") + Some(b"style") ) { - helper.read_attrib(&mut tabindex, b"tabindex", &attrib.value)?; + helper.read_attrib(&mut style, b"style", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"onfocus") + Some(b"title") ) { - helper.read_attrib(&mut onfocus, b"onfocus", &attrib.value)?; + helper.read_attrib(&mut title, b"title", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"onblur") + Some(b"name") ) { - helper.read_attrib(&mut onblur, b"onblur", &attrib.value)?; + helper.read_attrib(&mut name, b"name", &attrib.value)?; } else { helper.raise_unexpected_attrib_checked(&attrib)?; } } Ok(Self { - id: id, + lang: lang, + dir: dir, + id: id.ok_or_else(|| ErrorKind::MissingAttribute("id".into()))?, class: class, style: style, title: title, - lang: lang, - dir: dir, - charset: charset, - type_: type_, name: name, - href: href, - hreflang: hreflang, - rel: rel, - rev: rev, - accesskey: accesskey, - shape: shape.unwrap_or_else(super::AElementType::default_shape), - coords: coords, - tabindex: tabindex, - onfocus: onfocus, - onblur: onblur, content: Vec::new(), - state__: Box::new(AElementTypeDeserializerState::Init__), + state__: Box::new(MapElementTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: AElementTypeDeserializerState, + state: MapElementTypeDeserializerState, ) -> Result<(), Error> { - if let AElementTypeDeserializerState::Content__(deserializer) = state { + if let MapElementTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content(&mut self, value: super::AElementTypeContent) -> Result<(), Error> { + fn store_content(&mut self, value: super::MapElementTypeContent) -> Result<(), Error> { self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::AElementTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::MapElementTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use AElementTypeDeserializerState as S; + use MapElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -208298,19 +208280,19 @@ pub mod onix { } } } - impl<'de> Deserializer<'de, super::AElementType> for AElementTypeDeserializer { + impl<'de> Deserializer<'de, super::MapElementType> for MapElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AElementType> { + ) -> DeserializerResult<'de, super::MapElementType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AElementType> { - use AElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::MapElementType> { + use MapElementTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -208335,7 +208317,7 @@ pub mod onix { } (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); - let output = ::init( + let output = ::init( helper, event, )?; match self.handle_content(helper, output, &mut fallback)? { @@ -208360,69 +208342,45 @@ pub mod onix { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace(&mut *self.state__, AElementTypeDeserializerState::Unknown__); + ) -> Result { + let state = replace( + &mut *self.state__, + MapElementTypeDeserializerState::Unknown__, + ); self.finish_state(helper, state)?; - Ok(super::AElementType { + Ok(super::MapElementType { + lang: self.lang, + dir: self.dir, id: self.id, class: self.class, style: self.style, title: self.title, - lang: self.lang, - dir: self.dir, - charset: self.charset, - type_: self.type_, name: self.name, - href: self.href, - hreflang: self.hreflang, - rel: self.rel, - rev: self.rev, - accesskey: self.accesskey, - shape: self.shape, - coords: self.coords, - tabindex: self.tabindex, - onfocus: self.onfocus, - onblur: self.onblur, - content: helper.finish_vec(0usize, None, self.content)?, + content: helper.finish_vec(1usize, None, self.content)?, }) } } #[derive(Debug)] - pub struct AElementTypeContentDeserializer { - state__: Box, + pub struct MapElementTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - pub enum AElementTypeContentDeserializerState { + pub enum MapElementTypeContentDeserializerState { Init__, - Special( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Fontstyle( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Phrase( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Gloss( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Block( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Text( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Area( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Done__(super::AElementTypeContent), + Done__(super::MapElementTypeContent), Unknown__, } - impl AElementTypeContentDeserializer { + impl MapElementTypeContentDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, @@ -208430,50 +208388,19 @@ pub mod onix { ) -> Result, Error> { let mut event = event; let mut allow_any_element = false; - if let Event::Start(_) | Event::Empty(_) = &event { - event = { - let output = - ::init(helper, event)?; - match self.handle_special(helper, Default::default(), None, output)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - output => { - return Ok(output); - } - } - }; - event = { - let output = - ::init(helper, event)?; - match self.handle_fontstyle(helper, Default::default(), None, output)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - output => { - return Ok(output); - } - } - }; - event = { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"area") + ) { let output = - ::init(helper, event)?; - match self.handle_phrase(helper, Default::default(), None, output)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - output => { - return Ok(output); - } - } - }; + ::init(helper, event)?; + return self.handle_area(helper, Default::default(), None, output); + } event = { let output = - ::init(helper, event)?; - match self.handle_gloss(helper, Default::default(), None, output)? { + ::init(helper, event)?; + match self.handle_block(helper, Default::default(), None, output)? { ElementHandlerOutput::Continue { event, allow_any } => { allow_any_element = allow_any_element || allow_any; event @@ -208484,16 +208411,7 @@ pub mod onix { } }; } - event = { - let output = ::init(helper, event)?; - match self.handle_text(helper, Default::default(), None, output)? { - ElementHandlerOutput::Continue { event, .. } => event, - output => { - return Ok(output); - } - } - }; - *self.state__ = AElementTypeContentDeserializerState::Init__; + *self.state__ = MapElementTypeContentDeserializerState::Init__; Ok(ElementHandlerOutput::return_to_parent( event, allow_any_element, @@ -208501,225 +208419,63 @@ pub mod onix { } fn finish_state( helper: &mut DeserializeHelper, - state: AElementTypeContentDeserializerState, - ) -> Result { - use AElementTypeContentDeserializerState as S; + state: MapElementTypeContentDeserializerState, + ) -> Result { + use MapElementTypeContentDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Special(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_special(&mut values, value)?; - } - Ok(super::AElementTypeContent::Special( - helper.finish_element("special", values)?, - )) - } - S::Fontstyle(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_fontstyle(&mut values, value)?; - } - Ok(super::AElementTypeContent::Fontstyle( - helper.finish_element("fontstyle", values)?, - )) - } - S::Phrase(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_phrase(&mut values, value)?; - } - Ok(super::AElementTypeContent::Phrase( - helper.finish_element("phrase", values)?, - )) - } - S::Gloss(mut values, None, deserializer) => { + S::Block(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_gloss(&mut values, value)?; + Self::store_block(&mut values, value)?; } - Ok(super::AElementTypeContent::Gloss( - helper.finish_element("gloss", values)?, + Ok(super::MapElementTypeContent::Block( + helper.finish_element("block", values)?, )) } - S::Text(mut values, None, deserializer) => { + S::Area(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_text(&mut values, value)?; + Self::store_area(&mut values, value)?; } - Ok(super::AElementTypeContent::Text( - helper.finish_element("text", values)?, + Ok(super::MapElementTypeContent::Area( + helper.finish_element("area", values)?, )) } S::Done__(data) => Ok(data), _ => unreachable!(), } } - fn store_special( - values: &mut Option, - value: super::SpecialElement, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"special", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_fontstyle( - values: &mut Option, - value: super::FontstyleElement, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"fontstyle", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_phrase( - values: &mut Option, - value: super::PhraseElement, + fn store_block( + values: &mut Option, + value: super::BlockElement, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"phrase", + b"block", )))?; } *values = Some(value); Ok(()) } - fn store_gloss( - values: &mut Option, - value: super::GlossElement, + fn store_area( + values: &mut Option, + value: super::AreaElementType, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"gloss", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_text(values: &mut Option, value: Text) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"text")))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"area")))?; } *values = Some(value); Ok(()) } - fn handle_special<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::SpecialElement>, - ) -> Result, Error> { - use AElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_special(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_special(&mut values, data)?; - let data = Self::finish_state(helper, S::Special(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Special(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_fontstyle<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FontstyleElement>, - ) -> Result, Error> { - use AElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_fontstyle(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_fontstyle(&mut values, data)?; - let data = Self::finish_state(helper, S::Fontstyle(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Fontstyle(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_phrase<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::PhraseElement>, - ) -> Result, Error> { - use AElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_phrase(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_phrase(&mut values, data)?; - let data = Self::finish_state(helper, S::Phrase(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Phrase(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_gloss<'de>( + fn handle_block<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GlossElement>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::BlockElement>, ) -> Result, Error> { - use AElementTypeContentDeserializerState as S; + use MapElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -208730,69 +208486,72 @@ pub mod onix { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_gloss(&mut values, data)?; + Self::store_block(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_gloss(&mut values, data)?; - let data = Self::finish_state(helper, S::Gloss(values, None, None))?; + Self::store_block(&mut values, data)?; + let data = Self::finish_state(helper, S::Block(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Gloss(values, None, Some(deserializer)); + *self.state__ = S::Block(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_text<'de>( + fn handle_area<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, Text>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AreaElementType>, ) -> Result, Error> { - use AElementTypeContentDeserializerState as S; + use MapElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_text(&mut values, data)?; + Self::store_area(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_text(&mut values, data)?; - let data = Self::finish_state(helper, S::Text(values, None, None))?; + Self::store_area(&mut values, data)?; + let data = Self::finish_state(helper, S::Area(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Text(values, None, Some(deserializer)); + *self.state__ = S::Area(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::AElementTypeContent> for AElementTypeContentDeserializer { + impl<'de> Deserializer<'de, super::MapElementTypeContent> for MapElementTypeContentDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AElementTypeContent> { + ) -> DeserializerResult<'de, super::MapElementTypeContent> { let deserializer = Self { - state__: Box::new(AElementTypeContentDeserializerState::Init__), + state__: Box::new(MapElementTypeContentDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, AElementTypeContentDeserializerState::Init__) => + if matches!( + &*x.state__, + MapElementTypeContentDeserializerState::Init__ + ) => { DeserializerArtifact::None } @@ -208804,52 +208563,25 @@ pub mod onix { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AElementTypeContent> { - use AElementTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::MapElementTypeContent> { + use MapElementTypeContentDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Special(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_special(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Fontstyle(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_fontstyle(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Phrase(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_phrase(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Gloss(values, fallback, Some(deserializer)), event) => { + (S::Block(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_gloss(helper, values, fallback, output)? { + match self.handle_block(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Text(values, fallback, Some(deserializer)), event) => { + (S::Area(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_text(helper, values, fallback, output)? { + match self.handle_area(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -208872,51 +208604,12 @@ pub mod onix { ElementHandlerOutput::Continue { event, .. } => event, }, ( - S::Special(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = - ::init(helper, event)?; - match self.handle_special(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::Fontstyle(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = - ::init(helper, event)?; - match self.handle_fontstyle(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::Phrase(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = - ::init(helper, event)?; - match self.handle_phrase(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::Gloss(values, fallback, None), + S::Block(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = - ::init(helper, event)?; - match self.handle_gloss(helper, values, fallback, output)? { + ::init(helper, event)?; + match self.handle_block(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -208924,11 +208617,16 @@ pub mod onix { } } ( - S::Text(values, fallback, None), + S::Area(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = ::init(helper, event)?; - match self.handle_text(helper, values, fallback, output)? { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"area", + false, + )?; + match self.handle_area(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -208959,7 +208657,7 @@ pub mod onix { fn finish( self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { Self::finish_state(helper, *self.state__) } } @@ -216603,7 +216301,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"FeatureNote", - false, + true, )?; match self.handle_feature_note(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -244452,7 +244150,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"em", - false, + true, )?; match self.handle_em(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244469,7 +244167,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"strong", - false, + true, )?; match self.handle_strong(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244486,7 +244184,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"dfn", - false, + true, )?; match self.handle_dfn(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244503,7 +244201,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"code", - false, + true, )?; match self.handle_code(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244520,7 +244218,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"samp", - false, + true, )?; match self.handle_samp(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244537,7 +244235,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"kbd", - false, + true, )?; match self.handle_kbd(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244554,7 +244252,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"var", - false, + true, )?; match self.handle_var(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244571,7 +244269,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"cite", - false, + true, )?; match self.handle_cite(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244588,7 +244286,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"abbr", - false, + true, )?; match self.handle_abbr(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244605,7 +244303,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"acronym", - false, + true, )?; match self.handle_acronym(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244622,7 +244320,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"q", - false, + true, )?; match self.handle_q(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244639,7 +244337,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"sub", - false, + true, )?; match self.handle_sub(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244656,7 +244354,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"sup", - false, + true, )?; match self.handle_sup(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -244691,6 +244389,201 @@ pub mod onix { } } #[derive(Debug)] + pub struct GlossElementDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum GlossElementDeserializerState { + Init__, + Ruby( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::GlossElement), + Unknown__, + } + impl GlossElementDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"ruby") + ) { + let output = + ::init(helper, event)?; + return self.handle_ruby(helper, Default::default(), None, output); + } + } + *self.state__ = GlossElementDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: GlossElementDeserializerState, + ) -> Result { + use GlossElementDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Ruby(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_ruby(&mut values, value)?; + } + Ok(super::GlossElement::Ruby( + helper.finish_element("ruby", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_ruby( + values: &mut Option, + value: super::RubyElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"ruby")))?; + } + *values = Some(value); + Ok(()) + } + fn handle_ruby<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::RubyElementType>, + ) -> Result, Error> { + use GlossElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_ruby(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_ruby(&mut values, data)?; + let data = Self::finish_state(helper, S::Ruby(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Ruby(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::GlossElement> for GlossElementDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::GlossElement> { + let deserializer = Self { + state__: Box::new(GlossElementDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, GlossElementDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::GlossElement> { + use GlossElementDeserializerState as S; + let mut event = event; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Ruby(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_ruby(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state, event @ Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Ruby(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"ruby", + true, + )?; + match self.handle_ruby(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + } + }; + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + Self::finish_state(helper, *self.state__) + } + } + #[derive(Debug)] pub struct TableContent48Deserializer { state__: Box, } @@ -245211,7 +245104,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"tr", - false, + true, )?; match self.handle_tr(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -245522,7 +245415,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"tbody", - false, + true, )?; match self.handle_tbody(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -245539,7 +245432,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"tr", - false, + true, )?; match self.handle_tr(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -245577,176 +245470,6 @@ pub mod onix { } } #[derive(Debug)] - pub struct AreaElementTypeDeserializer { - id: Option, - class: Option, - style: Option, - title: Option, - lang: Option, - dir: Option, - shape: super::Shape, - coords: Option, - href: Option, - nohref: Option, - alt: String, - state__: Box, - } - #[derive(Debug)] - enum AreaElementTypeDeserializerState { - Init__, - Unknown__, - } - impl AreaElementTypeDeserializer { - fn from_bytes_start( - helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut id: Option = None; - let mut class: Option = None; - let mut style: Option = None; - let mut title: Option = None; - let mut lang: Option = None; - let mut dir: Option = None; - let mut shape: Option = None; - let mut coords: Option = None; - let mut href: Option = None; - let mut nohref: Option = None; - let mut alt: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; - if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"id") - ) { - helper.read_attrib(&mut id, b"id", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"class") - ) { - helper.read_attrib(&mut class, b"class", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"style") - ) { - helper.read_attrib(&mut style, b"style", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"title") - ) { - helper.read_attrib(&mut title, b"title", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"lang") - ) { - helper.read_attrib(&mut lang, b"lang", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"dir") - ) { - helper.read_attrib(&mut dir, b"dir", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"shape") - ) { - helper.read_attrib(&mut shape, b"shape", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"coords") - ) { - helper.read_attrib(&mut coords, b"coords", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"href") - ) { - helper.read_attrib(&mut href, b"href", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"nohref") - ) { - helper.read_attrib(&mut nohref, b"nohref", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), - Some(b"alt") - ) { - helper.read_attrib(&mut alt, b"alt", &attrib.value)?; - } else { - helper.raise_unexpected_attrib_checked(&attrib)?; - } - } - Ok(Self { - id: id, - class: class, - style: style, - title: title, - lang: lang, - dir: dir, - shape: shape.unwrap_or_else(super::AreaElementType::default_shape), - coords: coords, - href: href, - nohref: nohref, - alt: alt.ok_or_else(|| ErrorKind::MissingAttribute("alt".into()))?, - state__: Box::new(AreaElementTypeDeserializerState::Init__), - }) - } - fn finish_state( - &mut self, - helper: &mut DeserializeHelper, - state: AreaElementTypeDeserializerState, - ) -> Result<(), Error> { - Ok(()) - } - } - impl<'de> Deserializer<'de, super::AreaElementType> for AreaElementTypeDeserializer { - fn init( - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::AreaElementType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) - } - fn next( - mut self, - helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::AreaElementType> { - if let Event::End(_) = &event { - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, - allow_any: false, - }) - } else { - Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), - event: DeserializerEvent::Break(event), - allow_any: false, - }) - } - } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - AreaElementTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::AreaElementType { - id: self.id, - class: self.class, - style: self.style, - title: self.title, - lang: self.lang, - dir: self.dir, - shape: self.shape, - coords: self.coords, - href: self.href, - nohref: self.nohref, - alt: self.alt, - }) - } - } - #[derive(Debug)] pub struct SpecialElementDeserializer { state__: Box, } @@ -246207,7 +245930,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"span", - false, + true, )?; match self.handle_span(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -246224,7 +245947,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"bdo", - false, + true, )?; match self.handle_bdo(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -246275,7 +245998,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"map", - false, + true, )?; match self.handle_map(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -246308,11 +246031,749 @@ pub mod onix { fn finish( self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { + Self::finish_state(helper, *self.state__) + } + } + #[derive(Debug)] + pub struct FontstyleElementDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum FontstyleElementDeserializerState { + Init__, + Tt( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + I( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + B( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Big( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Small( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::FontstyleElement), + Unknown__, + } + impl FontstyleElementDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"tt") + ) { + let output = + ::init(helper, event)?; + return self.handle_tt(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"i") + ) { + let output = + ::init(helper, event)?; + return self.handle_i(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"b") + ) { + let output = + ::init(helper, event)?; + return self.handle_b(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"big") + ) { + let output = + ::init(helper, event)?; + return self.handle_big(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::super::NS_ONIX), + Some(b"small") + ) { + let output = + ::init(helper, event)?; + return self.handle_small(helper, Default::default(), None, output); + } + } + *self.state__ = FontstyleElementDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: FontstyleElementDeserializerState, + ) -> Result { + use FontstyleElementDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Tt(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_tt(&mut values, value)?; + } + Ok(super::FontstyleElement::Tt(Box::new( + helper.finish_element("tt", values)?, + ))) + } + S::I(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_i(&mut values, value)?; + } + Ok(super::FontstyleElement::I(Box::new( + helper.finish_element("i", values)?, + ))) + } + S::B(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_b(&mut values, value)?; + } + Ok(super::FontstyleElement::B(Box::new( + helper.finish_element("b", values)?, + ))) + } + S::Big(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_big(&mut values, value)?; + } + Ok(super::FontstyleElement::Big(Box::new( + helper.finish_element("big", values)?, + ))) + } + S::Small(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_small(&mut values, value)?; + } + Ok(super::FontstyleElement::Small(Box::new( + helper.finish_element("small", values)?, + ))) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_tt( + values: &mut Option, + value: super::AbbrElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"tt")))?; + } + *values = Some(value); + Ok(()) + } + fn store_i( + values: &mut Option, + value: super::AbbrElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"i")))?; + } + *values = Some(value); + Ok(()) + } + fn store_b( + values: &mut Option, + value: super::AbbrElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"b")))?; + } + *values = Some(value); + Ok(()) + } + fn store_big( + values: &mut Option, + value: super::AbbrElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"big")))?; + } + *values = Some(value); + Ok(()) + } + fn store_small( + values: &mut Option, + value: super::AbbrElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"small", + )))?; + } + *values = Some(value); + Ok(()) + } + fn handle_tt<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AbbrElementType>, + ) -> Result, Error> { + use FontstyleElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_tt(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_tt(&mut values, data)?; + let data = Self::finish_state(helper, S::Tt(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Tt(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_i<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AbbrElementType>, + ) -> Result, Error> { + use FontstyleElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_i(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_i(&mut values, data)?; + let data = Self::finish_state(helper, S::I(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::I(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_b<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AbbrElementType>, + ) -> Result, Error> { + use FontstyleElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_b(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_b(&mut values, data)?; + let data = Self::finish_state(helper, S::B(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::B(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_big<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AbbrElementType>, + ) -> Result, Error> { + use FontstyleElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_big(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_big(&mut values, data)?; + let data = Self::finish_state(helper, S::Big(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Big(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_small<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AbbrElementType>, + ) -> Result, Error> { + use FontstyleElementDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_small(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_small(&mut values, data)?; + let data = Self::finish_state(helper, S::Small(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Small(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::FontstyleElement> for FontstyleElementDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::FontstyleElement> { + let deserializer = Self { + state__: Box::new(FontstyleElementDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, FontstyleElementDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::FontstyleElement> { + use FontstyleElementDeserializerState as S; + let mut event = event; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Tt(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_tt(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::I(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_i(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::B(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_b(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Big(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_big(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Small(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_small(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state, event @ Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Tt(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"tt", + true, + )?; + match self.handle_tt(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::I(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"i", + true, + )?; + match self.handle_i(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::B(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"b", + true, + )?; + match self.handle_b(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Big(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"big", + true, + )?; + match self.handle_big(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Small(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::super::NS_ONIX), + b"small", + true, + )?; + match self.handle_small(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + } + }; + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish( + self, + helper: &mut DeserializeHelper, + ) -> Result { Self::finish_state(helper, *self.state__) } } #[derive(Debug)] + pub struct AreaElementTypeDeserializer { + id: Option, + class: Option, + style: Option, + title: Option, + lang: Option, + dir: Option, + shape: super::Shape, + coords: Option, + href: Option, + nohref: Option, + alt: String, + state__: Box, + } + #[derive(Debug)] + enum AreaElementTypeDeserializerState { + Init__, + Unknown__, + } + impl AreaElementTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut id: Option = None; + let mut class: Option = None; + let mut style: Option = None; + let mut title: Option = None; + let mut lang: Option = None; + let mut dir: Option = None; + let mut shape: Option = None; + let mut coords: Option = None; + let mut href: Option = None; + let mut nohref: Option = None; + let mut alt: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"class") + ) { + helper.read_attrib(&mut class, b"class", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"style") + ) { + helper.read_attrib(&mut style, b"style", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"title") + ) { + helper.read_attrib(&mut title, b"title", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"lang") + ) { + helper.read_attrib(&mut lang, b"lang", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"dir") + ) { + helper.read_attrib(&mut dir, b"dir", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"shape") + ) { + helper.read_attrib(&mut shape, b"shape", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"coords") + ) { + helper.read_attrib(&mut coords, b"coords", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"href") + ) { + helper.read_attrib(&mut href, b"href", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"nohref") + ) { + helper.read_attrib(&mut nohref, b"nohref", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::super::NS_ONIX), + Some(b"alt") + ) { + helper.read_attrib(&mut alt, b"alt", &attrib.value)?; + } else { + helper.raise_unexpected_attrib_checked(&attrib)?; + } + } + Ok(Self { + id: id, + class: class, + style: style, + title: title, + lang: lang, + dir: dir, + shape: shape.unwrap_or_else(super::AreaElementType::default_shape), + coords: coords, + href: href, + nohref: nohref, + alt: alt.ok_or_else(|| ErrorKind::MissingAttribute("alt".into()))?, + state__: Box::new(AreaElementTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: AreaElementTypeDeserializerState, + ) -> Result<(), Error> { + Ok(()) + } + } + impl<'de> Deserializer<'de, super::AreaElementType> for AreaElementTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AreaElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AreaElementType> { + if let Event::End(_) = &event { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }) + } else { + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event: DeserializerEvent::Break(event), + allow_any: false, + }) + } + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + AreaElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::AreaElementType { + id: self.id, + class: self.class, + style: self.style, + title: self.title, + lang: self.lang, + dir: self.dir, + shape: self.shape, + coords: self.coords, + href: self.href, + nohref: self.nohref, + alt: self.alt, + }) + } + } + #[derive(Debug)] pub struct RubyContent59Deserializer { rb: Option, content_60: Option, @@ -246511,7 +246972,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"rb", - false, + true, )?; match self.handle_rb(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -246761,7 +247222,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"rbc", - false, + true, )?; match self.handle_rbc(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -246778,7 +247239,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"rtc", - false, + true, )?; match self.handle_rtc(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -269688,7 +270149,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"th", - false, + true, )?; match self.handle_th(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -269705,7 +270166,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"td", - false, + true, )?; match self.handle_td(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -270430,7 +270891,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"a", - false, + true, )?; match self.handle_a(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -270766,7 +271227,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"rt", - false, + true, )?; match self.handle_rt(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -271002,7 +271463,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"rb", - false, + true, )?; match self.handle_rb(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -271242,7 +271703,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"rt", - false, + true, )?; match self.handle_rt(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -280719,7 +281180,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"a", - false, + true, )?; match self.handle_a(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { @@ -281019,7 +281480,7 @@ pub mod onix { event, Some(&super::super::NS_ONIX), b"rt", - false, + true, )?; match self.handle_rt(helper, output, &mut fallback)? { ElementHandlerOutput::Continue { event, allow_any } => { @@ -286796,7 +287257,7 @@ pub mod onix { BytesEnd, BytesStart, Error, Event, IterSerializer, SerializeHelper, Serializer, WithSerializer, }, - xml::{Mixed, Text}, + xml::{AnyElement, Mixed, Text}, }; #[derive(Debug)] pub struct OnixMessageElementTypeSerializer<'ser> { @@ -311726,6 +312187,11 @@ pub mod onix { #[derive(Debug)] pub(super) enum BlockElementSerializerState<'ser> { Init__, + Heading(::Serializer<'ser>), + Lists(::Serializer<'ser>), + Blocktext(::Serializer<'ser>), + Div(::Serializer<'ser>), + P(::Serializer<'ser>), H1(::Serializer<'ser>), H2(::Serializer<'ser>), H3(::Serializer<'ser>), @@ -311739,8 +312205,6 @@ pub mod onix { Hr(::Serializer<'ser>), Pre(::Serializer<'ser>), Blockquote(::Serializer<'ser>), - Div(::Serializer<'ser>), - P(::Serializer<'ser>), Table(::Serializer<'ser>), Done__, Phantom__(&'ser ()), @@ -311753,6 +312217,31 @@ pub mod onix { loop { match &mut *self.state { BlockElementSerializerState::Init__ => match self.value { + super::BlockElement::Heading(x) => { + *self.state = BlockElementSerializerState::Heading( + WithSerializer::serializer(x, Some("heading"), self.is_root)?, + ) + } + super::BlockElement::Lists(x) => { + *self.state = BlockElementSerializerState::Lists( + WithSerializer::serializer(x, Some("lists"), self.is_root)?, + ) + } + super::BlockElement::Blocktext(x) => { + *self.state = BlockElementSerializerState::Blocktext( + WithSerializer::serializer(x, Some("blocktext"), self.is_root)?, + ) + } + super::BlockElement::Div(x) => { + *self.state = BlockElementSerializerState::Div( + WithSerializer::serializer(x, Some("div"), self.is_root)?, + ) + } + super::BlockElement::P(x) => { + *self.state = BlockElementSerializerState::P( + WithSerializer::serializer(x, Some("p"), self.is_root)?, + ) + } super::BlockElement::H1(x) => { *self.state = BlockElementSerializerState::H1( WithSerializer::serializer(x, Some("h1"), self.is_root)?, @@ -311822,22 +312311,38 @@ pub mod onix { )?, ) } - super::BlockElement::Div(x) => { - *self.state = BlockElementSerializerState::Div( - WithSerializer::serializer(x, Some("div"), self.is_root)?, - ) - } - super::BlockElement::P(x) => { - *self.state = BlockElementSerializerState::P( - WithSerializer::serializer(x, Some("p"), self.is_root)?, - ) - } super::BlockElement::Table(x) => { *self.state = BlockElementSerializerState::Table( WithSerializer::serializer(x, Some("table"), self.is_root)?, ) } }, + BlockElementSerializerState::Heading(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = BlockElementSerializerState::Done__, + } + } + BlockElementSerializerState::Lists(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = BlockElementSerializerState::Done__, + } + } + BlockElementSerializerState::Blocktext(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = BlockElementSerializerState::Done__, + } + } + BlockElementSerializerState::Div(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = BlockElementSerializerState::Done__, + }, + BlockElementSerializerState::P(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = BlockElementSerializerState::Done__, + }, BlockElementSerializerState::H1(x) => match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = BlockElementSerializerState::Done__, @@ -311894,14 +312399,6 @@ pub mod onix { None => *self.state = BlockElementSerializerState::Done__, } } - BlockElementSerializerState::Div(x) => match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = BlockElementSerializerState::Done__, - }, - BlockElementSerializerState::P(x) => match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = BlockElementSerializerState::Done__, - }, BlockElementSerializerState::Table(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), @@ -311935,12 +312432,14 @@ pub mod onix { #[derive(Debug)] pub(super) enum InlineElementSerializerState<'ser> { Init__, + Special(::Serializer<'ser>), + Fontstyle(::Serializer<'ser>), + Phrase(::Serializer<'ser>), + Gloss(::Serializer<'ser>), + A(::Serializer<'ser>), Span(::Serializer<'ser>), Bdo(::Serializer<'ser>), Br(::Serializer<'ser>), - Img(::Serializer<'ser>), - Map(::Serializer<'ser>), - Fontstyle(::Serializer<'ser>), Em(::Serializer<'ser>), Strong(::Serializer<'ser>), Dfn(::Serializer<'ser>), @@ -311954,13 +312453,13 @@ pub mod onix { Q(::Serializer<'ser>), Sub(::Serializer<'ser>), Sup(::Serializer<'ser>), - Gloss(::Serializer<'ser>), - A(::Serializer<'ser>), Tt(::Serializer<'ser>), I(::Serializer<'ser>), B(::Serializer<'ser>), Big(::Serializer<'ser>), Small(::Serializer<'ser>), + Img(::Serializer<'ser>), + Map(::Serializer<'ser>), Ruby(::Serializer<'ser>), Done__, Phantom__(&'ser ()), @@ -311973,6 +312472,31 @@ pub mod onix { loop { match &mut *self.state { InlineElementSerializerState::Init__ => match self.value { + super::InlineElement::Special(x) => { + *self.state = InlineElementSerializerState::Special( + WithSerializer::serializer(x, Some("special"), self.is_root)?, + ) + } + super::InlineElement::Fontstyle(x) => { + *self.state = InlineElementSerializerState::Fontstyle( + WithSerializer::serializer(x, Some("fontstyle"), self.is_root)?, + ) + } + super::InlineElement::Phrase(x) => { + *self.state = InlineElementSerializerState::Phrase( + WithSerializer::serializer(x, Some("phrase"), self.is_root)?, + ) + } + super::InlineElement::Gloss(x) => { + *self.state = InlineElementSerializerState::Gloss( + WithSerializer::serializer(x, Some("gloss"), self.is_root)?, + ) + } + super::InlineElement::A(x) => { + *self.state = InlineElementSerializerState::A( + WithSerializer::serializer(x, Some("a"), self.is_root)?, + ) + } super::InlineElement::Span(x) => { *self.state = InlineElementSerializerState::Span( WithSerializer::serializer(x, Some("span"), self.is_root)?, @@ -311988,21 +312512,6 @@ pub mod onix { WithSerializer::serializer(x, Some("br"), self.is_root)?, ) } - super::InlineElement::Img(x) => { - *self.state = InlineElementSerializerState::Img( - WithSerializer::serializer(x, Some("img"), self.is_root)?, - ) - } - super::InlineElement::Map(x) => { - *self.state = InlineElementSerializerState::Map( - WithSerializer::serializer(x, Some("map"), self.is_root)?, - ) - } - super::InlineElement::Fontstyle(x) => { - *self.state = InlineElementSerializerState::Fontstyle( - WithSerializer::serializer(x, Some("fontstyle"), self.is_root)?, - ) - } super::InlineElement::Em(x) => { *self.state = InlineElementSerializerState::Em( WithSerializer::serializer(x, Some("em"), self.is_root)?, @@ -312068,16 +312577,6 @@ pub mod onix { WithSerializer::serializer(x, Some("sup"), self.is_root)?, ) } - super::InlineElement::Gloss(x) => { - *self.state = InlineElementSerializerState::Gloss( - WithSerializer::serializer(x, Some("gloss"), self.is_root)?, - ) - } - super::InlineElement::A(x) => { - *self.state = InlineElementSerializerState::A( - WithSerializer::serializer(x, Some("a"), self.is_root)?, - ) - } super::InlineElement::Tt(x) => { *self.state = InlineElementSerializerState::Tt( WithSerializer::serializer(x, Some("tt"), self.is_root)?, @@ -312103,46 +312602,66 @@ pub mod onix { WithSerializer::serializer(x, Some("small"), self.is_root)?, ) } + super::InlineElement::Img(x) => { + *self.state = InlineElementSerializerState::Img( + WithSerializer::serializer(x, Some("img"), self.is_root)?, + ) + } + super::InlineElement::Map(x) => { + *self.state = InlineElementSerializerState::Map( + WithSerializer::serializer(x, Some("map"), self.is_root)?, + ) + } super::InlineElement::Ruby(x) => { *self.state = InlineElementSerializerState::Ruby( WithSerializer::serializer(x, Some("ruby"), self.is_root)?, ) } }, - InlineElementSerializerState::Span(x) => { + InlineElementSerializerState::Special(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = InlineElementSerializerState::Done__, } } - InlineElementSerializerState::Bdo(x) => { + InlineElementSerializerState::Fontstyle(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = InlineElementSerializerState::Done__, } } - InlineElementSerializerState::Br(x) => match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = InlineElementSerializerState::Done__, - }, - InlineElementSerializerState::Img(x) => { + InlineElementSerializerState::Phrase(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = InlineElementSerializerState::Done__, } } - InlineElementSerializerState::Map(x) => { + InlineElementSerializerState::Gloss(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = InlineElementSerializerState::Done__, } } - InlineElementSerializerState::Fontstyle(x) => { + InlineElementSerializerState::A(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = InlineElementSerializerState::Done__, + }, + InlineElementSerializerState::Span(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = InlineElementSerializerState::Done__, } } + InlineElementSerializerState::Bdo(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = InlineElementSerializerState::Done__, + } + } + InlineElementSerializerState::Br(x) => match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = InlineElementSerializerState::Done__, + }, InlineElementSerializerState::Em(x) => match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = InlineElementSerializerState::Done__, @@ -312217,16 +312736,6 @@ pub mod onix { None => *self.state = InlineElementSerializerState::Done__, } } - InlineElementSerializerState::Gloss(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = InlineElementSerializerState::Done__, - } - } - InlineElementSerializerState::A(x) => match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = InlineElementSerializerState::Done__, - }, InlineElementSerializerState::Tt(x) => match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), None => *self.state = InlineElementSerializerState::Done__, @@ -312251,6 +312760,18 @@ pub mod onix { None => *self.state = InlineElementSerializerState::Done__, } } + InlineElementSerializerState::Img(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = InlineElementSerializerState::Done__, + } + } + InlineElementSerializerState::Map(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = InlineElementSerializerState::Done__, + } + } InlineElementSerializerState::Ruby(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), @@ -328500,6 +329021,154 @@ pub mod onix { } } #[derive(Debug)] + pub struct DdElementTypeSerializer<'ser> { + pub(super) value: &'ser super::DdElementType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum DdElementTypeSerializerState<'ser> { + Init__, + Content__( + IterSerializer< + 'ser, + &'ser [super::DdElementTypeContent], + super::DdElementTypeContent, + >, + ), + End__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> DdElementTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + DdElementTypeSerializerState::Init__ => { + *self.state = DdElementTypeSerializerState::Content__( + IterSerializer::new(&self.value.content[..], None, false), + ); + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns(&mut bytes, None, &super::super::NS_ONIX); + } + helper.write_attrib_opt(&mut bytes, "id", &self.value.id)?; + helper.write_attrib_opt(&mut bytes, "class", &self.value.class)?; + helper.write_attrib_opt(&mut bytes, "style", &self.value.style)?; + helper.write_attrib_opt(&mut bytes, "title", &self.value.title)?; + helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?; + helper.write_attrib_opt(&mut bytes, "dir", &self.value.dir)?; + return Ok(Some(Event::Start(bytes))); + } + DdElementTypeSerializerState::Content__(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = DdElementTypeSerializerState::End__, + } + } + DdElementTypeSerializerState::End__ => { + *self.state = DdElementTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); + } + DdElementTypeSerializerState::Done__ => return Ok(None), + DdElementTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for DdElementTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = DdElementTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct DdElementTypeContentSerializer<'ser> { + pub(super) value: &'ser super::DdElementTypeContent, + pub(super) state: Box>, + } + #[derive(Debug)] + pub(super) enum DdElementTypeContentSerializerState<'ser> { + Init__, + Block(::Serializer<'ser>), + Inline(::Serializer<'ser>), + Text(::Serializer<'ser>), + Done__, + Phantom__(&'ser ()), + } + impl<'ser> DdElementTypeContentSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + DdElementTypeContentSerializerState::Init__ => match self.value { + super::DdElementTypeContent::Block(x) => { + *self.state = DdElementTypeContentSerializerState::Block( + WithSerializer::serializer(x, Some("block"), false)?, + ) + } + super::DdElementTypeContent::Inline(x) => { + *self.state = DdElementTypeContentSerializerState::Inline( + WithSerializer::serializer(x, Some("inline"), false)?, + ) + } + super::DdElementTypeContent::Text(x) => { + *self.state = DdElementTypeContentSerializerState::Text( + WithSerializer::serializer(x, Some("text"), false)?, + ) + } + }, + DdElementTypeContentSerializerState::Block(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = DdElementTypeContentSerializerState::Done__, + } + } + DdElementTypeContentSerializerState::Inline(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = DdElementTypeContentSerializerState::Done__, + } + } + DdElementTypeContentSerializerState::Text(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = DdElementTypeContentSerializerState::Done__, + } + } + DdElementTypeContentSerializerState::Done__ => return Ok(None), + DdElementTypeContentSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for DdElementTypeContentSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = DdElementTypeContentSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] pub struct AbbrElementTypeSerializer<'ser> { pub(super) value: &'ser super::AbbrElementType, pub(super) state: Box>, @@ -329232,154 +329901,6 @@ pub mod onix { } } #[derive(Debug)] - pub struct DdElementTypeSerializer<'ser> { - pub(super) value: &'ser super::DdElementType, - pub(super) state: Box>, - pub(super) name: &'ser str, - pub(super) is_root: bool, - } - #[derive(Debug)] - pub(super) enum DdElementTypeSerializerState<'ser> { - Init__, - Content__( - IterSerializer< - 'ser, - &'ser [super::DdElementTypeContent], - super::DdElementTypeContent, - >, - ), - End__, - Done__, - Phantom__(&'ser ()), - } - impl<'ser> DdElementTypeSerializer<'ser> { - fn next_event( - &mut self, - helper: &mut SerializeHelper, - ) -> Result>, Error> { - loop { - match &mut *self.state { - DdElementTypeSerializerState::Init__ => { - *self.state = DdElementTypeSerializerState::Content__( - IterSerializer::new(&self.value.content[..], None, false), - ); - let mut bytes = BytesStart::new(self.name); - helper.begin_ns_scope(); - if self.is_root { - helper.write_xmlns(&mut bytes, None, &super::super::NS_ONIX); - } - helper.write_attrib_opt(&mut bytes, "id", &self.value.id)?; - helper.write_attrib_opt(&mut bytes, "class", &self.value.class)?; - helper.write_attrib_opt(&mut bytes, "style", &self.value.style)?; - helper.write_attrib_opt(&mut bytes, "title", &self.value.title)?; - helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?; - helper.write_attrib_opt(&mut bytes, "dir", &self.value.dir)?; - return Ok(Some(Event::Start(bytes))); - } - DdElementTypeSerializerState::Content__(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = DdElementTypeSerializerState::End__, - } - } - DdElementTypeSerializerState::End__ => { - *self.state = DdElementTypeSerializerState::Done__; - helper.end_ns_scope(); - return Ok(Some(Event::End(BytesEnd::new(self.name)))); - } - DdElementTypeSerializerState::Done__ => return Ok(None), - DdElementTypeSerializerState::Phantom__(_) => unreachable!(), - } - } - } - } - impl<'ser> Serializer<'ser> for DdElementTypeSerializer<'ser> { - fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { - match self.next_event(helper) { - Ok(Some(event)) => Some(Ok(event)), - Ok(None) => None, - Err(error) => { - *self.state = DdElementTypeSerializerState::Done__; - Some(Err(error)) - } - } - } - } - #[derive(Debug)] - pub struct DdElementTypeContentSerializer<'ser> { - pub(super) value: &'ser super::DdElementTypeContent, - pub(super) state: Box>, - } - #[derive(Debug)] - pub(super) enum DdElementTypeContentSerializerState<'ser> { - Init__, - Block(::Serializer<'ser>), - Inline(::Serializer<'ser>), - Text(::Serializer<'ser>), - Done__, - Phantom__(&'ser ()), - } - impl<'ser> DdElementTypeContentSerializer<'ser> { - fn next_event( - &mut self, - helper: &mut SerializeHelper, - ) -> Result>, Error> { - loop { - match &mut *self.state { - DdElementTypeContentSerializerState::Init__ => match self.value { - super::DdElementTypeContent::Block(x) => { - *self.state = DdElementTypeContentSerializerState::Block( - WithSerializer::serializer(x, Some("block"), false)?, - ) - } - super::DdElementTypeContent::Inline(x) => { - *self.state = DdElementTypeContentSerializerState::Inline( - WithSerializer::serializer(x, Some("inline"), false)?, - ) - } - super::DdElementTypeContent::Text(x) => { - *self.state = DdElementTypeContentSerializerState::Text( - WithSerializer::serializer(x, Some("text"), false)?, - ) - } - }, - DdElementTypeContentSerializerState::Block(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = DdElementTypeContentSerializerState::Done__, - } - } - DdElementTypeContentSerializerState::Inline(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = DdElementTypeContentSerializerState::Done__, - } - } - DdElementTypeContentSerializerState::Text(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = DdElementTypeContentSerializerState::Done__, - } - } - DdElementTypeContentSerializerState::Done__ => return Ok(None), - DdElementTypeContentSerializerState::Phantom__(_) => unreachable!(), - } - } - } - } - impl<'ser> Serializer<'ser> for DdElementTypeContentSerializer<'ser> { - fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { - match self.next_event(helper) { - Ok(Some(event)) => Some(Ok(event)), - Ok(None) => None, - Err(error) => { - *self.state = DdElementTypeContentSerializerState::Done__; - Some(Err(error)) - } - } - } - } - #[derive(Debug)] pub struct TableElementTypeSerializer<'ser> { pub(super) value: &'ser super::TableElementType, pub(super) state: Box>, @@ -329540,41 +330061,37 @@ pub mod onix { } } #[derive(Debug)] - pub struct BdoElementTypeSerializer<'ser> { - pub(super) value: &'ser super::BdoElementType, - pub(super) state: Box>, + pub struct AElementTypeSerializer<'ser> { + pub(super) value: &'ser super::AElementType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum BdoElementTypeSerializerState<'ser> { + pub(super) enum AElementTypeSerializerState<'ser> { Init__, - TextBefore(IterSerializer<'ser, Option<&'ser Text>, Text>), - Inline( + Content__( IterSerializer< 'ser, - &'ser [Mixed], - Mixed, + &'ser [super::AElementTypeContent], + super::AElementTypeContent, >, ), End__, Done__, Phantom__(&'ser ()), } - impl<'ser> BdoElementTypeSerializer<'ser> { + impl<'ser> AElementTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - BdoElementTypeSerializerState::Init__ => { - *self.state = - BdoElementTypeSerializerState::TextBefore(IterSerializer::new( - self.value.text_before.as_ref(), - Some(""), - false, - )); + AElementTypeSerializerState::Init__ => { + *self.state = AElementTypeSerializerState::Content__( + IterSerializer::new(&self.value.content[..], None, false), + ); let mut bytes = BytesStart::new(self.name); helper.begin_ns_scope(); if self.is_root { @@ -329585,399 +330102,299 @@ pub mod onix { helper.write_attrib_opt(&mut bytes, "style", &self.value.style)?; helper.write_attrib_opt(&mut bytes, "title", &self.value.title)?; helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?; - helper.write_attrib(&mut bytes, "dir", &self.value.dir)?; + helper.write_attrib_opt(&mut bytes, "dir", &self.value.dir)?; + helper.write_attrib_opt(&mut bytes, "charset", &self.value.charset)?; + helper.write_attrib_opt(&mut bytes, "type", &self.value.type_)?; + helper.write_attrib_opt(&mut bytes, "name", &self.value.name)?; + helper.write_attrib_opt(&mut bytes, "href", &self.value.href)?; + helper.write_attrib_opt( + &mut bytes, + "hreflang", + &self.value.hreflang, + )?; + helper.write_attrib_opt(&mut bytes, "rel", &self.value.rel)?; + helper.write_attrib_opt(&mut bytes, "rev", &self.value.rev)?; + helper.write_attrib_opt( + &mut bytes, + "accesskey", + &self.value.accesskey, + )?; + helper.write_attrib(&mut bytes, "shape", &self.value.shape)?; + helper.write_attrib_opt(&mut bytes, "coords", &self.value.coords)?; + helper.write_attrib_opt( + &mut bytes, + "tabindex", + &self.value.tabindex, + )?; + helper.write_attrib_opt(&mut bytes, "onfocus", &self.value.onfocus)?; + helper.write_attrib_opt(&mut bytes, "onblur", &self.value.onblur)?; return Ok(Some(Event::Start(bytes))); } - BdoElementTypeSerializerState::TextBefore(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => { - *self.state = - BdoElementTypeSerializerState::Inline(IterSerializer::new( - &self.value.inline[..], - Some("inline"), - false, - )) - } - } - } - BdoElementTypeSerializerState::Inline(x) => { + AElementTypeSerializerState::Content__(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = BdoElementTypeSerializerState::End__, + None => *self.state = AElementTypeSerializerState::End__, } } - BdoElementTypeSerializerState::End__ => { - *self.state = BdoElementTypeSerializerState::Done__; + AElementTypeSerializerState::End__ => { + *self.state = AElementTypeSerializerState::Done__; helper.end_ns_scope(); return Ok(Some(Event::End(BytesEnd::new(self.name)))); } - BdoElementTypeSerializerState::Done__ => return Ok(None), - BdoElementTypeSerializerState::Phantom__(_) => unreachable!(), + AElementTypeSerializerState::Done__ => return Ok(None), + AElementTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for BdoElementTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for AElementTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = BdoElementTypeSerializerState::Done__; + *self.state = AElementTypeSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct BrElementTypeSerializer<'ser> { - pub(super) value: &'ser super::BrElementType, - pub(super) state: Box>, - pub(super) name: &'ser str, - pub(super) is_root: bool, + pub struct AElementTypeContentSerializer<'ser> { + pub(super) value: &'ser super::AElementTypeContent, + pub(super) state: Box>, } #[derive(Debug)] - pub(super) enum BrElementTypeSerializerState<'ser> { + pub(super) enum AElementTypeContentSerializerState<'ser> { Init__, + Special(::Serializer<'ser>), + Fontstyle(::Serializer<'ser>), + Phrase(::Serializer<'ser>), + Gloss(::Serializer<'ser>), + Text(::Serializer<'ser>), Done__, Phantom__(&'ser ()), } - impl<'ser> BrElementTypeSerializer<'ser> { + impl<'ser> AElementTypeContentSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - BrElementTypeSerializerState::Init__ => { - *self.state = BrElementTypeSerializerState::Done__; - let mut bytes = BytesStart::new(self.name); - helper.begin_ns_scope(); - if self.is_root { - helper.write_xmlns(&mut bytes, None, &super::super::NS_ONIX); + AElementTypeContentSerializerState::Init__ => match self.value { + super::AElementTypeContent::Special(x) => { + *self.state = AElementTypeContentSerializerState::Special( + WithSerializer::serializer(x, Some("special"), false)?, + ) + } + super::AElementTypeContent::Fontstyle(x) => { + *self.state = AElementTypeContentSerializerState::Fontstyle( + WithSerializer::serializer(x, Some("fontstyle"), false)?, + ) + } + super::AElementTypeContent::Phrase(x) => { + *self.state = AElementTypeContentSerializerState::Phrase( + WithSerializer::serializer(x, Some("phrase"), false)?, + ) + } + super::AElementTypeContent::Gloss(x) => { + *self.state = AElementTypeContentSerializerState::Gloss( + WithSerializer::serializer(x, Some("gloss"), false)?, + ) + } + super::AElementTypeContent::Text(x) => { + *self.state = AElementTypeContentSerializerState::Text( + WithSerializer::serializer(x, Some("text"), false)?, + ) + } + }, + AElementTypeContentSerializerState::Special(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AElementTypeContentSerializerState::Done__, } - helper.write_attrib_opt(&mut bytes, "id", &self.value.id)?; - helper.write_attrib_opt(&mut bytes, "class", &self.value.class)?; - helper.write_attrib_opt(&mut bytes, "style", &self.value.style)?; - helper.write_attrib_opt(&mut bytes, "title", &self.value.title)?; - helper.end_ns_scope(); - return Ok(Some(Event::Empty(bytes))); } - BrElementTypeSerializerState::Done__ => return Ok(None), - BrElementTypeSerializerState::Phantom__(_) => unreachable!(), - } - } - } - } - impl<'ser> Serializer<'ser> for BrElementTypeSerializer<'ser> { - fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { - match self.next_event(helper) { - Ok(Some(event)) => Some(Ok(event)), - Ok(None) => None, - Err(error) => { - *self.state = BrElementTypeSerializerState::Done__; - Some(Err(error)) - } - } - } - } - #[derive(Debug)] - pub struct ImgElementTypeSerializer<'ser> { - pub(super) value: &'ser super::ImgElementType, - pub(super) state: Box>, - pub(super) name: &'ser str, - pub(super) is_root: bool, - } - #[derive(Debug)] - pub(super) enum ImgElementTypeSerializerState<'ser> { - Init__, - Done__, - Phantom__(&'ser ()), - } - impl<'ser> ImgElementTypeSerializer<'ser> { - fn next_event( - &mut self, - helper: &mut SerializeHelper, - ) -> Result>, Error> { - loop { - match &mut *self.state { - ImgElementTypeSerializerState::Init__ => { - *self.state = ImgElementTypeSerializerState::Done__; - let mut bytes = BytesStart::new(self.name); - helper.begin_ns_scope(); - if self.is_root { - helper.write_xmlns(&mut bytes, None, &super::super::NS_ONIX); + AElementTypeContentSerializerState::Fontstyle(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AElementTypeContentSerializerState::Done__, } - helper.write_attrib_opt(&mut bytes, "id", &self.value.id)?; - helper.write_attrib_opt(&mut bytes, "class", &self.value.class)?; - helper.write_attrib_opt(&mut bytes, "style", &self.value.style)?; - helper.write_attrib_opt(&mut bytes, "title", &self.value.title)?; - helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?; - helper.write_attrib_opt(&mut bytes, "dir", &self.value.dir)?; - helper.write_attrib(&mut bytes, "src", &self.value.src)?; - helper.write_attrib(&mut bytes, "alt", &self.value.alt)?; - helper.write_attrib_opt( - &mut bytes, - "longdesc", - &self.value.longdesc, - )?; - helper.write_attrib_opt(&mut bytes, "height", &self.value.height)?; - helper.write_attrib_opt(&mut bytes, "width", &self.value.width)?; - helper.write_attrib_opt(&mut bytes, "usemap", &self.value.usemap)?; - helper.write_attrib_opt(&mut bytes, "ismap", &self.value.ismap)?; - helper.end_ns_scope(); - return Ok(Some(Event::Empty(bytes))); } - ImgElementTypeSerializerState::Done__ => return Ok(None), - ImgElementTypeSerializerState::Phantom__(_) => unreachable!(), + AElementTypeContentSerializerState::Phrase(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AElementTypeContentSerializerState::Done__, + } + } + AElementTypeContentSerializerState::Gloss(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AElementTypeContentSerializerState::Done__, + } + } + AElementTypeContentSerializerState::Text(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = AElementTypeContentSerializerState::Done__, + } + } + AElementTypeContentSerializerState::Done__ => return Ok(None), + AElementTypeContentSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for ImgElementTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for AElementTypeContentSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = ImgElementTypeSerializerState::Done__; + *self.state = AElementTypeContentSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct MapElementTypeSerializer<'ser> { - pub(super) value: &'ser super::MapElementType, - pub(super) state: Box>, + pub struct BdoElementTypeSerializer<'ser> { + pub(super) value: &'ser super::BdoElementType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum MapElementTypeSerializerState<'ser> { + pub(super) enum BdoElementTypeSerializerState<'ser> { Init__, - Content__( + TextBefore(IterSerializer<'ser, Option<&'ser Text>, Text>), + Inline( IterSerializer< 'ser, - &'ser [super::MapElementTypeContent], - super::MapElementTypeContent, + &'ser [Mixed], + Mixed, >, ), End__, Done__, Phantom__(&'ser ()), } - impl<'ser> MapElementTypeSerializer<'ser> { + impl<'ser> BdoElementTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - MapElementTypeSerializerState::Init__ => { - *self.state = MapElementTypeSerializerState::Content__( - IterSerializer::new(&self.value.content[..], None, false), - ); + BdoElementTypeSerializerState::Init__ => { + *self.state = + BdoElementTypeSerializerState::TextBefore(IterSerializer::new( + self.value.text_before.as_ref(), + Some(""), + false, + )); let mut bytes = BytesStart::new(self.name); helper.begin_ns_scope(); if self.is_root { helper.write_xmlns(&mut bytes, None, &super::super::NS_ONIX); } - helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?; - helper.write_attrib_opt(&mut bytes, "dir", &self.value.dir)?; - helper.write_attrib(&mut bytes, "id", &self.value.id)?; + helper.write_attrib_opt(&mut bytes, "id", &self.value.id)?; helper.write_attrib_opt(&mut bytes, "class", &self.value.class)?; helper.write_attrib_opt(&mut bytes, "style", &self.value.style)?; helper.write_attrib_opt(&mut bytes, "title", &self.value.title)?; - helper.write_attrib_opt(&mut bytes, "name", &self.value.name)?; + helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?; + helper.write_attrib(&mut bytes, "dir", &self.value.dir)?; return Ok(Some(Event::Start(bytes))); } - MapElementTypeSerializerState::Content__(x) => { + BdoElementTypeSerializerState::TextBefore(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = MapElementTypeSerializerState::End__, + None => { + *self.state = + BdoElementTypeSerializerState::Inline(IterSerializer::new( + &self.value.inline[..], + Some("inline"), + false, + )) + } } } - MapElementTypeSerializerState::End__ => { - *self.state = MapElementTypeSerializerState::Done__; - helper.end_ns_scope(); - return Ok(Some(Event::End(BytesEnd::new(self.name)))); - } - MapElementTypeSerializerState::Done__ => return Ok(None), - MapElementTypeSerializerState::Phantom__(_) => unreachable!(), - } - } - } - } - impl<'ser> Serializer<'ser> for MapElementTypeSerializer<'ser> { - fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { - match self.next_event(helper) { - Ok(Some(event)) => Some(Ok(event)), - Ok(None) => None, - Err(error) => { - *self.state = MapElementTypeSerializerState::Done__; - Some(Err(error)) - } - } - } - } - #[derive(Debug)] - pub struct MapElementTypeContentSerializer<'ser> { - pub(super) value: &'ser super::MapElementTypeContent, - pub(super) state: Box>, - } - #[derive(Debug)] - pub(super) enum MapElementTypeContentSerializerState<'ser> { - Init__, - Block(::Serializer<'ser>), - Area(::Serializer<'ser>), - Done__, - Phantom__(&'ser ()), - } - impl<'ser> MapElementTypeContentSerializer<'ser> { - fn next_event( - &mut self, - helper: &mut SerializeHelper, - ) -> Result>, Error> { - loop { - match &mut *self.state { - MapElementTypeContentSerializerState::Init__ => match self.value { - super::MapElementTypeContent::Block(x) => { - *self.state = MapElementTypeContentSerializerState::Block( - WithSerializer::serializer(x, Some("block"), false)?, - ) - } - super::MapElementTypeContent::Area(x) => { - *self.state = MapElementTypeContentSerializerState::Area( - WithSerializer::serializer(x, Some("area"), false)?, - ) - } - }, - MapElementTypeContentSerializerState::Block(x) => { + BdoElementTypeSerializerState::Inline(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = MapElementTypeContentSerializerState::Done__, + None => *self.state = BdoElementTypeSerializerState::End__, } } - MapElementTypeContentSerializerState::Area(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = MapElementTypeContentSerializerState::Done__, - } + BdoElementTypeSerializerState::End__ => { + *self.state = BdoElementTypeSerializerState::Done__; + helper.end_ns_scope(); + return Ok(Some(Event::End(BytesEnd::new(self.name)))); } - MapElementTypeContentSerializerState::Done__ => return Ok(None), - MapElementTypeContentSerializerState::Phantom__(_) => unreachable!(), + BdoElementTypeSerializerState::Done__ => return Ok(None), + BdoElementTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for MapElementTypeContentSerializer<'ser> { + impl<'ser> Serializer<'ser> for BdoElementTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = MapElementTypeContentSerializerState::Done__; + *self.state = BdoElementTypeSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct FontstyleElementSerializer<'ser> { - pub(super) value: &'ser super::FontstyleElement, - pub(super) state: Box>, + pub struct BrElementTypeSerializer<'ser> { + pub(super) value: &'ser super::BrElementType, + pub(super) state: Box>, + pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum FontstyleElementSerializerState<'ser> { + pub(super) enum BrElementTypeSerializerState<'ser> { Init__, - Tt(::Serializer<'ser>), - I(::Serializer<'ser>), - B(::Serializer<'ser>), - Big(::Serializer<'ser>), - Small(::Serializer<'ser>), Done__, Phantom__(&'ser ()), } - impl<'ser> FontstyleElementSerializer<'ser> { + impl<'ser> BrElementTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - FontstyleElementSerializerState::Init__ => match self.value { - super::FontstyleElement::Tt(x) => { - *self.state = FontstyleElementSerializerState::Tt( - WithSerializer::serializer(&**x, Some("tt"), self.is_root)?, - ) - } - super::FontstyleElement::I(x) => { - *self.state = FontstyleElementSerializerState::I( - WithSerializer::serializer(&**x, Some("i"), self.is_root)?, - ) - } - super::FontstyleElement::B(x) => { - *self.state = FontstyleElementSerializerState::B( - WithSerializer::serializer(&**x, Some("b"), self.is_root)?, - ) - } - super::FontstyleElement::Big(x) => { - *self.state = FontstyleElementSerializerState::Big( - WithSerializer::serializer(&**x, Some("big"), self.is_root)?, - ) - } - super::FontstyleElement::Small(x) => { - *self.state = FontstyleElementSerializerState::Small( - WithSerializer::serializer(&**x, Some("small"), self.is_root)?, - ) - } - }, - FontstyleElementSerializerState::Tt(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = FontstyleElementSerializerState::Done__, - } - } - FontstyleElementSerializerState::I(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = FontstyleElementSerializerState::Done__, - } - } - FontstyleElementSerializerState::B(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = FontstyleElementSerializerState::Done__, - } - } - FontstyleElementSerializerState::Big(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = FontstyleElementSerializerState::Done__, - } - } - FontstyleElementSerializerState::Small(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = FontstyleElementSerializerState::Done__, + BrElementTypeSerializerState::Init__ => { + *self.state = BrElementTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns(&mut bytes, None, &super::super::NS_ONIX); } + helper.write_attrib_opt(&mut bytes, "id", &self.value.id)?; + helper.write_attrib_opt(&mut bytes, "class", &self.value.class)?; + helper.write_attrib_opt(&mut bytes, "style", &self.value.style)?; + helper.write_attrib_opt(&mut bytes, "title", &self.value.title)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); } - FontstyleElementSerializerState::Done__ => return Ok(None), - FontstyleElementSerializerState::Phantom__(_) => unreachable!(), + BrElementTypeSerializerState::Done__ => return Ok(None), + BrElementTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for FontstyleElementSerializer<'ser> { + impl<'ser> Serializer<'ser> for BrElementTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = FontstyleElementSerializerState::Done__; + *self.state = BrElementTypeSerializerState::Done__; Some(Err(error)) } } @@ -330076,86 +330493,100 @@ pub mod onix { } } #[derive(Debug)] - pub struct GlossElementSerializer<'ser> { - pub(super) value: &'ser super::GlossElement, - pub(super) state: Box>, + pub struct ImgElementTypeSerializer<'ser> { + pub(super) value: &'ser super::ImgElementType, + pub(super) state: Box>, + pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum GlossElementSerializerState<'ser> { + pub(super) enum ImgElementTypeSerializerState<'ser> { Init__, - Ruby(::Serializer<'ser>), Done__, Phantom__(&'ser ()), } - impl<'ser> GlossElementSerializer<'ser> { + impl<'ser> ImgElementTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - GlossElementSerializerState::Init__ => match self.value { - super::GlossElement::Ruby(x) => { - *self.state = GlossElementSerializerState::Ruby( - WithSerializer::serializer(x, Some("ruby"), self.is_root)?, - ) - } - }, - GlossElementSerializerState::Ruby(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = GlossElementSerializerState::Done__, + ImgElementTypeSerializerState::Init__ => { + *self.state = ImgElementTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns(&mut bytes, None, &super::super::NS_ONIX); } + helper.write_attrib_opt(&mut bytes, "id", &self.value.id)?; + helper.write_attrib_opt(&mut bytes, "class", &self.value.class)?; + helper.write_attrib_opt(&mut bytes, "style", &self.value.style)?; + helper.write_attrib_opt(&mut bytes, "title", &self.value.title)?; + helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?; + helper.write_attrib_opt(&mut bytes, "dir", &self.value.dir)?; + helper.write_attrib(&mut bytes, "src", &self.value.src)?; + helper.write_attrib(&mut bytes, "alt", &self.value.alt)?; + helper.write_attrib_opt( + &mut bytes, + "longdesc", + &self.value.longdesc, + )?; + helper.write_attrib_opt(&mut bytes, "height", &self.value.height)?; + helper.write_attrib_opt(&mut bytes, "width", &self.value.width)?; + helper.write_attrib_opt(&mut bytes, "usemap", &self.value.usemap)?; + helper.write_attrib_opt(&mut bytes, "ismap", &self.value.ismap)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); } - GlossElementSerializerState::Done__ => return Ok(None), - GlossElementSerializerState::Phantom__(_) => unreachable!(), + ImgElementTypeSerializerState::Done__ => return Ok(None), + ImgElementTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for GlossElementSerializer<'ser> { + impl<'ser> Serializer<'ser> for ImgElementTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = GlossElementSerializerState::Done__; + *self.state = ImgElementTypeSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct AElementTypeSerializer<'ser> { - pub(super) value: &'ser super::AElementType, - pub(super) state: Box>, + pub struct MapElementTypeSerializer<'ser> { + pub(super) value: &'ser super::MapElementType, + pub(super) state: Box>, pub(super) name: &'ser str, pub(super) is_root: bool, } #[derive(Debug)] - pub(super) enum AElementTypeSerializerState<'ser> { + pub(super) enum MapElementTypeSerializerState<'ser> { Init__, Content__( IterSerializer< 'ser, - &'ser [super::AElementTypeContent], - super::AElementTypeContent, + &'ser [super::MapElementTypeContent], + super::MapElementTypeContent, >, ), End__, Done__, Phantom__(&'ser ()), } - impl<'ser> AElementTypeSerializer<'ser> { + impl<'ser> MapElementTypeSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - AElementTypeSerializerState::Init__ => { - *self.state = AElementTypeSerializerState::Content__( + MapElementTypeSerializerState::Init__ => { + *self.state = MapElementTypeSerializerState::Content__( IterSerializer::new(&self.value.content[..], None, false), ); let mut bytes = BytesStart::new(self.name); @@ -330163,161 +330594,101 @@ pub mod onix { if self.is_root { helper.write_xmlns(&mut bytes, None, &super::super::NS_ONIX); } - helper.write_attrib_opt(&mut bytes, "id", &self.value.id)?; + helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?; + helper.write_attrib_opt(&mut bytes, "dir", &self.value.dir)?; + helper.write_attrib(&mut bytes, "id", &self.value.id)?; helper.write_attrib_opt(&mut bytes, "class", &self.value.class)?; helper.write_attrib_opt(&mut bytes, "style", &self.value.style)?; helper.write_attrib_opt(&mut bytes, "title", &self.value.title)?; - helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?; - helper.write_attrib_opt(&mut bytes, "dir", &self.value.dir)?; - helper.write_attrib_opt(&mut bytes, "charset", &self.value.charset)?; - helper.write_attrib_opt(&mut bytes, "type", &self.value.type_)?; helper.write_attrib_opt(&mut bytes, "name", &self.value.name)?; - helper.write_attrib_opt(&mut bytes, "href", &self.value.href)?; - helper.write_attrib_opt( - &mut bytes, - "hreflang", - &self.value.hreflang, - )?; - helper.write_attrib_opt(&mut bytes, "rel", &self.value.rel)?; - helper.write_attrib_opt(&mut bytes, "rev", &self.value.rev)?; - helper.write_attrib_opt( - &mut bytes, - "accesskey", - &self.value.accesskey, - )?; - helper.write_attrib(&mut bytes, "shape", &self.value.shape)?; - helper.write_attrib_opt(&mut bytes, "coords", &self.value.coords)?; - helper.write_attrib_opt( - &mut bytes, - "tabindex", - &self.value.tabindex, - )?; - helper.write_attrib_opt(&mut bytes, "onfocus", &self.value.onfocus)?; - helper.write_attrib_opt(&mut bytes, "onblur", &self.value.onblur)?; return Ok(Some(Event::Start(bytes))); } - AElementTypeSerializerState::Content__(x) => { + MapElementTypeSerializerState::Content__(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = AElementTypeSerializerState::End__, + None => *self.state = MapElementTypeSerializerState::End__, } } - AElementTypeSerializerState::End__ => { - *self.state = AElementTypeSerializerState::Done__; + MapElementTypeSerializerState::End__ => { + *self.state = MapElementTypeSerializerState::Done__; helper.end_ns_scope(); return Ok(Some(Event::End(BytesEnd::new(self.name)))); } - AElementTypeSerializerState::Done__ => return Ok(None), - AElementTypeSerializerState::Phantom__(_) => unreachable!(), + MapElementTypeSerializerState::Done__ => return Ok(None), + MapElementTypeSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for AElementTypeSerializer<'ser> { + impl<'ser> Serializer<'ser> for MapElementTypeSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = AElementTypeSerializerState::Done__; + *self.state = MapElementTypeSerializerState::Done__; Some(Err(error)) } } } } #[derive(Debug)] - pub struct AElementTypeContentSerializer<'ser> { - pub(super) value: &'ser super::AElementTypeContent, - pub(super) state: Box>, + pub struct MapElementTypeContentSerializer<'ser> { + pub(super) value: &'ser super::MapElementTypeContent, + pub(super) state: Box>, } #[derive(Debug)] - pub(super) enum AElementTypeContentSerializerState<'ser> { + pub(super) enum MapElementTypeContentSerializerState<'ser> { Init__, - Special(::Serializer<'ser>), - Fontstyle(::Serializer<'ser>), - Phrase(::Serializer<'ser>), - Gloss(::Serializer<'ser>), - Text(::Serializer<'ser>), + Block(::Serializer<'ser>), + Area(::Serializer<'ser>), Done__, Phantom__(&'ser ()), } - impl<'ser> AElementTypeContentSerializer<'ser> { + impl<'ser> MapElementTypeContentSerializer<'ser> { fn next_event( &mut self, helper: &mut SerializeHelper, ) -> Result>, Error> { loop { match &mut *self.state { - AElementTypeContentSerializerState::Init__ => match self.value { - super::AElementTypeContent::Special(x) => { - *self.state = AElementTypeContentSerializerState::Special( - WithSerializer::serializer(x, Some("special"), false)?, - ) - } - super::AElementTypeContent::Fontstyle(x) => { - *self.state = AElementTypeContentSerializerState::Fontstyle( - WithSerializer::serializer(x, Some("fontstyle"), false)?, - ) - } - super::AElementTypeContent::Phrase(x) => { - *self.state = AElementTypeContentSerializerState::Phrase( - WithSerializer::serializer(x, Some("phrase"), false)?, - ) - } - super::AElementTypeContent::Gloss(x) => { - *self.state = AElementTypeContentSerializerState::Gloss( - WithSerializer::serializer(x, Some("gloss"), false)?, + MapElementTypeContentSerializerState::Init__ => match self.value { + super::MapElementTypeContent::Block(x) => { + *self.state = MapElementTypeContentSerializerState::Block( + WithSerializer::serializer(x, Some("block"), false)?, ) } - super::AElementTypeContent::Text(x) => { - *self.state = AElementTypeContentSerializerState::Text( - WithSerializer::serializer(x, Some("text"), false)?, + super::MapElementTypeContent::Area(x) => { + *self.state = MapElementTypeContentSerializerState::Area( + WithSerializer::serializer(x, Some("area"), false)?, ) } }, - AElementTypeContentSerializerState::Special(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = AElementTypeContentSerializerState::Done__, - } - } - AElementTypeContentSerializerState::Fontstyle(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = AElementTypeContentSerializerState::Done__, - } - } - AElementTypeContentSerializerState::Phrase(x) => { - match x.next(helper).transpose()? { - Some(event) => return Ok(Some(event)), - None => *self.state = AElementTypeContentSerializerState::Done__, - } - } - AElementTypeContentSerializerState::Gloss(x) => { + MapElementTypeContentSerializerState::Block(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = AElementTypeContentSerializerState::Done__, + None => *self.state = MapElementTypeContentSerializerState::Done__, } } - AElementTypeContentSerializerState::Text(x) => { + MapElementTypeContentSerializerState::Area(x) => { match x.next(helper).transpose()? { Some(event) => return Ok(Some(event)), - None => *self.state = AElementTypeContentSerializerState::Done__, + None => *self.state = MapElementTypeContentSerializerState::Done__, } } - AElementTypeContentSerializerState::Done__ => return Ok(None), - AElementTypeContentSerializerState::Phantom__(_) => unreachable!(), + MapElementTypeContentSerializerState::Done__ => return Ok(None), + MapElementTypeContentSerializerState::Phantom__(_) => unreachable!(), } } } } - impl<'ser> Serializer<'ser> for AElementTypeContentSerializer<'ser> { + impl<'ser> Serializer<'ser> for MapElementTypeContentSerializer<'ser> { fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { match self.next_event(helper) { Ok(Some(event)) => Some(Ok(event)), Ok(None) => None, Err(error) => { - *self.state = AElementTypeContentSerializerState::Done__; + *self.state = MapElementTypeContentSerializerState::Done__; Some(Err(error)) } } @@ -341981,6 +342352,57 @@ pub mod onix { } } #[derive(Debug)] + pub struct GlossElementSerializer<'ser> { + pub(super) value: &'ser super::GlossElement, + pub(super) state: Box>, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum GlossElementSerializerState<'ser> { + Init__, + Ruby(::Serializer<'ser>), + Done__, + Phantom__(&'ser ()), + } + impl<'ser> GlossElementSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + GlossElementSerializerState::Init__ => match self.value { + super::GlossElement::Ruby(x) => { + *self.state = GlossElementSerializerState::Ruby( + WithSerializer::serializer(x, Some("ruby"), self.is_root)?, + ) + } + }, + GlossElementSerializerState::Ruby(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = GlossElementSerializerState::Done__, + } + } + GlossElementSerializerState::Done__ => return Ok(None), + GlossElementSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for GlossElementSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = GlossElementSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] pub struct TableContent48Serializer<'ser> { pub(super) value: &'ser super::TableContent48, pub(super) state: Box>, @@ -342187,65 +342609,6 @@ pub mod onix { } } #[derive(Debug)] - pub struct AreaElementTypeSerializer<'ser> { - pub(super) value: &'ser super::AreaElementType, - pub(super) state: Box>, - pub(super) name: &'ser str, - pub(super) is_root: bool, - } - #[derive(Debug)] - pub(super) enum AreaElementTypeSerializerState<'ser> { - Init__, - Done__, - Phantom__(&'ser ()), - } - impl<'ser> AreaElementTypeSerializer<'ser> { - fn next_event( - &mut self, - helper: &mut SerializeHelper, - ) -> Result>, Error> { - loop { - match &mut *self.state { - AreaElementTypeSerializerState::Init__ => { - *self.state = AreaElementTypeSerializerState::Done__; - let mut bytes = BytesStart::new(self.name); - helper.begin_ns_scope(); - if self.is_root { - helper.write_xmlns(&mut bytes, None, &super::super::NS_ONIX); - } - helper.write_attrib_opt(&mut bytes, "id", &self.value.id)?; - helper.write_attrib_opt(&mut bytes, "class", &self.value.class)?; - helper.write_attrib_opt(&mut bytes, "style", &self.value.style)?; - helper.write_attrib_opt(&mut bytes, "title", &self.value.title)?; - helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?; - helper.write_attrib_opt(&mut bytes, "dir", &self.value.dir)?; - helper.write_attrib(&mut bytes, "shape", &self.value.shape)?; - helper.write_attrib_opt(&mut bytes, "coords", &self.value.coords)?; - helper.write_attrib_opt(&mut bytes, "href", &self.value.href)?; - helper.write_attrib_opt(&mut bytes, "nohref", &self.value.nohref)?; - helper.write_attrib(&mut bytes, "alt", &self.value.alt)?; - helper.end_ns_scope(); - return Ok(Some(Event::Empty(bytes))); - } - AreaElementTypeSerializerState::Done__ => return Ok(None), - AreaElementTypeSerializerState::Phantom__(_) => unreachable!(), - } - } - } - } - impl<'ser> Serializer<'ser> for AreaElementTypeSerializer<'ser> { - fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { - match self.next_event(helper) { - Ok(Some(event)) => Some(Ok(event)), - Ok(None) => None, - Err(error) => { - *self.state = AreaElementTypeSerializerState::Done__; - Some(Err(error)) - } - } - } - } - #[derive(Debug)] pub struct SpecialElementSerializer<'ser> { pub(super) value: &'ser super::SpecialElement, pub(super) state: Box>, @@ -342345,6 +342708,164 @@ pub mod onix { } } #[derive(Debug)] + pub struct FontstyleElementSerializer<'ser> { + pub(super) value: &'ser super::FontstyleElement, + pub(super) state: Box>, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum FontstyleElementSerializerState<'ser> { + Init__, + Tt(::Serializer<'ser>), + I(::Serializer<'ser>), + B(::Serializer<'ser>), + Big(::Serializer<'ser>), + Small(::Serializer<'ser>), + Done__, + Phantom__(&'ser ()), + } + impl<'ser> FontstyleElementSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + FontstyleElementSerializerState::Init__ => match self.value { + super::FontstyleElement::Tt(x) => { + *self.state = FontstyleElementSerializerState::Tt( + WithSerializer::serializer(&**x, Some("tt"), self.is_root)?, + ) + } + super::FontstyleElement::I(x) => { + *self.state = FontstyleElementSerializerState::I( + WithSerializer::serializer(&**x, Some("i"), self.is_root)?, + ) + } + super::FontstyleElement::B(x) => { + *self.state = FontstyleElementSerializerState::B( + WithSerializer::serializer(&**x, Some("b"), self.is_root)?, + ) + } + super::FontstyleElement::Big(x) => { + *self.state = FontstyleElementSerializerState::Big( + WithSerializer::serializer(&**x, Some("big"), self.is_root)?, + ) + } + super::FontstyleElement::Small(x) => { + *self.state = FontstyleElementSerializerState::Small( + WithSerializer::serializer(&**x, Some("small"), self.is_root)?, + ) + } + }, + FontstyleElementSerializerState::Tt(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = FontstyleElementSerializerState::Done__, + } + } + FontstyleElementSerializerState::I(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = FontstyleElementSerializerState::Done__, + } + } + FontstyleElementSerializerState::B(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = FontstyleElementSerializerState::Done__, + } + } + FontstyleElementSerializerState::Big(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = FontstyleElementSerializerState::Done__, + } + } + FontstyleElementSerializerState::Small(x) => { + match x.next(helper).transpose()? { + Some(event) => return Ok(Some(event)), + None => *self.state = FontstyleElementSerializerState::Done__, + } + } + FontstyleElementSerializerState::Done__ => return Ok(None), + FontstyleElementSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for FontstyleElementSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = FontstyleElementSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] + pub struct AreaElementTypeSerializer<'ser> { + pub(super) value: &'ser super::AreaElementType, + pub(super) state: Box>, + pub(super) name: &'ser str, + pub(super) is_root: bool, + } + #[derive(Debug)] + pub(super) enum AreaElementTypeSerializerState<'ser> { + Init__, + Done__, + Phantom__(&'ser ()), + } + impl<'ser> AreaElementTypeSerializer<'ser> { + fn next_event( + &mut self, + helper: &mut SerializeHelper, + ) -> Result>, Error> { + loop { + match &mut *self.state { + AreaElementTypeSerializerState::Init__ => { + *self.state = AreaElementTypeSerializerState::Done__; + let mut bytes = BytesStart::new(self.name); + helper.begin_ns_scope(); + if self.is_root { + helper.write_xmlns(&mut bytes, None, &super::super::NS_ONIX); + } + helper.write_attrib_opt(&mut bytes, "id", &self.value.id)?; + helper.write_attrib_opt(&mut bytes, "class", &self.value.class)?; + helper.write_attrib_opt(&mut bytes, "style", &self.value.style)?; + helper.write_attrib_opt(&mut bytes, "title", &self.value.title)?; + helper.write_attrib_opt(&mut bytes, "lang", &self.value.lang)?; + helper.write_attrib_opt(&mut bytes, "dir", &self.value.dir)?; + helper.write_attrib(&mut bytes, "shape", &self.value.shape)?; + helper.write_attrib_opt(&mut bytes, "coords", &self.value.coords)?; + helper.write_attrib_opt(&mut bytes, "href", &self.value.href)?; + helper.write_attrib_opt(&mut bytes, "nohref", &self.value.nohref)?; + helper.write_attrib(&mut bytes, "alt", &self.value.alt)?; + helper.end_ns_scope(); + return Ok(Some(Event::Empty(bytes))); + } + AreaElementTypeSerializerState::Done__ => return Ok(None), + AreaElementTypeSerializerState::Phantom__(_) => unreachable!(), + } + } + } + } + impl<'ser> Serializer<'ser> for AreaElementTypeSerializer<'ser> { + fn next(&mut self, helper: &mut SerializeHelper) -> Option, Error>> { + match self.next_event(helper) { + Ok(Some(event)) => Some(Ok(event)), + Ok(None) => None, + Err(error) => { + *self.state = AreaElementTypeSerializerState::Done__; + Some(Err(error)) + } + } + } + } + #[derive(Debug)] pub struct RubyContent59Serializer<'ser> { pub(super) value: &'ser super::RubyContent59, pub(super) state: Box>, diff --git a/xsd-parser/tests/schema/opendrive/v1_6/expected/default.rs b/xsd-parser/tests/schema/opendrive/v1_6/expected/default.rs index 56ea5c5c..6d30265b 100644 --- a/xsd-parser/tests/schema/opendrive/v1_6/expected/default.rs +++ b/xsd-parser/tests/schema/opendrive/v1_6/expected/default.rs @@ -1,4 +1,8 @@ -use xsd_parser_types::xml::{Base64String, HexString}; +use core::fmt::Debug; +use xsd_parser_types::{ + xml::{Base64String, HexString}, + AsAny, +}; pub type OpenDrive = OpenDriveXElementType; #[derive(Debug)] pub struct OpenDriveXElementType { @@ -11,7 +15,15 @@ pub struct OpenDriveXElementType { pub g_additional_data: Vec, } #[derive(Debug)] -pub struct OpenDriveElementXType; +pub struct OpenDriveElementXType(pub Box); +pub trait OpenDriveElementXTypeTrait: Debug + AsAny {} +impl OpenDriveElementXType { + pub fn new(value: T) -> Self { + Self(Box::new(value)) + } +} +#[derive(Debug)] +pub struct OpenDriveElementDyn; #[derive(Debug)] pub enum EDataQualityRawDataPostProcessingXType { Raw, @@ -92,6 +104,7 @@ pub struct THeaderXType { pub offset: Option, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for THeaderXType {} #[derive(Debug)] pub struct THeaderGeoReferenceXType { pub g_additional_data: Vec, @@ -104,6 +117,7 @@ pub struct THeaderOffsetXType { pub hdg_attrib: f32, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for THeaderOffsetXType {} #[derive(Debug)] pub struct TIncludeXType { pub file_attrib: String, @@ -141,6 +155,7 @@ pub struct TRoadRailroadXType { pub switch: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadRailroadXType {} #[derive(Debug)] pub struct TRoadRailroadSwitchXType { pub name_attrib: String, @@ -151,6 +166,7 @@ pub struct TRoadRailroadSwitchXType { pub partner: Option, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadRailroadSwitchXType {} #[derive(Debug)] pub struct TRoadRailroadSwitchMainTrackXType { pub id_attrib: String, @@ -158,12 +174,14 @@ pub struct TRoadRailroadSwitchMainTrackXType { pub dir_attrib: EElementDirXType, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadRailroadSwitchMainTrackXType {} #[derive(Debug)] pub struct TRoadRailroadSwitchPartnerXType { pub name_attrib: Option, pub id_attrib: String, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadRailroadSwitchPartnerXType {} #[derive(Debug)] pub struct TRoadRailroadSwitchSideTrackXType { pub id_attrib: String, @@ -171,6 +189,7 @@ pub struct TRoadRailroadSwitchSideTrackXType { pub dir_attrib: EElementDirXType, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadRailroadSwitchSideTrackXType {} #[derive(Debug)] pub struct TStationXType { pub name_attrib: String, @@ -179,6 +198,7 @@ pub struct TStationXType { pub platform: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TStationXType {} #[derive(Debug)] pub struct TStationPlatformXType { pub name_attrib: Option, @@ -186,6 +206,7 @@ pub struct TStationPlatformXType { pub segment: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TStationPlatformXType {} #[derive(Debug)] pub struct TStationPlatformSegmentXType { pub road_id_attrib: String, @@ -193,6 +214,7 @@ pub struct TStationPlatformSegmentXType { pub s_end_attrib: f64, pub side_attrib: EStationPlatformSegmentSideXType, } +impl OpenDriveElementXTypeTrait for TStationPlatformSegmentXType {} #[derive(Debug)] pub enum EContactPointXType { Start, @@ -236,6 +258,7 @@ pub struct TJunctionXType { pub surface: Option, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TJunctionXType {} #[derive(Debug)] pub struct TJunctionGroupXType { pub name_attrib: Option, @@ -244,10 +267,12 @@ pub struct TJunctionGroupXType { pub junction_reference: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TJunctionGroupXType {} #[derive(Debug)] pub struct TJunctionGroupJunctionReferenceXType { pub junction_attrib: String, } +impl OpenDriveElementXTypeTrait for TJunctionGroupJunctionReferenceXType {} #[derive(Debug)] pub struct TJunctionConnectionXType { pub id_attrib: String, @@ -259,17 +284,20 @@ pub struct TJunctionConnectionXType { pub successor: Option, pub lane_link: Vec, } +impl OpenDriveElementXTypeTrait for TJunctionConnectionXType {} #[derive(Debug)] pub struct TJunctionConnectionLaneLinkXType { pub from_attrib: i32, pub to_attrib: i32, } +impl OpenDriveElementXTypeTrait for TJunctionConnectionLaneLinkXType {} #[derive(Debug)] pub struct TJunctionControllerXType { pub id_attrib: String, pub type_attrib: Option, pub sequence_attrib: Option, } +impl OpenDriveElementXTypeTrait for TJunctionControllerXType {} #[derive(Debug)] pub struct TJunctionPredecessorSuccessorXType { pub element_type_attrib: String, @@ -277,16 +305,19 @@ pub struct TJunctionPredecessorSuccessorXType { pub element_s_attrib: f64, pub element_dir_attrib: EElementDirXType, } +impl OpenDriveElementXTypeTrait for TJunctionPredecessorSuccessorXType {} #[derive(Debug)] pub struct TJunctionPriorityXType { pub high_attrib: Option, pub low_attrib: Option, } +impl OpenDriveElementXTypeTrait for TJunctionPriorityXType {} #[derive(Debug)] pub struct TJunctionSurfaceXType { pub crg: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TJunctionSurfaceXType {} #[derive(Debug)] pub struct TJunctionSurfaceCrgXType { pub file_attrib: String, @@ -295,6 +326,7 @@ pub struct TJunctionSurfaceCrgXType { pub z_offset_attrib: Option, pub z_scale_attrib: Option, } +impl OpenDriveElementXTypeTrait for TJunctionSurfaceCrgXType {} #[derive(Debug)] pub enum ERoadSignalsSignalReferenceElementTypeXType { Object, @@ -308,17 +340,20 @@ pub struct TControllerXType { pub control: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TControllerXType {} #[derive(Debug)] pub struct TControllerControlXType { pub signal_id_attrib: String, pub type_attrib: Option, } +impl OpenDriveElementXTypeTrait for TControllerControlXType {} #[derive(Debug)] pub struct TRoadSignalsXType { pub signal: Vec, pub signal_reference: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadSignalsXType {} #[derive(Debug)] pub struct TRoadSignalsSignalXType { pub s_attrib: f64, @@ -346,6 +381,7 @@ pub struct TRoadSignalsSignalXType { pub content_91: Option, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadSignalsSignalXType {} #[derive(Debug)] pub struct TRoadSignalsSignalReference2 { pub s_attrib: f64, @@ -355,11 +391,13 @@ pub struct TRoadSignalsSignalReference2 { pub validity: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadSignalsSignalReference2 {} #[derive(Debug)] pub struct TRoadSignalsSignalDependencyXType { pub id_attrib: String, pub type_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadSignalsSignalDependencyXType {} #[derive(Debug)] pub struct TRoadSignalsSignalPositionInertialXType { pub x_attrib: f64, @@ -369,6 +407,7 @@ pub struct TRoadSignalsSignalPositionInertialXType { pub pitch_attrib: Option, pub roll_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadSignalsSignalPositionInertialXType {} #[derive(Debug)] pub struct TRoadSignalsSignalPositionRoadXType { pub road_id_attrib: String, @@ -379,12 +418,14 @@ pub struct TRoadSignalsSignalPositionRoadXType { pub pitch_attrib: Option, pub roll_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadSignalsSignalPositionRoadXType {} #[derive(Debug)] pub struct TRoadSignalsSignalReferenceXType { pub element_type_attrib: ERoadSignalsSignalReferenceElementTypeXType, pub element_id_attrib: String, pub type_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadSignalsSignalReferenceXType {} #[derive(Debug)] pub enum ECountryCodeXType { String(String), @@ -469,11 +510,13 @@ pub struct TRoadXType { pub railroad: Option, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadXType {} #[derive(Debug)] pub struct TRoadElevationProfileXType { pub elevation: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadElevationProfileXType {} #[derive(Debug)] pub struct TRoadElevationProfileElevationXType { pub s_attrib: f64, @@ -482,12 +525,14 @@ pub struct TRoadElevationProfileElevationXType { pub c_attrib: f64, pub d_attrib: f64, } +impl OpenDriveElementXTypeTrait for TRoadElevationProfileElevationXType {} #[derive(Debug)] pub struct TRoadLateralProfileXType { pub superelevation: Vec, pub shape: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLateralProfileXType {} #[derive(Debug)] pub struct TRoadLateralProfileShapeXType { pub s_attrib: f64, @@ -497,6 +542,7 @@ pub struct TRoadLateralProfileShapeXType { pub c_attrib: f64, pub d_attrib: f64, } +impl OpenDriveElementXTypeTrait for TRoadLateralProfileShapeXType {} #[derive(Debug)] pub struct TRoadLateralProfileSuperelevationXType { pub s_attrib: f64, @@ -505,12 +551,14 @@ pub struct TRoadLateralProfileSuperelevationXType { pub c_attrib: f64, pub d_attrib: f64, } +impl OpenDriveElementXTypeTrait for TRoadLateralProfileSuperelevationXType {} #[derive(Debug)] pub struct TRoadLinkXType { pub predecessor: Option, pub successor: Option, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLinkXType {} #[derive(Debug)] pub struct TRoadLinkPredecessorSuccessorXType { pub element_id_attrib: String, @@ -519,11 +567,13 @@ pub struct TRoadLinkPredecessorSuccessorXType { pub element_s_attrib: Option, pub element_dir_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadLinkPredecessorSuccessorXType {} #[derive(Debug)] pub struct TRoadPlanViewXType { pub geometry: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadPlanViewXType {} #[derive(Debug)] pub struct TRoadPlanViewGeometryXType { pub s_attrib: f64, @@ -533,6 +583,7 @@ pub struct TRoadPlanViewGeometryXType { pub length_attrib: String, pub content: TRoadPlanViewGeometryXTypeContent, } +impl OpenDriveElementXTypeTrait for TRoadPlanViewGeometryXType {} #[derive(Debug)] pub enum TRoadPlanViewGeometryXTypeContent { Line(TRoadPlanViewGeometryLineXType), @@ -546,8 +597,10 @@ pub enum TRoadPlanViewGeometryXTypeContent { pub struct TRoadPlanViewGeometryArcXType { pub curvature_attrib: f64, } +impl OpenDriveElementXTypeTrait for TRoadPlanViewGeometryArcXType {} #[derive(Debug)] pub struct TRoadPlanViewGeometryLineXType; +impl OpenDriveElementXTypeTrait for TRoadPlanViewGeometryLineXType {} #[derive(Debug)] pub struct TRoadPlanViewGeometryParamPoly3XType { pub au_attrib: f64, @@ -560,6 +613,7 @@ pub struct TRoadPlanViewGeometryParamPoly3XType { pub dv_attrib: f64, pub p_range_attrib: EParamPoly3PRangeXType, } +impl OpenDriveElementXTypeTrait for TRoadPlanViewGeometryParamPoly3XType {} #[derive(Debug)] pub struct TRoadPlanViewGeometryPoly3XType { pub a_attrib: f64, @@ -567,16 +621,19 @@ pub struct TRoadPlanViewGeometryPoly3XType { pub c_attrib: f64, pub d_attrib: f64, } +impl OpenDriveElementXTypeTrait for TRoadPlanViewGeometryPoly3XType {} #[derive(Debug)] pub struct TRoadPlanViewGeometrySpiralXType { pub curv_start_attrib: f64, pub curv_end_attrib: f64, } +impl OpenDriveElementXTypeTrait for TRoadPlanViewGeometrySpiralXType {} #[derive(Debug)] pub struct TRoadSurfaceXType { pub crg: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadSurfaceXType {} #[derive(Debug)] pub struct TRoadSurfaceCrgXType { pub file_attrib: String, @@ -591,6 +648,7 @@ pub struct TRoadSurfaceCrgXType { pub z_scale_attrib: Option, pub h_offset_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadSurfaceCrgXType {} #[derive(Debug)] pub struct TRoadTypeXType { pub s_attrib: f64, @@ -599,11 +657,13 @@ pub struct TRoadTypeXType { pub speed: Option, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadTypeXType {} #[derive(Debug)] pub struct TRoadTypeSpeedXType { pub max_attrib: TMaxSpeedXType, pub unit_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadTypeSpeedXType {} #[derive(Debug)] pub enum EBorderTypeXType { Concrete, @@ -692,6 +752,7 @@ pub struct TRoadObjectsXType { pub bridge: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadObjectsXType {} #[derive(Debug)] pub struct TRoadObjectsBridgeXType { pub s_attrib: f64, @@ -702,6 +763,7 @@ pub struct TRoadObjectsBridgeXType { pub validity: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadObjectsBridgeXType {} #[derive(Debug)] pub struct TRoadObjectsObjectXType { pub t_attrib: f64, @@ -731,6 +793,7 @@ pub struct TRoadObjectsObjectXType { pub borders: Option, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectXType {} #[derive(Debug)] pub struct TRoadObjectsObjectReferenceXType { pub s_attrib: f64, @@ -742,11 +805,13 @@ pub struct TRoadObjectsObjectReferenceXType { pub validity: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectReferenceXType {} #[derive(Debug)] pub struct TRoadObjectsObjectBordersXType { pub border: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectBordersXType {} #[derive(Debug)] pub struct TRoadObjectsObjectBordersBorderXType { pub width_attrib: f64, @@ -756,11 +821,13 @@ pub struct TRoadObjectsObjectBordersBorderXType { pub corner_reference: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectBordersBorderXType {} #[derive(Debug)] pub struct TRoadObjectsObjectMarkingsXType { pub marking: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectMarkingsXType {} #[derive(Debug)] pub struct TRoadObjectsObjectMarkingsMarkingXType { pub side_attrib: Option, @@ -775,21 +842,25 @@ pub struct TRoadObjectsObjectMarkingsMarkingXType { pub corner_reference: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectMarkingsMarkingXType {} #[derive(Debug)] pub struct TRoadObjectsObjectMarkingsMarkingCornerReferenceXType { pub id_attrib: usize, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectMarkingsMarkingCornerReferenceXType {} #[derive(Debug)] pub struct TRoadObjectsObjectMaterialXType { pub surface_attrib: Option, pub friction_attrib: Option, pub roughness_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectMaterialXType {} #[derive(Debug)] pub struct TRoadObjectsObjectOutlinesXType { pub outline: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectOutlinesXType {} #[derive(Debug)] pub struct TRoadObjectsObjectOutlinesOutlineXType { pub id_attrib: Option, @@ -800,6 +871,7 @@ pub struct TRoadObjectsObjectOutlinesOutlineXType { pub content_61: Option, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectOutlinesOutlineXType {} #[derive(Debug)] pub struct TRoadObjectsObjectOutlinesOutlineCornerLocalXType { pub u_attrib: f64, @@ -808,6 +880,7 @@ pub struct TRoadObjectsObjectOutlinesOutlineCornerLocalXType { pub height_attrib: f64, pub id_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectOutlinesOutlineCornerLocalXType {} #[derive(Debug)] pub struct TRoadObjectsObjectOutlinesOutlineCornerRoadXType { pub s_attrib: f64, @@ -816,11 +889,13 @@ pub struct TRoadObjectsObjectOutlinesOutlineCornerRoadXType { pub height_attrib: f64, pub id_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectOutlinesOutlineCornerRoadXType {} #[derive(Debug)] pub struct TRoadObjectsObjectParkingSpaceXType { pub access_attrib: ERoadObjectsObjectParkingSpaceAccessXType, pub restrictions_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectParkingSpaceXType {} #[derive(Debug)] pub struct TRoadObjectsObjectRepeatXType { pub s_attrib: f64, @@ -839,6 +914,7 @@ pub struct TRoadObjectsObjectRepeatXType { pub radius_start_attrib: Option, pub radius_end_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectRepeatXType {} #[derive(Debug)] pub struct TRoadObjectsTunnelXType { pub s_attrib: f64, @@ -851,6 +927,7 @@ pub struct TRoadObjectsTunnelXType { pub validity: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadObjectsTunnelXType {} #[derive(Debug)] pub enum EAccessRestrictionTypeXType { Simulator, @@ -958,6 +1035,7 @@ pub struct TRoadLanesXType { pub lane_section: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesXType {} #[derive(Debug)] pub struct TRoadLanesLaneOffsetXType { pub s_attrib: f64, @@ -966,6 +1044,7 @@ pub struct TRoadLanesLaneOffsetXType { pub c_attrib: f64, pub d_attrib: f64, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneOffsetXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionXType { pub s_attrib: f64, @@ -975,11 +1054,13 @@ pub struct TRoadLanesLaneSectionXType { pub right: Option, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionCenterXType { pub lane: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionCenterXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionCenterLaneXType { pub type_attrib: ELaneTypeXType, @@ -995,16 +1076,19 @@ pub struct TRoadLanesLaneSectionCenterLaneXType { pub rule: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionCenterLaneXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLcrLaneLinkXType { pub predecessor: Vec, pub successor: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLcrLaneLinkXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLcrLaneLinkPredecessorSuccessorXType { pub id_attrib: i32, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLcrLaneLinkPredecessorSuccessorXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLcrLaneRoadMarkXType { pub s_offset_attrib: f64, @@ -1020,11 +1104,13 @@ pub struct TRoadLanesLaneSectionLcrLaneRoadMarkXType { pub explicit: Option, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLcrLaneRoadMarkXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLcrLaneRoadMarkExplicitXType { pub line: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLcrLaneRoadMarkExplicitXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLcrLaneRoadMarkExplicitLineXType { pub length_attrib: String, @@ -1033,6 +1119,7 @@ pub struct TRoadLanesLaneSectionLcrLaneRoadMarkExplicitLineXType { pub rule_attrib: Option, pub width_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLcrLaneRoadMarkExplicitLineXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLcrLaneRoadMarkSwayXType { pub ds_attrib: f64, @@ -1041,6 +1128,7 @@ pub struct TRoadLanesLaneSectionLcrLaneRoadMarkSwayXType { pub c_attrib: f64, pub d_attrib: f64, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLcrLaneRoadMarkSwayXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLcrLaneRoadMarkTypeXType { pub name_attrib: String, @@ -1048,6 +1136,7 @@ pub struct TRoadLanesLaneSectionLcrLaneRoadMarkTypeXType { pub line: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLcrLaneRoadMarkTypeXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLcrLaneRoadMarkTypeLineXType { pub length_attrib: String, @@ -1058,11 +1147,13 @@ pub struct TRoadLanesLaneSectionLcrLaneRoadMarkTypeLineXType { pub width_attrib: Option, pub color_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLcrLaneRoadMarkTypeLineXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLeftXType { pub lane: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLeftXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLeftLaneXType { pub type_attrib: ELaneTypeXType, @@ -1078,6 +1169,7 @@ pub struct TRoadLanesLaneSectionLeftLaneXType { pub rule: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLeftLaneXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLrLaneXType { pub type_attrib: ELaneTypeXType, @@ -1092,12 +1184,14 @@ pub struct TRoadLanesLaneSectionLrLaneXType { pub rule: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLrLaneXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLrLaneAccessXType { pub s_offset_attrib: f64, pub rule_attrib: Option, pub restriction_attrib: EAccessRestrictionTypeXType, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLrLaneAccessXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLrLaneBorderXType { pub s_offset_attrib: f64, @@ -1106,12 +1200,14 @@ pub struct TRoadLanesLaneSectionLrLaneBorderXType { pub c_attrib: f64, pub d_attrib: f64, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLrLaneBorderXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLrLaneHeightXType { pub s_offset_attrib: f64, pub inner_attrib: f64, pub outer_attrib: f64, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLrLaneHeightXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLrLaneMaterialXType { pub s_offset_attrib: f64, @@ -1119,17 +1215,20 @@ pub struct TRoadLanesLaneSectionLrLaneMaterialXType { pub friction_attrib: f64, pub roughness_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLrLaneMaterialXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLrLaneRuleXType { pub s_offset_attrib: f64, pub value_attrib: String, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLrLaneRuleXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLrLaneSpeedXType { pub s_offset_attrib: f64, pub max_attrib: f64, pub unit_attrib: Option, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLrLaneSpeedXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionLrLaneWidthXType { pub s_offset_attrib: f64, @@ -1138,11 +1237,13 @@ pub struct TRoadLanesLaneSectionLrLaneWidthXType { pub c_attrib: f64, pub d_attrib: f64, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionLrLaneWidthXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionRightXType { pub lane: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionRightXType {} #[derive(Debug)] pub struct TRoadLanesLaneSectionRightLaneXType { pub type_attrib: ELaneTypeXType, @@ -1158,11 +1259,13 @@ pub struct TRoadLanesLaneSectionRightLaneXType { pub rule: Vec, pub g_additional_data: Vec, } +impl OpenDriveElementXTypeTrait for TRoadLanesLaneSectionRightLaneXType {} #[derive(Debug)] pub struct TRoadObjectsObjectLaneValidityXType { pub from_lane_attrib: i32, pub to_lane_attrib: i32, } +impl OpenDriveElementXTypeTrait for TRoadObjectsObjectLaneValidityXType {} #[derive(Debug, Default)] pub struct EntitiesXType(pub Vec); pub type EntityXType = String; diff --git a/xsd-parser/tests/schema/xml_schema/expected/quick_xml.rs b/xsd-parser/tests/schema/xml_schema/expected/quick_xml.rs index 664047c5..8d526fee 100644 --- a/xsd-parser/tests/schema/xml_schema/expected/quick_xml.rs +++ b/xsd-parser/tests/schema/xml_schema/expected/quick_xml.rs @@ -34,11 +34,11 @@ pub enum SchemaElementTypeContent { Override(OverrideElementType), Annotation(AnnotationElementType), DefaultOpenContent(DefaultOpenContentElementType), - SimpleType(SimpleBaseType), - ComplexType(ComplexBaseType), - Group(GroupType), - AttributeGroup(AttributeGroupType), - Element(ElementType), + SimpleType(TopLevelSimpleType), + ComplexType(TopLevelComplexType), + Group(RealGroupType), + AttributeGroup(NamedAttributeGroupType), + Element(TopLevelElementType), Attribute(AttributeType), Notation(NotationElementType), } @@ -182,10 +182,10 @@ pub struct RedefineElementType { #[derive(Debug)] pub enum RedefineElementTypeContent { Annotation(AnnotationElementType), - SimpleType(SimpleBaseType), - ComplexType(ComplexBaseType), - Group(GroupType), - AttributeGroup(AttributeGroupType), + SimpleType(TopLevelSimpleType), + ComplexType(TopLevelComplexType), + Group(RealGroupType), + AttributeGroup(NamedAttributeGroupType), } impl WithDeserializer for RedefineElementType { type Deserializer = quick_xml_deserialize::RedefineElementTypeDeserializer; @@ -203,11 +203,11 @@ pub struct OverrideElementType { #[derive(Debug)] pub enum OverrideElementTypeContent { Annotation(AnnotationElementType), - SimpleType(SimpleBaseType), - ComplexType(ComplexBaseType), - Group(GroupType), - AttributeGroup(AttributeGroupType), - Element(ElementType), + SimpleType(TopLevelSimpleType), + ComplexType(TopLevelComplexType), + Group(RealGroupType), + AttributeGroup(NamedAttributeGroupType), + Element(TopLevelElementType), Attribute(AttributeType), Notation(NotationElementType), } @@ -257,33 +257,34 @@ impl WithDeserializer for DefaultOpenContentElementType { type Deserializer = quick_xml_deserialize::DefaultOpenContentElementTypeDeserializer; } #[derive(Debug)] -pub struct SimpleBaseType { +pub struct TopLevelSimpleType { pub any_attribute: AnyAttributes, pub id: Option, pub final_: Option, ///Can be restricted to required or forbidden - pub name: Option, - pub content: Vec, + ///Required at the top level + pub name: String, + pub content: Vec, } #[derive(Debug)] -pub enum SimpleBaseTypeContent { - Annotation(AnnotationElementType), +pub enum TopLevelSimpleTypeContent { Restriction(RestrictionElementType), List(ListElementType), Union(UnionElementType), + Annotation(AnnotationElementType), } -impl WithDeserializer for SimpleBaseType { - type Deserializer = quick_xml_deserialize::SimpleBaseTypeDeserializer; +impl WithDeserializer for TopLevelSimpleType { + type Deserializer = quick_xml_deserialize::TopLevelSimpleTypeDeserializer; } -impl WithDeserializer for SimpleBaseTypeContent { - type Deserializer = quick_xml_deserialize::SimpleBaseTypeContentDeserializer; +impl WithDeserializer for TopLevelSimpleTypeContent { + type Deserializer = quick_xml_deserialize::TopLevelSimpleTypeContentDeserializer; } #[derive(Debug)] -pub struct ComplexBaseType { +pub struct TopLevelComplexType { pub any_attribute: AnyAttributes, pub id: Option, ///Will be restricted to required or prohibited - pub name: Option, + pub name: String, ///Not allowed if simpleContent child is chosen. ///May be overridden by setting on complexContent child. pub mixed: Option, @@ -291,24 +292,24 @@ pub struct ComplexBaseType { pub final_: Option, pub block: Option, pub default_attributes_apply: bool, - pub content: Vec, + pub content: Vec, } #[derive(Debug)] -pub enum ComplexBaseTypeContent { - Annotation(AnnotationElementType), +pub enum TopLevelComplexTypeContent { SimpleContent(SimpleContentElementType), ComplexContent(ComplexContentElementType), OpenContent(OpenContentElementType), - Group(GroupType), - All(GroupType), - Choice(GroupType), - Sequence(GroupType), + Group(RealGroupType), + All(ExplicitGroupType), + Choice(ExplicitGroupType), + Sequence(ExplicitGroupType), Attribute(AttributeType), - AttributeGroup(AttributeGroupType), + AttributeGroup(AttributeGroupRefType), AnyAttribute(AnyAttributeElementType), Assert(AssertionType), + Annotation(AnnotationElementType), } -impl ComplexBaseType { +impl TopLevelComplexType { #[must_use] pub fn default_abstract_() -> bool { false @@ -318,43 +319,30 @@ impl ComplexBaseType { true } } -impl WithDeserializer for ComplexBaseType { - type Deserializer = quick_xml_deserialize::ComplexBaseTypeDeserializer; +impl WithDeserializer for TopLevelComplexType { + type Deserializer = quick_xml_deserialize::TopLevelComplexTypeDeserializer; } -impl WithDeserializer for ComplexBaseTypeContent { - type Deserializer = quick_xml_deserialize::ComplexBaseTypeContentDeserializer; +impl WithDeserializer for TopLevelComplexTypeContent { + type Deserializer = quick_xml_deserialize::TopLevelComplexTypeContentDeserializer; } -///group type for explicit groups, named top-level groups and -///group references -///for element, group and attributeGroup, -///which both define and reference -///for all particles #[derive(Debug)] -pub struct GroupType { +pub struct RealGroupType { pub any_attribute: AnyAttributes, pub id: Option, pub name: Option, pub ref_: Option, pub min_occurs: usize, pub max_occurs: AllNniType, - pub content: Vec, + pub content: Vec, } -///group type for explicit groups, named top-level groups and -///group references -///for element, group and attributeGroup, -///which both define and reference -///for all particles #[derive(Debug)] -pub enum GroupTypeContent { +pub enum RealGroupTypeContent { Annotation(AnnotationElementType), - Element(ElementType), - Group(GroupType), - All(GroupType), - Choice(GroupType), - Sequence(GroupType), - Any(AnyElementType), + All(ExplicitGroupType), + Choice(ExplicitGroupType), + Sequence(ExplicitGroupType), } -impl GroupType { +impl RealGroupType { #[must_use] pub fn default_min_occurs() -> usize { 1usize @@ -364,102 +352,68 @@ impl GroupType { AllNniType::Usize(1usize) } } -impl WithDeserializer for GroupType { - type Deserializer = quick_xml_deserialize::GroupTypeDeserializer; +impl WithDeserializer for RealGroupType { + type Deserializer = quick_xml_deserialize::RealGroupTypeDeserializer; } -impl WithDeserializer for GroupTypeContent { - type Deserializer = quick_xml_deserialize::GroupTypeContentDeserializer; +impl WithDeserializer for RealGroupTypeContent { + type Deserializer = quick_xml_deserialize::RealGroupTypeContentDeserializer; } -///for element, group and attributeGroup, -///which both define and reference #[derive(Debug)] -pub struct AttributeGroupType { +pub struct NamedAttributeGroupType { pub any_attribute: AnyAttributes, pub id: Option, - pub name: Option, - pub ref_: Option, - pub content: Vec, + pub name: String, + pub content: Vec, } -///for element, group and attributeGroup, -///which both define and reference #[derive(Debug)] -pub enum AttributeGroupTypeContent { +pub enum NamedAttributeGroupTypeContent { Annotation(AnnotationElementType), Attribute(AttributeType), - AttributeGroup(AttributeGroupType), + AttributeGroup(AttributeGroupRefType), AnyAttribute(AnyAttributeElementType), } -impl WithDeserializer for AttributeGroupType { - type Deserializer = quick_xml_deserialize::AttributeGroupTypeDeserializer; +impl WithDeserializer for NamedAttributeGroupType { + type Deserializer = quick_xml_deserialize::NamedAttributeGroupTypeDeserializer; } -impl WithDeserializer for AttributeGroupTypeContent { - type Deserializer = quick_xml_deserialize::AttributeGroupTypeContentDeserializer; +impl WithDeserializer for NamedAttributeGroupTypeContent { + type Deserializer = quick_xml_deserialize::NamedAttributeGroupTypeContentDeserializer; } -///The element element can be used either -///at the top level to define an element-type binding globally, -///or within a content model to either reference a globally-defined -///element or type or declare an element-type binding locally. -///The ref form is not allowed at the top level. -///for element, group and attributeGroup, -///which both define and reference -///for all particles #[derive(Debug)] -pub struct ElementType { +pub struct TopLevelElementType { pub any_attribute: AnyAttributes, pub id: Option, - pub name: Option, - pub ref_: Option, + pub name: String, pub type_: Option, pub substitution_group: Option, - pub min_occurs: usize, - pub max_occurs: AllNniType, pub default: Option, pub fixed: Option, pub nillable: Option, pub abstract_: bool, pub final_: Option, pub block: Option, - pub form: Option, - pub target_namespace: Option, - pub content: Vec, + pub content: Vec, } -///The element element can be used either -///at the top level to define an element-type binding globally, -///or within a content model to either reference a globally-defined -///element or type or declare an element-type binding locally. -///The ref form is not allowed at the top level. -///for element, group and attributeGroup, -///which both define and reference -///for all particles #[derive(Debug)] -pub enum ElementTypeContent { +pub enum TopLevelElementTypeContent { Annotation(AnnotationElementType), - SimpleType(SimpleBaseType), - ComplexType(ComplexBaseType), + SimpleType(LocalSimpleType), + ComplexType(LocalComplexType), Alternative(AltType), Unique(KeybaseType), Key(KeybaseType), Keyref(KeyrefElementType), } -impl ElementType { - #[must_use] - pub fn default_min_occurs() -> usize { - 1usize - } - #[must_use] - pub fn default_max_occurs() -> AllNniType { - AllNniType::Usize(1usize) - } +impl TopLevelElementType { #[must_use] pub fn default_abstract_() -> bool { false } } -impl WithDeserializer for ElementType { - type Deserializer = quick_xml_deserialize::ElementTypeDeserializer; +impl WithDeserializer for TopLevelElementType { + type Deserializer = quick_xml_deserialize::TopLevelElementTypeDeserializer; } -impl WithDeserializer for ElementTypeContent { - type Deserializer = quick_xml_deserialize::ElementTypeContentDeserializer; +impl WithDeserializer for TopLevelElementTypeContent { + type Deserializer = quick_xml_deserialize::TopLevelElementTypeContentDeserializer; } ///for element, group and attributeGroup, ///which both define and reference @@ -477,7 +431,7 @@ pub struct AttributeType { pub target_namespace: Option, pub inheritable: Option, pub annotation: Option, - pub simple_type: Option, + pub simple_type: Option, } impl AttributeType { #[must_use] @@ -603,7 +557,7 @@ pub struct RestrictionElementType { #[derive(Debug)] pub enum RestrictionElementTypeContent { Annotation(AnnotationElementType), - SimpleType(SimpleBaseType), + SimpleType(LocalSimpleType), Facet(Facet), Any(AnyElement), } @@ -621,7 +575,7 @@ pub struct ListElementType { pub id: Option, pub item_type: Option, pub annotation: Option, - pub simple_type: Option>, + pub simple_type: Option, } impl WithDeserializer for ListElementType { type Deserializer = quick_xml_deserialize::ListElementTypeDeserializer; @@ -634,7 +588,7 @@ pub struct UnionElementType { pub id: Option, pub member_types: Option, pub annotation: Option, - pub simple_type: Vec, + pub simple_type: Vec, } impl WithDeserializer for UnionElementType { type Deserializer = quick_xml_deserialize::UnionElementTypeDeserializer; @@ -712,6 +666,51 @@ impl OpenContentElementType { impl WithDeserializer for OpenContentElementType { type Deserializer = quick_xml_deserialize::OpenContentElementTypeDeserializer; } +///group type for the three kinds of group +#[derive(Debug)] +pub struct ExplicitGroupType { + pub any_attribute: AnyAttributes, + pub id: Option, + pub min_occurs: usize, + pub max_occurs: AllNniType, + pub content: Vec, +} +///group type for the three kinds of group +#[derive(Debug)] +pub enum ExplicitGroupTypeContent { + Annotation(AnnotationElementType), + Element(LocalElementType), + Group(RealGroupType), + Choice(ExplicitGroupType), + Sequence(ExplicitGroupType), + Any(AnyElementType), +} +impl ExplicitGroupType { + #[must_use] + pub fn default_min_occurs() -> usize { + 1usize + } + #[must_use] + pub fn default_max_occurs() -> AllNniType { + AllNniType::Usize(1usize) + } +} +impl WithDeserializer for ExplicitGroupType { + type Deserializer = quick_xml_deserialize::ExplicitGroupTypeDeserializer; +} +impl WithDeserializer for ExplicitGroupTypeContent { + type Deserializer = quick_xml_deserialize::ExplicitGroupTypeContentDeserializer; +} +#[derive(Debug)] +pub struct AttributeGroupRefType { + pub any_attribute: AnyAttributes, + pub id: Option, + pub ref_: String, + pub annotation: Option, +} +impl WithDeserializer for AttributeGroupRefType { + type Deserializer = quick_xml_deserialize::AttributeGroupRefTypeDeserializer; +} #[derive(Debug)] pub struct AnyAttributeElementType { pub any_attribute: AnyAttributes, @@ -757,44 +756,70 @@ impl DeserializeBytes for AllNniType { } } impl WithDeserializerFromBytes for AllNniType {} -///for all particles +#[derive(Debug, Default)] +pub struct EntitiesType(pub Vec); +impl DeserializeBytes for EntitiesType { + fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result { + Ok(Self(helper.deserialize_list(bytes)?)) + } +} +impl WithDeserializerFromBytes for EntitiesType {} #[derive(Debug)] -pub struct AnyElementType { +pub struct LocalSimpleType { pub any_attribute: AnyAttributes, pub id: Option, - pub namespace: Option, - pub not_namespace: Option, - pub process_contents: ProcessContentsType, - pub not_q_name: Option, - pub min_occurs: usize, - pub max_occurs: AllNniType, - pub annotation: Option, + pub content: Vec, } -impl AnyElementType { - #[must_use] - pub fn default_process_contents() -> ProcessContentsType { - ProcessContentsType::Strict - } - #[must_use] - pub fn default_min_occurs() -> usize { - 1usize - } +#[derive(Debug)] +pub enum LocalSimpleTypeContent { + Restriction(RestrictionElementType), + List(ListElementType), + Union(UnionElementType), + Annotation(AnnotationElementType), +} +impl WithDeserializer for LocalSimpleType { + type Deserializer = quick_xml_deserialize::LocalSimpleTypeDeserializer; +} +impl WithDeserializer for LocalSimpleTypeContent { + type Deserializer = quick_xml_deserialize::LocalSimpleTypeContentDeserializer; +} +#[derive(Debug)] +pub struct LocalComplexType { + pub any_attribute: AnyAttributes, + pub id: Option, + ///Not allowed if simpleContent child is chosen. + ///May be overridden by setting on complexContent child. + pub mixed: Option, + pub default_attributes_apply: bool, + pub content: Vec, +} +#[derive(Debug)] +pub enum LocalComplexTypeContent { + SimpleContent(SimpleContentElementType), + ComplexContent(ComplexContentElementType), + OpenContent(OpenContentElementType), + Group(RealGroupType), + All(ExplicitGroupType), + Choice(ExplicitGroupType), + Sequence(ExplicitGroupType), + Attribute(AttributeType), + AttributeGroup(AttributeGroupRefType), + AnyAttribute(AnyAttributeElementType), + Assert(AssertionType), + Annotation(AnnotationElementType), +} +impl LocalComplexType { #[must_use] - pub fn default_max_occurs() -> AllNniType { - AllNniType::Usize(1usize) + pub fn default_default_attributes_apply() -> bool { + true } } -impl WithDeserializer for AnyElementType { - type Deserializer = quick_xml_deserialize::AnyElementTypeDeserializer; +impl WithDeserializer for LocalComplexType { + type Deserializer = quick_xml_deserialize::LocalComplexTypeDeserializer; } -#[derive(Debug, Default)] -pub struct EntitiesType(pub Vec); -impl DeserializeBytes for EntitiesType { - fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result { - Ok(Self(helper.deserialize_list(bytes)?)) - } +impl WithDeserializer for LocalComplexTypeContent { + type Deserializer = quick_xml_deserialize::LocalComplexTypeContentDeserializer; } -impl WithDeserializerFromBytes for EntitiesType {} ///This type is used for 'alternative' elements. #[derive(Debug)] pub struct AltType { @@ -809,8 +834,8 @@ pub struct AltType { #[derive(Debug)] pub enum AltTypeContent { Annotation(AnnotationElementType), - SimpleType(SimpleBaseType), - ComplexType(ComplexBaseType), + SimpleType(LocalSimpleType), + ComplexType(LocalComplexType), } impl WithDeserializer for AltType { type Deserializer = quick_xml_deserialize::AltTypeDeserializer; @@ -1017,15 +1042,15 @@ pub struct RestrictionType { pub enum RestrictionTypeContent { Annotation(AnnotationElementType), OpenContent(OpenContentElementType), - Group(GroupType), - All(GroupType), - Choice(GroupType), - Sequence(GroupType), - SimpleType(SimpleBaseType), + Group(RealGroupType), + All(ExplicitGroupType), + Choice(ExplicitGroupType), + Sequence(ExplicitGroupType), + SimpleType(LocalSimpleType), Facet(Facet), Any(AnyElement), Attribute(AttributeType), - AttributeGroup(AttributeGroupType), + AttributeGroup(AttributeGroupRefType), AnyAttribute(AnyAttributeElementType), Assert(AssertionType), } @@ -1046,12 +1071,12 @@ pub struct ExtensionType { pub enum ExtensionTypeContent { Annotation(AnnotationElementType), OpenContent(OpenContentElementType), - Group(GroupType), - All(GroupType), - Choice(GroupType), - Sequence(GroupType), + Group(RealGroupType), + All(ExplicitGroupType), + Choice(ExplicitGroupType), + Sequence(ExplicitGroupType), Attribute(AttributeType), - AttributeGroup(AttributeGroupType), + AttributeGroup(AttributeGroupRefType), AnyAttribute(AnyAttributeElementType), Assert(AssertionType), } @@ -1080,6 +1105,79 @@ impl DeserializeBytes for OpenContentModeType { } } impl WithDeserializerFromBytes for OpenContentModeType {} +#[derive(Debug)] +pub struct LocalElementType { + pub any_attribute: AnyAttributes, + pub id: Option, + pub name: Option, + pub ref_: Option, + pub type_: Option, + pub min_occurs: usize, + pub max_occurs: AllNniType, + pub default: Option, + pub fixed: Option, + pub nillable: Option, + pub block: Option, + pub form: Option, + pub target_namespace: Option, + pub content: Vec, +} +#[derive(Debug)] +pub enum LocalElementTypeContent { + Annotation(AnnotationElementType), + SimpleType(LocalSimpleType), + ComplexType(LocalComplexType), + Alternative(AltType), + Unique(KeybaseType), + Key(KeybaseType), + Keyref(KeyrefElementType), +} +impl LocalElementType { + #[must_use] + pub fn default_min_occurs() -> usize { + 1usize + } + #[must_use] + pub fn default_max_occurs() -> AllNniType { + AllNniType::Usize(1usize) + } +} +impl WithDeserializer for LocalElementType { + type Deserializer = quick_xml_deserialize::LocalElementTypeDeserializer; +} +impl WithDeserializer for LocalElementTypeContent { + type Deserializer = quick_xml_deserialize::LocalElementTypeContentDeserializer; +} +///for all particles +#[derive(Debug)] +pub struct AnyElementType { + pub any_attribute: AnyAttributes, + pub id: Option, + pub namespace: Option, + pub not_namespace: Option, + pub process_contents: ProcessContentsType, + pub not_q_name: Option, + pub min_occurs: usize, + pub max_occurs: AllNniType, + pub annotation: Option, +} +impl AnyElementType { + #[must_use] + pub fn default_process_contents() -> ProcessContentsType { + ProcessContentsType::Strict + } + #[must_use] + pub fn default_min_occurs() -> usize { + 1usize + } + #[must_use] + pub fn default_max_occurs() -> AllNniType { + AllNniType::Usize(1usize) + } +} +impl WithDeserializer for AnyElementType { + type Deserializer = quick_xml_deserialize::AnyElementTypeDeserializer; +} ///A utility type, not for public use #[derive(Debug, Default)] pub struct QnameListAType(pub Vec); @@ -1089,15 +1187,6 @@ impl DeserializeBytes for QnameListAType { } } impl WithDeserializerFromBytes for QnameListAType {} -///A utility type, not for public use -#[derive(Debug, Default)] -pub struct QnameListType(pub Vec); -impl DeserializeBytes for QnameListType { - fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result { - Ok(Self(helper.deserialize_list(bytes)?)) - } -} -impl WithDeserializerFromBytes for QnameListType {} #[derive(Debug)] pub struct FieldElementType { pub any_attribute: AnyAttributes, @@ -1151,6 +1240,15 @@ impl FacetType { impl WithDeserializer for FacetType { type Deserializer = quick_xml_deserialize::FacetTypeDeserializer; } +///A utility type, not for public use +#[derive(Debug, Default)] +pub struct QnameListType(pub Vec); +impl DeserializeBytes for QnameListType { + fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result { + Ok(Self(helper.deserialize_list(bytes)?)) + } +} +impl WithDeserializerFromBytes for QnameListType {} #[derive(Debug)] pub enum QnameListAItemType { String(String), @@ -1493,29 +1591,29 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, ), SimpleType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), ComplexType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Group( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), AttributeGroup( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Element( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Attribute( Option, @@ -1595,21 +1693,23 @@ pub mod quick_xml_deserialize { helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"simpleType") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_simple_type(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"complexType") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_complex_type(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"group") ) { - let output = ::init(helper, event)?; + let output = ::init(helper, event)?; return self.handle_group(helper, Default::default(), None, output); } if matches!( @@ -1617,14 +1717,15 @@ pub mod quick_xml_deserialize { Some(b"attributeGroup") ) { let output = - ::init(helper, event)?; + ::init(helper, event)?; return self.handle_attribute_group(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"element") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_element(helper, Default::default(), None, output); } if matches!( @@ -1847,8 +1948,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_simple_type( - values: &mut Option, - value: super::SimpleBaseType, + values: &mut Option, + value: super::TopLevelSimpleType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -1859,8 +1960,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_complex_type( - values: &mut Option, - value: super::ComplexBaseType, + values: &mut Option, + value: super::TopLevelComplexType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -1871,8 +1972,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_group( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::RealGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -1883,8 +1984,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_attribute_group( - values: &mut Option, - value: super::AttributeGroupType, + values: &mut Option, + value: super::NamedAttributeGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -1895,8 +1996,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_element( - values: &mut Option, - value: super::ElementType, + values: &mut Option, + value: super::TopLevelElementType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -2140,9 +2241,9 @@ pub mod quick_xml_deserialize { fn handle_simple_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::SimpleBaseType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::TopLevelSimpleType>, ) -> Result, Error> { use SchemaElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -2174,9 +2275,9 @@ pub mod quick_xml_deserialize { fn handle_complex_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::ComplexBaseType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::TopLevelComplexType>, ) -> Result, Error> { use SchemaElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -2208,9 +2309,9 @@ pub mod quick_xml_deserialize { fn handle_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::RealGroupType>, ) -> Result, Error> { use SchemaElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -2242,9 +2343,9 @@ pub mod quick_xml_deserialize { fn handle_attribute_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AttributeGroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::NamedAttributeGroupType>, ) -> Result, Error> { use SchemaElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -2276,9 +2377,9 @@ pub mod quick_xml_deserialize { fn handle_element<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::ElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::TopLevelElementType>, ) -> Result, Error> { use SchemaElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -3395,24 +3496,24 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, ), SimpleType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), ComplexType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Group( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), AttributeGroup( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Done__(super::RedefineElementTypeContent), Unknown__, @@ -3436,21 +3537,23 @@ pub mod quick_xml_deserialize { helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"simpleType") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_simple_type(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"complexType") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_complex_type(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"group") ) { - let output = ::init(helper, event)?; + let output = ::init(helper, event)?; return self.handle_group(helper, Default::default(), None, output); } if matches!( @@ -3458,7 +3561,7 @@ pub mod quick_xml_deserialize { Some(b"attributeGroup") ) { let output = - ::init(helper, event)?; + ::init(helper, event)?; return self.handle_attribute_group(helper, Default::default(), None, output); } } @@ -3534,8 +3637,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_simple_type( - values: &mut Option, - value: super::SimpleBaseType, + values: &mut Option, + value: super::TopLevelSimpleType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -3546,8 +3649,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_complex_type( - values: &mut Option, - value: super::ComplexBaseType, + values: &mut Option, + value: super::TopLevelComplexType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -3558,8 +3661,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_group( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::RealGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -3570,8 +3673,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_attribute_group( - values: &mut Option, - value: super::AttributeGroupType, + values: &mut Option, + value: super::NamedAttributeGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -3618,9 +3721,9 @@ pub mod quick_xml_deserialize { fn handle_simple_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::SimpleBaseType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::TopLevelSimpleType>, ) -> Result, Error> { use RedefineElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -3652,9 +3755,9 @@ pub mod quick_xml_deserialize { fn handle_complex_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::ComplexBaseType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::TopLevelComplexType>, ) -> Result, Error> { use RedefineElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -3686,9 +3789,9 @@ pub mod quick_xml_deserialize { fn handle_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::RealGroupType>, ) -> Result, Error> { use RedefineElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -3720,9 +3823,9 @@ pub mod quick_xml_deserialize { fn handle_attribute_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AttributeGroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::NamedAttributeGroupType>, ) -> Result, Error> { use RedefineElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -4145,29 +4248,29 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, ), SimpleType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), ComplexType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Group( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), AttributeGroup( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Element( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Attribute( Option, @@ -4201,21 +4304,23 @@ pub mod quick_xml_deserialize { helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"simpleType") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_simple_type(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"complexType") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_complex_type(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"group") ) { - let output = ::init(helper, event)?; + let output = ::init(helper, event)?; return self.handle_group(helper, Default::default(), None, output); } if matches!( @@ -4223,14 +4328,15 @@ pub mod quick_xml_deserialize { Some(b"attributeGroup") ) { let output = - ::init(helper, event)?; + ::init(helper, event)?; return self.handle_attribute_group(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"element") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_element(helper, Default::default(), None, output); } if matches!( @@ -4348,8 +4454,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_simple_type( - values: &mut Option, - value: super::SimpleBaseType, + values: &mut Option, + value: super::TopLevelSimpleType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -4360,8 +4466,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_complex_type( - values: &mut Option, - value: super::ComplexBaseType, + values: &mut Option, + value: super::TopLevelComplexType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -4372,8 +4478,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_group( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::RealGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -4384,8 +4490,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_attribute_group( - values: &mut Option, - value: super::AttributeGroupType, + values: &mut Option, + value: super::NamedAttributeGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -4396,8 +4502,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_element( - values: &mut Option, - value: super::ElementType, + values: &mut Option, + value: super::TopLevelElementType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -4468,9 +4574,9 @@ pub mod quick_xml_deserialize { fn handle_simple_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::SimpleBaseType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::TopLevelSimpleType>, ) -> Result, Error> { use OverrideElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -4502,9 +4608,9 @@ pub mod quick_xml_deserialize { fn handle_complex_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::ComplexBaseType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::TopLevelComplexType>, ) -> Result, Error> { use OverrideElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -4536,9 +4642,9 @@ pub mod quick_xml_deserialize { fn handle_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::RealGroupType>, ) -> Result, Error> { use OverrideElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -4570,9 +4676,9 @@ pub mod quick_xml_deserialize { fn handle_attribute_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AttributeGroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::NamedAttributeGroupType>, ) -> Result, Error> { use OverrideElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -4604,9 +4710,9 @@ pub mod quick_xml_deserialize { fn handle_element<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::ElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::TopLevelElementType>, ) -> Result, Error> { use OverrideElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -5750,22 +5856,22 @@ pub mod quick_xml_deserialize { } } #[derive(Debug)] - pub struct SimpleBaseTypeDeserializer { + pub struct TopLevelSimpleTypeDeserializer { any_attribute: AnyAttributes, id: Option, final_: Option, - name: Option, - content: Vec, - state__: Box, + name: String, + content: Vec, + state__: Box, } #[derive(Debug)] - enum SimpleBaseTypeDeserializerState { + enum TopLevelSimpleTypeDeserializerState { Init__, Next__, - Content__(::Deserializer), + Content__(::Deserializer), Unknown__, } - impl SimpleBaseTypeDeserializer { + impl TopLevelSimpleTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -5799,32 +5905,32 @@ pub mod quick_xml_deserialize { any_attribute: any_attribute, id: id, final_: final_, - name: name, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, content: Vec::new(), - state__: Box::new(SimpleBaseTypeDeserializerState::Init__), + state__: Box::new(TopLevelSimpleTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: SimpleBaseTypeDeserializerState, + state: TopLevelSimpleTypeDeserializerState, ) -> Result<(), Error> { - if let SimpleBaseTypeDeserializerState::Content__(deserializer) = state { + if let TopLevelSimpleTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content(&mut self, value: super::SimpleBaseTypeContent) -> Result<(), Error> { + fn store_content(&mut self, value: super::TopLevelSimpleTypeContent) -> Result<(), Error> { self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::SimpleBaseTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::TopLevelSimpleTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use SimpleBaseTypeDeserializerState as S; + use TopLevelSimpleTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -5845,7 +5951,7 @@ pub mod quick_xml_deserialize { Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - if self.content.len() < 1usize { + if self.content.len() < 2usize { *fallback = Some(S::Content__(deserializer)); *self.state__ = S::Next__; Ok(ElementHandlerOutput::from_event(event, allow_any)) @@ -5857,19 +5963,19 @@ pub mod quick_xml_deserialize { } } } - impl<'de> Deserializer<'de, super::SimpleBaseType> for SimpleBaseTypeDeserializer { + impl<'de> Deserializer<'de, super::TopLevelSimpleType> for TopLevelSimpleTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::SimpleBaseType> { + ) -> DeserializerResult<'de, super::TopLevelSimpleType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::SimpleBaseType> { - use SimpleBaseTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::TopLevelSimpleType> { + use TopLevelSimpleTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -5894,7 +6000,7 @@ pub mod quick_xml_deserialize { } (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); - let output = ::init( + let output = ::init( helper, event, )?; match self.handle_content(helper, output, &mut fallback)? { @@ -5919,33 +6025,28 @@ pub mod quick_xml_deserialize { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - SimpleBaseTypeDeserializerState::Unknown__, + TopLevelSimpleTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::SimpleBaseType { + Ok(super::TopLevelSimpleType { any_attribute: self.any_attribute, id: self.id, final_: self.final_, name: self.name, - content: helper.finish_vec(1usize, Some(2usize), self.content)?, + content: helper.finish_vec(1usize, Some(3usize), self.content)?, }) } } #[derive(Debug)] - pub struct SimpleBaseTypeContentDeserializer { - state__: Box, + pub struct TopLevelSimpleTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - pub enum SimpleBaseTypeContentDeserializerState { + pub enum TopLevelSimpleTypeContentDeserializerState { Init__, - Annotation( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), Restriction( Option, Option<::Deserializer>, @@ -5961,24 +6062,21 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, Option<::Deserializer>, ), - Done__(super::SimpleBaseTypeContent), + Annotation( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::TopLevelSimpleTypeContent), Unknown__, } - impl SimpleBaseTypeContentDeserializer { + impl TopLevelSimpleTypeContentDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, event: Event<'de>, ) -> Result, Error> { if let Event::Start(x) | Event::Empty(x) = &event { - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"annotation") - ) { - let output = - ::init(helper, event)?; - return self.handle_annotation(helper, Default::default(), None, output); - } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"restriction") @@ -6002,32 +6100,31 @@ pub mod quick_xml_deserialize { ::init(helper, event)?; return self.handle_union_(helper, Default::default(), None, output); } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"annotation") + ) { + let output = + ::init(helper, event)?; + return self.handle_annotation(helper, Default::default(), None, output); + } } - *self.state__ = SimpleBaseTypeContentDeserializerState::Init__; + *self.state__ = TopLevelSimpleTypeContentDeserializerState::Init__; Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( helper: &mut DeserializeHelper, - state: SimpleBaseTypeContentDeserializerState, - ) -> Result { - use SimpleBaseTypeContentDeserializerState as S; + state: TopLevelSimpleTypeContentDeserializerState, + ) -> Result { + use TopLevelSimpleTypeContentDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Annotation(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_annotation(&mut values, value)?; - } - Ok(super::SimpleBaseTypeContent::Annotation( - helper.finish_element("annotation", values)?, - )) - } S::Restriction(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; Self::store_restriction(&mut values, value)?; } - Ok(super::SimpleBaseTypeContent::Restriction( + Ok(super::TopLevelSimpleTypeContent::Restriction( helper.finish_element("restriction", values)?, )) } @@ -6036,7 +6133,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_list(&mut values, value)?; } - Ok(super::SimpleBaseTypeContent::List( + Ok(super::TopLevelSimpleTypeContent::List( helper.finish_element("list", values)?, )) } @@ -6045,26 +6142,23 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_union_(&mut values, value)?; } - Ok(super::SimpleBaseTypeContent::Union( + Ok(super::TopLevelSimpleTypeContent::Union( helper.finish_element("union", values)?, )) } + S::Annotation(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_annotation(&mut values, value)?; + } + Ok(super::TopLevelSimpleTypeContent::Annotation( + helper.finish_element("annotation", values)?, + )) + } S::Done__(data) => Ok(data), _ => unreachable!(), } } - fn store_annotation( - values: &mut Option, - value: super::AnnotationElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"annotation", - )))?; - } - *values = Some(value); - Ok(()) - } fn store_restriction( values: &mut Option, value: super::RestrictionElementType, @@ -6099,39 +6193,17 @@ pub mod quick_xml_deserialize { *values = Some(value); Ok(()) } - fn handle_annotation<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AnnotationElementType>, - ) -> Result, Error> { - use SimpleBaseTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_annotation(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_annotation(&mut values, data)?; - let data = Self::finish_state(helper, S::Annotation(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Annotation(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } + fn store_annotation( + values: &mut Option, + value: super::AnnotationElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"annotation", + )))?; } + *values = Some(value); + Ok(()) } fn handle_restriction<'de>( &mut self, @@ -6140,7 +6212,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::RestrictionElementType>, ) -> Result, Error> { - use SimpleBaseTypeContentDeserializerState as S; + use TopLevelSimpleTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -6174,7 +6246,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::ListElementType>, ) -> Result, Error> { - use SimpleBaseTypeContentDeserializerState as S; + use TopLevelSimpleTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -6208,7 +6280,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::UnionElementType>, ) -> Result, Error> { - use SimpleBaseTypeContentDeserializerState as S; + use TopLevelSimpleTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -6235,19 +6307,58 @@ pub mod quick_xml_deserialize { } } } + fn handle_annotation<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnnotationElementType>, + ) -> Result, Error> { + use TopLevelSimpleTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_annotation(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_annotation(&mut values, data)?; + let data = Self::finish_state(helper, S::Annotation(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Annotation(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } } - impl<'de> Deserializer<'de, super::SimpleBaseTypeContent> for SimpleBaseTypeContentDeserializer { + impl<'de> Deserializer<'de, super::TopLevelSimpleTypeContent> + for TopLevelSimpleTypeContentDeserializer + { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::SimpleBaseTypeContent> { + ) -> DeserializerResult<'de, super::TopLevelSimpleTypeContent> { let deserializer = Self { - state__: Box::new(SimpleBaseTypeContentDeserializerState::Init__), + state__: Box::new(TopLevelSimpleTypeContentDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, SimpleBaseTypeContentDeserializerState::Init__) => + if matches!( + &*x.state__, + TopLevelSimpleTypeContentDeserializerState::Init__ + ) => { DeserializerArtifact::None } @@ -6259,43 +6370,43 @@ pub mod quick_xml_deserialize { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::SimpleBaseTypeContent> { - use SimpleBaseTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::TopLevelSimpleTypeContent> { + use TopLevelSimpleTypeContentDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Annotation(values, fallback, Some(deserializer)), event) => { + (S::Restriction(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_annotation(helper, values, fallback, output)? { + match self.handle_restriction(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Restriction(values, fallback, Some(deserializer)), event) => { + (S::List(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_restriction(helper, values, fallback, output)? { + match self.handle_list(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::List(values, fallback, Some(deserializer)), event) => { + (S::Union(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_list(helper, values, fallback, output)? { + match self.handle_union_(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Union(values, fallback, Some(deserializer)), event) => { + (S::Annotation(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_union_(helper, values, fallback, output)? { + match self.handle_annotation(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -6318,16 +6429,16 @@ pub mod quick_xml_deserialize { ElementHandlerOutput::Continue { event, .. } => event, }, ( - S::Annotation(values, fallback, None), + S::Restriction(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"annotation", + b"restriction", true, )?; - match self.handle_annotation(helper, values, fallback, output)? { + match self.handle_restriction(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -6335,16 +6446,16 @@ pub mod quick_xml_deserialize { } } ( - S::Restriction(values, fallback, None), + S::List(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"restriction", + b"list", true, )?; - match self.handle_restriction(helper, values, fallback, output)? { + match self.handle_list(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -6352,16 +6463,16 @@ pub mod quick_xml_deserialize { } } ( - S::List(values, fallback, None), + S::Union(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"list", + b"union", true, )?; - match self.handle_list(helper, values, fallback, output)? { + match self.handle_union_(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -6369,16 +6480,16 @@ pub mod quick_xml_deserialize { } } ( - S::Union(values, fallback, None), + S::Annotation(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"union", + b"annotation", true, )?; - match self.handle_union_(helper, values, fallback, output)? { + match self.handle_annotation(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -6409,31 +6520,31 @@ pub mod quick_xml_deserialize { fn finish( self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct ComplexBaseTypeDeserializer { + pub struct TopLevelComplexTypeDeserializer { any_attribute: AnyAttributes, id: Option, - name: Option, + name: String, mixed: Option, abstract_: bool, final_: Option, block: Option, default_attributes_apply: bool, - content: Vec, - state__: Box, + content: Vec, + state__: Box, } #[derive(Debug)] - enum ComplexBaseTypeDeserializerState { + enum TopLevelComplexTypeDeserializerState { Init__, Next__, - Content__(::Deserializer), + Content__(::Deserializer), Unknown__, } - impl ComplexBaseTypeDeserializer { + impl TopLevelComplexTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -6494,38 +6605,38 @@ pub mod quick_xml_deserialize { Ok(Self { any_attribute: any_attribute, id: id, - name: name, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, mixed: mixed, - abstract_: abstract_.unwrap_or_else(super::ComplexBaseType::default_abstract_), + abstract_: abstract_.unwrap_or_else(super::TopLevelComplexType::default_abstract_), final_: final_, block: block, default_attributes_apply: default_attributes_apply - .unwrap_or_else(super::ComplexBaseType::default_default_attributes_apply), + .unwrap_or_else(super::TopLevelComplexType::default_default_attributes_apply), content: Vec::new(), - state__: Box::new(ComplexBaseTypeDeserializerState::Init__), + state__: Box::new(TopLevelComplexTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: ComplexBaseTypeDeserializerState, + state: TopLevelComplexTypeDeserializerState, ) -> Result<(), Error> { - if let ComplexBaseTypeDeserializerState::Content__(deserializer) = state { + if let TopLevelComplexTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content(&mut self, value: super::ComplexBaseTypeContent) -> Result<(), Error> { + fn store_content(&mut self, value: super::TopLevelComplexTypeContent) -> Result<(), Error> { self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::ComplexBaseTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::TopLevelComplexTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use ComplexBaseTypeDeserializerState as S; + use TopLevelComplexTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -6553,19 +6664,19 @@ pub mod quick_xml_deserialize { } } } - impl<'de> Deserializer<'de, super::ComplexBaseType> for ComplexBaseTypeDeserializer { + impl<'de> Deserializer<'de, super::TopLevelComplexType> for TopLevelComplexTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::ComplexBaseType> { + ) -> DeserializerResult<'de, super::TopLevelComplexType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::ComplexBaseType> { - use ComplexBaseTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::TopLevelComplexType> { + use TopLevelComplexTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -6590,7 +6701,7 @@ pub mod quick_xml_deserialize { } (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); - let output = ::init( + let output = ::init( helper, event, )?; match self.handle_content(helper, output, &mut fallback)? { @@ -6615,13 +6726,13 @@ pub mod quick_xml_deserialize { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - ComplexBaseTypeDeserializerState::Unknown__, + TopLevelComplexTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::ComplexBaseType { + Ok(super::TopLevelComplexType { any_attribute: self.any_attribute, id: self.id, name: self.name, @@ -6635,17 +6746,12 @@ pub mod quick_xml_deserialize { } } #[derive(Debug)] - pub struct ComplexBaseTypeContentDeserializer { - state__: Box, + pub struct TopLevelComplexTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - pub enum ComplexBaseTypeContentDeserializerState { + pub enum TopLevelComplexTypeContentDeserializerState { Init__, - Annotation( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), SimpleContent( Option, Option<::Deserializer>, @@ -6662,24 +6768,24 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, ), Group( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), All( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Choice( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Sequence( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Attribute( Option, @@ -6687,9 +6793,9 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, ), AttributeGroup( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), AnyAttribute( Option, @@ -6701,24 +6807,21 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, Option<::Deserializer>, ), - Done__(super::ComplexBaseTypeContent), + Annotation( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::TopLevelComplexTypeContent), Unknown__, } - impl ComplexBaseTypeContentDeserializer { + impl TopLevelComplexTypeContentDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, event: Event<'de>, ) -> Result, Error> { if let Event::Start(x) | Event::Empty(x) = &event { - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"annotation") - ) { - let output = - ::init(helper, event)?; - return self.handle_annotation(helper, Default::default(), None, output); - } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"simpleContent") @@ -6748,28 +6851,31 @@ pub mod quick_xml_deserialize { helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"group") ) { - let output = ::init(helper, event)?; + let output = ::init(helper, event)?; return self.handle_group(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"all") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_all(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"choice") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_choice(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"sequence") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_sequence(helper, Default::default(), None, output); } if matches!( @@ -6784,7 +6890,7 @@ pub mod quick_xml_deserialize { Some(b"attributeGroup") ) { let output = - ::init(helper, event)?; + ::init(helper, event)?; return self.handle_attribute_group(helper, Default::default(), None, output); } if matches!( @@ -6802,32 +6908,31 @@ pub mod quick_xml_deserialize { let output = ::init(helper, event)?; return self.handle_assert(helper, Default::default(), None, output); } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"annotation") + ) { + let output = + ::init(helper, event)?; + return self.handle_annotation(helper, Default::default(), None, output); + } } - *self.state__ = ComplexBaseTypeContentDeserializerState::Init__; + *self.state__ = TopLevelComplexTypeContentDeserializerState::Init__; Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( helper: &mut DeserializeHelper, - state: ComplexBaseTypeContentDeserializerState, - ) -> Result { - use ComplexBaseTypeContentDeserializerState as S; + state: TopLevelComplexTypeContentDeserializerState, + ) -> Result { + use TopLevelComplexTypeContentDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Annotation(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_annotation(&mut values, value)?; - } - Ok(super::ComplexBaseTypeContent::Annotation( - helper.finish_element("annotation", values)?, - )) - } S::SimpleContent(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; Self::store_simple_content(&mut values, value)?; } - Ok(super::ComplexBaseTypeContent::SimpleContent( + Ok(super::TopLevelComplexTypeContent::SimpleContent( helper.finish_element("simpleContent", values)?, )) } @@ -6836,7 +6941,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_complex_content(&mut values, value)?; } - Ok(super::ComplexBaseTypeContent::ComplexContent( + Ok(super::TopLevelComplexTypeContent::ComplexContent( helper.finish_element("complexContent", values)?, )) } @@ -6845,7 +6950,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_open_content(&mut values, value)?; } - Ok(super::ComplexBaseTypeContent::OpenContent( + Ok(super::TopLevelComplexTypeContent::OpenContent( helper.finish_element("openContent", values)?, )) } @@ -6854,7 +6959,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_group(&mut values, value)?; } - Ok(super::ComplexBaseTypeContent::Group( + Ok(super::TopLevelComplexTypeContent::Group( helper.finish_element("group", values)?, )) } @@ -6863,7 +6968,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_all(&mut values, value)?; } - Ok(super::ComplexBaseTypeContent::All( + Ok(super::TopLevelComplexTypeContent::All( helper.finish_element("all", values)?, )) } @@ -6872,7 +6977,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_choice(&mut values, value)?; } - Ok(super::ComplexBaseTypeContent::Choice( + Ok(super::TopLevelComplexTypeContent::Choice( helper.finish_element("choice", values)?, )) } @@ -6881,7 +6986,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_sequence(&mut values, value)?; } - Ok(super::ComplexBaseTypeContent::Sequence( + Ok(super::TopLevelComplexTypeContent::Sequence( helper.finish_element("sequence", values)?, )) } @@ -6890,7 +6995,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_attribute(&mut values, value)?; } - Ok(super::ComplexBaseTypeContent::Attribute( + Ok(super::TopLevelComplexTypeContent::Attribute( helper.finish_element("attribute", values)?, )) } @@ -6899,7 +7004,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_attribute_group(&mut values, value)?; } - Ok(super::ComplexBaseTypeContent::AttributeGroup( + Ok(super::TopLevelComplexTypeContent::AttributeGroup( helper.finish_element("attributeGroup", values)?, )) } @@ -6908,7 +7013,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_any_attribute(&mut values, value)?; } - Ok(super::ComplexBaseTypeContent::AnyAttribute( + Ok(super::TopLevelComplexTypeContent::AnyAttribute( helper.finish_element("anyAttribute", values)?, )) } @@ -6917,26 +7022,23 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_assert(&mut values, value)?; } - Ok(super::ComplexBaseTypeContent::Assert( + Ok(super::TopLevelComplexTypeContent::Assert( helper.finish_element("assert", values)?, )) } + S::Annotation(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_annotation(&mut values, value)?; + } + Ok(super::TopLevelComplexTypeContent::Annotation( + helper.finish_element("annotation", values)?, + )) + } S::Done__(data) => Ok(data), _ => unreachable!(), } } - fn store_annotation( - values: &mut Option, - value: super::AnnotationElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"annotation", - )))?; - } - *values = Some(value); - Ok(()) - } fn store_simple_content( values: &mut Option, value: super::SimpleContentElementType, @@ -6974,8 +7076,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_group( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::RealGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -6986,8 +7088,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_all( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"all")))?; @@ -6996,8 +7098,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_choice( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -7008,8 +7110,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_sequence( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -7032,8 +7134,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_attribute_group( - values: &mut Option, - value: super::AttributeGroupType, + values: &mut Option, + value: super::AttributeGroupRefType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -7067,39 +7169,17 @@ pub mod quick_xml_deserialize { *values = Some(value); Ok(()) } - fn handle_annotation<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AnnotationElementType>, - ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_annotation(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_annotation(&mut values, data)?; - let data = Self::finish_state(helper, S::Annotation(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Annotation(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } + fn store_annotation( + values: &mut Option, + value: super::AnnotationElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"annotation", + )))?; } + *values = Some(value); + Ok(()) } fn handle_simple_content<'de>( &mut self, @@ -7108,7 +7188,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::SimpleContentElementType>, ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; + use TopLevelComplexTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7142,7 +7222,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::ComplexContentElementType>, ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; + use TopLevelComplexTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7176,7 +7256,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::OpenContentElementType>, ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; + use TopLevelComplexTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7206,11 +7286,11 @@ pub mod quick_xml_deserialize { fn handle_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::RealGroupType>, ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; + use TopLevelComplexTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7240,11 +7320,11 @@ pub mod quick_xml_deserialize { fn handle_all<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; + use TopLevelComplexTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7274,11 +7354,11 @@ pub mod quick_xml_deserialize { fn handle_choice<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; + use TopLevelComplexTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7308,11 +7388,11 @@ pub mod quick_xml_deserialize { fn handle_sequence<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; + use TopLevelComplexTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7346,7 +7426,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AttributeType>, ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; + use TopLevelComplexTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7376,11 +7456,11 @@ pub mod quick_xml_deserialize { fn handle_attribute_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AttributeGroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AttributeGroupRefType>, ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; + use TopLevelComplexTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7414,7 +7494,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AnyAttributeElementType>, ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; + use TopLevelComplexTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7448,7 +7528,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AssertionType>, ) -> Result, Error> { - use ComplexBaseTypeContentDeserializerState as S; + use TopLevelComplexTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7475,19 +7555,58 @@ pub mod quick_xml_deserialize { } } } - } - impl<'de> Deserializer<'de, super::ComplexBaseTypeContent> for ComplexBaseTypeContentDeserializer { - fn init( + fn handle_annotation<'de>( + &mut self, helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> DeserializerResult<'de, super::ComplexBaseTypeContent> { - let deserializer = Self { - state__: Box::new(ComplexBaseTypeContentDeserializerState::Init__), - }; - let mut output = deserializer.next(helper, event)?; - output.artifact = match output.artifact { + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnnotationElementType>, + ) -> Result, Error> { + use TopLevelComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_annotation(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_annotation(&mut values, data)?; + let data = Self::finish_state(helper, S::Annotation(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Annotation(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::TopLevelComplexTypeContent> + for TopLevelComplexTypeContentDeserializer + { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::TopLevelComplexTypeContent> { + let deserializer = Self { + state__: Box::new(TopLevelComplexTypeContentDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, ComplexBaseTypeContentDeserializerState::Init__) => + if matches!( + &*x.state__, + TopLevelComplexTypeContentDeserializerState::Init__ + ) => { DeserializerArtifact::None } @@ -7499,22 +7618,13 @@ pub mod quick_xml_deserialize { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::ComplexBaseTypeContent> { - use ComplexBaseTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::TopLevelComplexTypeContent> { + use TopLevelComplexTypeContentDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Annotation(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_annotation(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } (S::SimpleContent(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; match self.handle_simple_content(helper, values, fallback, output)? { @@ -7614,6 +7724,15 @@ pub mod quick_xml_deserialize { ElementHandlerOutput::Continue { event, .. } => event, } } + (S::Annotation(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_annotation(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(Self::finish_state( @@ -7629,23 +7748,6 @@ pub mod quick_xml_deserialize { } ElementHandlerOutput::Continue { event, .. } => event, }, - ( - S::Annotation(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"annotation", - true, - )?; - match self.handle_annotation(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } ( S::SimpleContent(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), @@ -7833,6 +7935,23 @@ pub mod quick_xml_deserialize { ElementHandlerOutput::Continue { event, .. } => event, } } + ( + S::Annotation(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"annotation", + true, + )?; + match self.handle_annotation(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } (state @ S::Done__(_), event) => { *self.state__ = state; break (DeserializerEvent::Continue(event), false); @@ -7857,29 +7976,29 @@ pub mod quick_xml_deserialize { fn finish( self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct GroupTypeDeserializer { + pub struct RealGroupTypeDeserializer { any_attribute: AnyAttributes, id: Option, name: Option, ref_: Option, min_occurs: usize, max_occurs: super::AllNniType, - content: Vec, - state__: Box, + content: Vec, + state__: Box, } #[derive(Debug)] - enum GroupTypeDeserializerState { + enum RealGroupTypeDeserializerState { Init__, Next__, - Content__(::Deserializer), + Content__(::Deserializer), Unknown__, } - impl GroupTypeDeserializer { + impl RealGroupTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -7926,33 +8045,33 @@ pub mod quick_xml_deserialize { id: id, name: name, ref_: ref_, - min_occurs: min_occurs.unwrap_or_else(super::GroupType::default_min_occurs), - max_occurs: max_occurs.unwrap_or_else(super::GroupType::default_max_occurs), + min_occurs: min_occurs.unwrap_or_else(super::RealGroupType::default_min_occurs), + max_occurs: max_occurs.unwrap_or_else(super::RealGroupType::default_max_occurs), content: Vec::new(), - state__: Box::new(GroupTypeDeserializerState::Init__), + state__: Box::new(RealGroupTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: GroupTypeDeserializerState, + state: RealGroupTypeDeserializerState, ) -> Result<(), Error> { - if let GroupTypeDeserializerState::Content__(deserializer) = state { + if let RealGroupTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content(&mut self, value: super::GroupTypeContent) -> Result<(), Error> { + fn store_content(&mut self, value: super::RealGroupTypeContent) -> Result<(), Error> { self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::GroupTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::RealGroupTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use GroupTypeDeserializerState as S; + use RealGroupTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -7973,26 +8092,31 @@ pub mod quick_xml_deserialize { Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *fallback = Some(S::Content__(deserializer)); - *self.state__ = S::Next__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + if self.content.len() < 1usize { + *fallback = Some(S::Content__(deserializer)); + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } else { + *self.state__ = S::Content__(deserializer); + Ok(ElementHandlerOutput::from_event_end(event, allow_any)) + } } } } } - impl<'de> Deserializer<'de, super::GroupType> for GroupTypeDeserializer { + impl<'de> Deserializer<'de, super::RealGroupType> for RealGroupTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::GroupType> { + ) -> DeserializerResult<'de, super::RealGroupType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::GroupType> { - use GroupTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::RealGroupType> { + use RealGroupTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -8018,7 +8142,7 @@ pub mod quick_xml_deserialize { (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); let output = - ::init(helper, event)?; + ::init(helper, event)?; match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) @@ -8038,66 +8162,54 @@ pub mod quick_xml_deserialize { allow_any, }) } - fn finish(mut self, helper: &mut DeserializeHelper) -> Result { - let state = replace(&mut *self.state__, GroupTypeDeserializerState::Unknown__); + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace( + &mut *self.state__, + RealGroupTypeDeserializerState::Unknown__, + ); self.finish_state(helper, state)?; - Ok(super::GroupType { + Ok(super::RealGroupType { any_attribute: self.any_attribute, id: self.id, name: self.name, ref_: self.ref_, min_occurs: self.min_occurs, max_occurs: self.max_occurs, - content: helper.finish_vec(0usize, None, self.content)?, + content: helper.finish_vec(0usize, Some(2usize), self.content)?, }) } } #[derive(Debug)] - pub struct GroupTypeContentDeserializer { - state__: Box, + pub struct RealGroupTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - pub enum GroupTypeContentDeserializerState { + pub enum RealGroupTypeContentDeserializerState { Init__, Annotation( Option, Option<::Deserializer>, Option<::Deserializer>, ), - Element( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Group( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), All( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Choice( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Sequence( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Any( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Done__(super::GroupTypeContent), + Done__(super::RealGroupTypeContent), Unknown__, } - impl GroupTypeContentDeserializer { + impl RealGroupTypeContentDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, @@ -8112,57 +8224,39 @@ pub mod quick_xml_deserialize { ::init(helper, event)?; return self.handle_annotation(helper, Default::default(), None, output); } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"element") - ) { - let output = ::init(helper, event)?; - return self.handle_element(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"group") - ) { - let output = ::init(helper, event)?; - return self.handle_group(helper, Default::default(), None, output); - } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"all") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_all(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"choice") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_choice(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"sequence") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_sequence(helper, Default::default(), None, output); } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"any") - ) { - let output = ::init(helper, event)?; - return self.handle_any(helper, Default::default(), None, output); - } } - *self.state__ = GroupTypeContentDeserializerState::Init__; + *self.state__ = RealGroupTypeContentDeserializerState::Init__; Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( helper: &mut DeserializeHelper, - state: GroupTypeContentDeserializerState, - ) -> Result { - use GroupTypeContentDeserializerState as S; + state: RealGroupTypeContentDeserializerState, + ) -> Result { + use RealGroupTypeContentDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), S::Annotation(mut values, None, deserializer) => { @@ -8170,34 +8264,16 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_annotation(&mut values, value)?; } - Ok(super::GroupTypeContent::Annotation( + Ok(super::RealGroupTypeContent::Annotation( helper.finish_element("annotation", values)?, )) } - S::Element(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_element(&mut values, value)?; - } - Ok(super::GroupTypeContent::Element( - helper.finish_element("element", values)?, - )) - } - S::Group(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_group(&mut values, value)?; - } - Ok(super::GroupTypeContent::Group( - helper.finish_element("group", values)?, - )) - } S::All(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; Self::store_all(&mut values, value)?; } - Ok(super::GroupTypeContent::All( + Ok(super::RealGroupTypeContent::All( helper.finish_element("all", values)?, )) } @@ -8206,7 +8282,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_choice(&mut values, value)?; } - Ok(super::GroupTypeContent::Choice( + Ok(super::RealGroupTypeContent::Choice( helper.finish_element("choice", values)?, )) } @@ -8215,19 +8291,10 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_sequence(&mut values, value)?; } - Ok(super::GroupTypeContent::Sequence( + Ok(super::RealGroupTypeContent::Sequence( helper.finish_element("sequence", values)?, )) } - S::Any(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_any(&mut values, value)?; - } - Ok(super::GroupTypeContent::Any( - helper.finish_element("any", values)?, - )) - } S::Done__(data) => Ok(data), _ => unreachable!(), } @@ -8244,33 +8311,9 @@ pub mod quick_xml_deserialize { *values = Some(value); Ok(()) } - fn store_element( - values: &mut Option, - value: super::ElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"element", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_group( - values: &mut Option, - value: super::GroupType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"group", - )))?; - } - *values = Some(value); - Ok(()) - } fn store_all( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"all")))?; @@ -8279,8 +8322,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_choice( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -8291,8 +8334,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_sequence( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -8302,16 +8345,6 @@ pub mod quick_xml_deserialize { *values = Some(value); Ok(()) } - fn store_any( - values: &mut Option, - value: super::AnyElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"any")))?; - } - *values = Some(value); - Ok(()) - } fn handle_annotation<'de>( &mut self, helper: &mut DeserializeHelper, @@ -8319,7 +8352,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AnnotationElementType>, ) -> Result, Error> { - use GroupTypeContentDeserializerState as S; + use RealGroupTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -8346,82 +8379,14 @@ pub mod quick_xml_deserialize { } } } - fn handle_element<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::ElementType>, - ) -> Result, Error> { - use GroupTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_element(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_element(&mut values, data)?; - let data = Self::finish_state(helper, S::Element(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Element(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_group<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, - ) -> Result, Error> { - use GroupTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_group(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_group(&mut values, data)?; - let data = Self::finish_state(helper, S::Group(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Group(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } fn handle_all<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use GroupTypeContentDeserializerState as S; + use RealGroupTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -8451,11 +8416,11 @@ pub mod quick_xml_deserialize { fn handle_choice<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use GroupTypeContentDeserializerState as S; + use RealGroupTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -8485,11 +8450,11 @@ pub mod quick_xml_deserialize { fn handle_sequence<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use GroupTypeContentDeserializerState as S; + use RealGroupTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -8516,53 +8481,19 @@ pub mod quick_xml_deserialize { } } } - fn handle_any<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AnyElementType>, - ) -> Result, Error> { - use GroupTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_any(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_any(&mut values, data)?; - let data = Self::finish_state(helper, S::Any(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Any(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } } - impl<'de> Deserializer<'de, super::GroupTypeContent> for GroupTypeContentDeserializer { + impl<'de> Deserializer<'de, super::RealGroupTypeContent> for RealGroupTypeContentDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::GroupTypeContent> { + ) -> DeserializerResult<'de, super::RealGroupTypeContent> { let deserializer = Self { - state__: Box::new(GroupTypeContentDeserializerState::Init__), + state__: Box::new(RealGroupTypeContentDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, GroupTypeContentDeserializerState::Init__) => + if matches!(&*x.state__, RealGroupTypeContentDeserializerState::Init__) => { DeserializerArtifact::None } @@ -8574,8 +8505,8 @@ pub mod quick_xml_deserialize { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::GroupTypeContent> { - use GroupTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::RealGroupTypeContent> { + use RealGroupTypeContentDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); @@ -8590,24 +8521,6 @@ pub mod quick_xml_deserialize { ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Element(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_element(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Group(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_group(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } (S::All(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; match self.handle_all(helper, values, fallback, output)? { @@ -8635,15 +8548,6 @@ pub mod quick_xml_deserialize { ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Any(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_any(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(Self::finish_state( @@ -8676,40 +8580,6 @@ pub mod quick_xml_deserialize { ElementHandlerOutput::Continue { event, .. } => event, } } - ( - S::Element(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"element", - true, - )?; - match self.handle_element(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::Group(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"group", - true, - )?; - match self.handle_group(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } ( S::All(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), @@ -8761,23 +8631,6 @@ pub mod quick_xml_deserialize { ElementHandlerOutput::Continue { event, .. } => event, } } - ( - S::Any(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"any", - true, - )?; - match self.handle_any(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } (state @ S::Done__(_), event) => { *self.state__ = state; break (DeserializerEvent::Continue(event), false); @@ -8799,27 +8652,29 @@ pub mod quick_xml_deserialize { allow_any, }) } - fn finish(self, helper: &mut DeserializeHelper) -> Result { + fn finish( + self, + helper: &mut DeserializeHelper, + ) -> Result { Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct AttributeGroupTypeDeserializer { + pub struct NamedAttributeGroupTypeDeserializer { any_attribute: AnyAttributes, id: Option, - name: Option, - ref_: Option, - content: Vec, - state__: Box, + name: String, + content: Vec, + state__: Box, } #[derive(Debug)] - enum AttributeGroupTypeDeserializerState { + enum NamedAttributeGroupTypeDeserializerState { Init__, Next__, - Content__(::Deserializer), + Content__(::Deserializer), Unknown__, } - impl AttributeGroupTypeDeserializer { + impl NamedAttributeGroupTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -8827,7 +8682,6 @@ pub mod quick_xml_deserialize { let mut any_attribute = AnyAttributes::default(); let mut id: Option = None; let mut name: Option = None; - let mut ref_: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( @@ -8840,11 +8694,6 @@ pub mod quick_xml_deserialize { Some(b"name") ) { helper.read_attrib(&mut name, b"name", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"ref") - ) { - helper.read_attrib(&mut ref_, b"ref", &attrib.value)?; } else { any_attribute.push(attrib)?; } @@ -8852,33 +8701,35 @@ pub mod quick_xml_deserialize { Ok(Self { any_attribute: any_attribute, id: id, - name: name, - ref_: ref_, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, content: Vec::new(), - state__: Box::new(AttributeGroupTypeDeserializerState::Init__), + state__: Box::new(NamedAttributeGroupTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: AttributeGroupTypeDeserializerState, + state: NamedAttributeGroupTypeDeserializerState, ) -> Result<(), Error> { - if let AttributeGroupTypeDeserializerState::Content__(deserializer) = state { + if let NamedAttributeGroupTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content(&mut self, value: super::AttributeGroupTypeContent) -> Result<(), Error> { + fn store_content( + &mut self, + value: super::NamedAttributeGroupTypeContent, + ) -> Result<(), Error> { self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::AttributeGroupTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::NamedAttributeGroupTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use AttributeGroupTypeDeserializerState as S; + use NamedAttributeGroupTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -8906,19 +8757,21 @@ pub mod quick_xml_deserialize { } } } - impl<'de> Deserializer<'de, super::AttributeGroupType> for AttributeGroupTypeDeserializer { + impl<'de> Deserializer<'de, super::NamedAttributeGroupType> + for NamedAttributeGroupTypeDeserializer + { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AttributeGroupType> { + ) -> DeserializerResult<'de, super::NamedAttributeGroupType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AttributeGroupType> { - use AttributeGroupTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::NamedAttributeGroupType> { + use NamedAttributeGroupTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -8943,9 +8796,10 @@ pub mod quick_xml_deserialize { } (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); - let output = ::init( - helper, event, - )?; + let output = + ::init( + helper, event, + )?; match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) @@ -8968,27 +8822,26 @@ pub mod quick_xml_deserialize { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - AttributeGroupTypeDeserializerState::Unknown__, + NamedAttributeGroupTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::AttributeGroupType { + Ok(super::NamedAttributeGroupType { any_attribute: self.any_attribute, id: self.id, name: self.name, - ref_: self.ref_, content: helper.finish_vec(0usize, None, self.content)?, }) } } #[derive(Debug)] - pub struct AttributeGroupTypeContentDeserializer { - state__: Box, + pub struct NamedAttributeGroupTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - pub enum AttributeGroupTypeContentDeserializerState { + pub enum NamedAttributeGroupTypeContentDeserializerState { Init__, Annotation( Option, @@ -9001,19 +8854,19 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, ), AttributeGroup( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), AnyAttribute( Option, Option<::Deserializer>, Option<::Deserializer>, ), - Done__(super::AttributeGroupTypeContent), + Done__(super::NamedAttributeGroupTypeContent), Unknown__, } - impl AttributeGroupTypeContentDeserializer { + impl NamedAttributeGroupTypeContentDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, @@ -9040,7 +8893,7 @@ pub mod quick_xml_deserialize { Some(b"attributeGroup") ) { let output = - ::init(helper, event)?; + ::init(helper, event)?; return self.handle_attribute_group(helper, Default::default(), None, output); } if matches!( @@ -9052,14 +8905,14 @@ pub mod quick_xml_deserialize { return self.handle_any_attribute(helper, Default::default(), None, output); } } - *self.state__ = AttributeGroupTypeContentDeserializerState::Init__; + *self.state__ = NamedAttributeGroupTypeContentDeserializerState::Init__; Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( helper: &mut DeserializeHelper, - state: AttributeGroupTypeContentDeserializerState, - ) -> Result { - use AttributeGroupTypeContentDeserializerState as S; + state: NamedAttributeGroupTypeContentDeserializerState, + ) -> Result { + use NamedAttributeGroupTypeContentDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), S::Annotation(mut values, None, deserializer) => { @@ -9067,7 +8920,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_annotation(&mut values, value)?; } - Ok(super::AttributeGroupTypeContent::Annotation( + Ok(super::NamedAttributeGroupTypeContent::Annotation( helper.finish_element("annotation", values)?, )) } @@ -9076,7 +8929,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_attribute(&mut values, value)?; } - Ok(super::AttributeGroupTypeContent::Attribute( + Ok(super::NamedAttributeGroupTypeContent::Attribute( helper.finish_element("attribute", values)?, )) } @@ -9085,7 +8938,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_attribute_group(&mut values, value)?; } - Ok(super::AttributeGroupTypeContent::AttributeGroup( + Ok(super::NamedAttributeGroupTypeContent::AttributeGroup( helper.finish_element("attributeGroup", values)?, )) } @@ -9094,7 +8947,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_any_attribute(&mut values, value)?; } - Ok(super::AttributeGroupTypeContent::AnyAttribute( + Ok(super::NamedAttributeGroupTypeContent::AnyAttribute( helper.finish_element("anyAttribute", values)?, )) } @@ -9127,8 +8980,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_attribute_group( - values: &mut Option, - value: super::AttributeGroupType, + values: &mut Option, + value: super::AttributeGroupRefType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -9157,7 +9010,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AnnotationElementType>, ) -> Result, Error> { - use AttributeGroupTypeContentDeserializerState as S; + use NamedAttributeGroupTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -9191,7 +9044,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AttributeType>, ) -> Result, Error> { - use AttributeGroupTypeContentDeserializerState as S; + use NamedAttributeGroupTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -9221,11 +9074,11 @@ pub mod quick_xml_deserialize { fn handle_attribute_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AttributeGroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AttributeGroupRefType>, ) -> Result, Error> { - use AttributeGroupTypeContentDeserializerState as S; + use NamedAttributeGroupTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -9259,7 +9112,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AnyAttributeElementType>, ) -> Result, Error> { - use AttributeGroupTypeContentDeserializerState as S; + use NamedAttributeGroupTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -9287,22 +9140,22 @@ pub mod quick_xml_deserialize { } } } - impl<'de> Deserializer<'de, super::AttributeGroupTypeContent> - for AttributeGroupTypeContentDeserializer + impl<'de> Deserializer<'de, super::NamedAttributeGroupTypeContent> + for NamedAttributeGroupTypeContentDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AttributeGroupTypeContent> { + ) -> DeserializerResult<'de, super::NamedAttributeGroupTypeContent> { let deserializer = Self { - state__: Box::new(AttributeGroupTypeContentDeserializerState::Init__), + state__: Box::new(NamedAttributeGroupTypeContentDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) if matches!( &*x.state__, - AttributeGroupTypeContentDeserializerState::Init__ + NamedAttributeGroupTypeContentDeserializerState::Init__ ) => { DeserializerArtifact::None @@ -9315,8 +9168,8 @@ pub mod quick_xml_deserialize { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AttributeGroupTypeContent> { - use AttributeGroupTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::NamedAttributeGroupTypeContent> { + use NamedAttributeGroupTypeContentDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); @@ -9465,39 +9318,34 @@ pub mod quick_xml_deserialize { fn finish( self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct ElementTypeDeserializer { + pub struct TopLevelElementTypeDeserializer { any_attribute: AnyAttributes, id: Option, - name: Option, - ref_: Option, + name: String, type_: Option, substitution_group: Option, - min_occurs: usize, - max_occurs: super::AllNniType, default: Option, fixed: Option, nillable: Option, abstract_: bool, final_: Option, block: Option, - form: Option, - target_namespace: Option, - content: Vec, - state__: Box, + content: Vec, + state__: Box, } #[derive(Debug)] - enum ElementTypeDeserializerState { + enum TopLevelElementTypeDeserializerState { Init__, Next__, - Content__(::Deserializer), + Content__(::Deserializer), Unknown__, } - impl ElementTypeDeserializer { + impl TopLevelElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -9505,19 +9353,14 @@ pub mod quick_xml_deserialize { let mut any_attribute = AnyAttributes::default(); let mut id: Option = None; let mut name: Option = None; - let mut ref_: Option = None; let mut type_: Option = None; let mut substitution_group: Option = None; - let mut min_occurs: Option = None; - let mut max_occurs: Option = None; let mut default: Option = None; let mut fixed: Option = None; let mut nillable: Option = None; let mut abstract_: Option = None; let mut final_: Option = None; let mut block: Option = None; - let mut form: Option = None; - let mut target_namespace: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( @@ -9530,11 +9373,6 @@ pub mod quick_xml_deserialize { Some(b"name") ) { helper.read_attrib(&mut name, b"name", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"ref") - ) { - helper.read_attrib(&mut ref_, b"ref", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_XS), Some(b"type") @@ -9549,16 +9387,6 @@ pub mod quick_xml_deserialize { b"substitutionGroup", &attrib.value, )?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"minOccurs") - ) { - helper.read_attrib(&mut min_occurs, b"minOccurs", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"maxOccurs") - ) { - helper.read_attrib(&mut max_occurs, b"maxOccurs", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_XS), Some(b"default") @@ -9589,16 +9417,6 @@ pub mod quick_xml_deserialize { Some(b"block") ) { helper.read_attrib(&mut block, b"block", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"form") - ) { - helper.read_attrib(&mut form, b"form", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"targetNamespace") - ) { - helper.read_attrib(&mut target_namespace, b"targetNamespace", &attrib.value)?; } else { any_attribute.push(attrib)?; } @@ -9606,45 +9424,40 @@ pub mod quick_xml_deserialize { Ok(Self { any_attribute: any_attribute, id: id, - name: name, - ref_: ref_, + name: name.ok_or_else(|| ErrorKind::MissingAttribute("name".into()))?, type_: type_, substitution_group: substitution_group, - min_occurs: min_occurs.unwrap_or_else(super::ElementType::default_min_occurs), - max_occurs: max_occurs.unwrap_or_else(super::ElementType::default_max_occurs), default: default, fixed: fixed, nillable: nillable, - abstract_: abstract_.unwrap_or_else(super::ElementType::default_abstract_), + abstract_: abstract_.unwrap_or_else(super::TopLevelElementType::default_abstract_), final_: final_, block: block, - form: form, - target_namespace: target_namespace, content: Vec::new(), - state__: Box::new(ElementTypeDeserializerState::Init__), + state__: Box::new(TopLevelElementTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: ElementTypeDeserializerState, + state: TopLevelElementTypeDeserializerState, ) -> Result<(), Error> { - if let ElementTypeDeserializerState::Content__(deserializer) = state { + if let TopLevelElementTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content(&mut self, value: super::ElementTypeContent) -> Result<(), Error> { + fn store_content(&mut self, value: super::TopLevelElementTypeContent) -> Result<(), Error> { self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::ElementTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::TopLevelElementTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use ElementTypeDeserializerState as S; + use TopLevelElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -9672,19 +9485,19 @@ pub mod quick_xml_deserialize { } } } - impl<'de> Deserializer<'de, super::ElementType> for ElementTypeDeserializer { + impl<'de> Deserializer<'de, super::TopLevelElementType> for TopLevelElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::ElementType> { + ) -> DeserializerResult<'de, super::TopLevelElementType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::ElementType> { - use ElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::TopLevelElementType> { + use TopLevelElementTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -9709,8 +9522,9 @@ pub mod quick_xml_deserialize { } (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); - let output = - ::init(helper, event)?; + let output = ::init( + helper, event, + )?; match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) @@ -9730,36 +9544,37 @@ pub mod quick_xml_deserialize { allow_any, }) } - fn finish(mut self, helper: &mut DeserializeHelper) -> Result { - let state = replace(&mut *self.state__, ElementTypeDeserializerState::Unknown__); + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + TopLevelElementTypeDeserializerState::Unknown__, + ); self.finish_state(helper, state)?; - Ok(super::ElementType { + Ok(super::TopLevelElementType { any_attribute: self.any_attribute, id: self.id, name: self.name, - ref_: self.ref_, type_: self.type_, substitution_group: self.substitution_group, - min_occurs: self.min_occurs, - max_occurs: self.max_occurs, default: self.default, fixed: self.fixed, nillable: self.nillable, abstract_: self.abstract_, final_: self.final_, block: self.block, - form: self.form, - target_namespace: self.target_namespace, content: helper.finish_vec(0usize, None, self.content)?, }) } } #[derive(Debug)] - pub struct ElementTypeContentDeserializer { - state__: Box, + pub struct TopLevelElementTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - pub enum ElementTypeContentDeserializerState { + pub enum TopLevelElementTypeContentDeserializerState { Init__, Annotation( Option, @@ -9767,14 +9582,14 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, ), SimpleType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), ComplexType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Alternative( Option, @@ -9796,10 +9611,10 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, Option<::Deserializer>, ), - Done__(super::ElementTypeContent), + Done__(super::TopLevelElementTypeContent), Unknown__, } - impl ElementTypeContentDeserializer { + impl TopLevelElementTypeContentDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, @@ -9818,14 +9633,15 @@ pub mod quick_xml_deserialize { helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"simpleType") ) { - let output = ::init(helper, event)?; + let output = ::init(helper, event)?; return self.handle_simple_type(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"complexType") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_complex_type(helper, Default::default(), None, output); } if matches!( @@ -9858,14 +9674,14 @@ pub mod quick_xml_deserialize { return self.handle_keyref(helper, Default::default(), None, output); } } - *self.state__ = ElementTypeContentDeserializerState::Init__; + *self.state__ = TopLevelElementTypeContentDeserializerState::Init__; Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( helper: &mut DeserializeHelper, - state: ElementTypeContentDeserializerState, - ) -> Result { - use ElementTypeContentDeserializerState as S; + state: TopLevelElementTypeContentDeserializerState, + ) -> Result { + use TopLevelElementTypeContentDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), S::Annotation(mut values, None, deserializer) => { @@ -9873,7 +9689,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_annotation(&mut values, value)?; } - Ok(super::ElementTypeContent::Annotation( + Ok(super::TopLevelElementTypeContent::Annotation( helper.finish_element("annotation", values)?, )) } @@ -9882,7 +9698,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_simple_type(&mut values, value)?; } - Ok(super::ElementTypeContent::SimpleType( + Ok(super::TopLevelElementTypeContent::SimpleType( helper.finish_element("simpleType", values)?, )) } @@ -9891,7 +9707,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_complex_type(&mut values, value)?; } - Ok(super::ElementTypeContent::ComplexType( + Ok(super::TopLevelElementTypeContent::ComplexType( helper.finish_element("complexType", values)?, )) } @@ -9900,7 +9716,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_alternative(&mut values, value)?; } - Ok(super::ElementTypeContent::Alternative( + Ok(super::TopLevelElementTypeContent::Alternative( helper.finish_element("alternative", values)?, )) } @@ -9909,7 +9725,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_unique(&mut values, value)?; } - Ok(super::ElementTypeContent::Unique( + Ok(super::TopLevelElementTypeContent::Unique( helper.finish_element("unique", values)?, )) } @@ -9918,7 +9734,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_key(&mut values, value)?; } - Ok(super::ElementTypeContent::Key( + Ok(super::TopLevelElementTypeContent::Key( helper.finish_element("key", values)?, )) } @@ -9927,7 +9743,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_keyref(&mut values, value)?; } - Ok(super::ElementTypeContent::Keyref( + Ok(super::TopLevelElementTypeContent::Keyref( helper.finish_element("keyref", values)?, )) } @@ -9948,8 +9764,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_simple_type( - values: &mut Option, - value: super::SimpleBaseType, + values: &mut Option, + value: super::LocalSimpleType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -9960,8 +9776,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_complex_type( - values: &mut Option, - value: super::ComplexBaseType, + values: &mut Option, + value: super::LocalComplexType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -10024,7 +9840,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AnnotationElementType>, ) -> Result, Error> { - use ElementTypeContentDeserializerState as S; + use TopLevelElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -10054,11 +9870,11 @@ pub mod quick_xml_deserialize { fn handle_simple_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::SimpleBaseType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LocalSimpleType>, ) -> Result, Error> { - use ElementTypeContentDeserializerState as S; + use TopLevelElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -10088,11 +9904,11 @@ pub mod quick_xml_deserialize { fn handle_complex_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::ComplexBaseType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LocalComplexType>, ) -> Result, Error> { - use ElementTypeContentDeserializerState as S; + use TopLevelElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -10126,7 +9942,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AltType>, ) -> Result, Error> { - use ElementTypeContentDeserializerState as S; + use TopLevelElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -10160,7 +9976,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::KeybaseType>, ) -> Result, Error> { - use ElementTypeContentDeserializerState as S; + use TopLevelElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -10194,7 +10010,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::KeybaseType>, ) -> Result, Error> { - use ElementTypeContentDeserializerState as S; + use TopLevelElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -10228,7 +10044,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::KeyrefElementType>, ) -> Result, Error> { - use ElementTypeContentDeserializerState as S; + use TopLevelElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -10256,18 +10072,23 @@ pub mod quick_xml_deserialize { } } } - impl<'de> Deserializer<'de, super::ElementTypeContent> for ElementTypeContentDeserializer { + impl<'de> Deserializer<'de, super::TopLevelElementTypeContent> + for TopLevelElementTypeContentDeserializer + { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::ElementTypeContent> { + ) -> DeserializerResult<'de, super::TopLevelElementTypeContent> { let deserializer = Self { - state__: Box::new(ElementTypeContentDeserializerState::Init__), + state__: Box::new(TopLevelElementTypeContentDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, ElementTypeContentDeserializerState::Init__) => + if matches!( + &*x.state__, + TopLevelElementTypeContentDeserializerState::Init__ + ) => { DeserializerArtifact::None } @@ -10279,8 +10100,8 @@ pub mod quick_xml_deserialize { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::ElementTypeContent> { - use ElementTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::TopLevelElementTypeContent> { + use TopLevelElementTypeContentDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); @@ -10507,7 +10328,7 @@ pub mod quick_xml_deserialize { fn finish( self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { Self::finish_state(helper, *self.state__) } } @@ -10525,14 +10346,14 @@ pub mod quick_xml_deserialize { target_namespace: Option, inheritable: Option, annotation: Option, - simple_type: Option, + simple_type: Option, state__: Box, } #[derive(Debug)] enum AttributeTypeDeserializerState { Init__, Annotation(Option<::Deserializer>), - SimpleType(Option<::Deserializer>), + SimpleType(Option<::Deserializer>), Done__, Unknown__, } @@ -10651,7 +10472,7 @@ pub mod quick_xml_deserialize { self.annotation = Some(value); Ok(()) } - fn store_simple_type(&mut self, value: super::SimpleBaseType) -> Result<(), Error> { + fn store_simple_type(&mut self, value: super::LocalSimpleType) -> Result<(), Error> { if self.simple_type.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( b"simpleType", @@ -10696,7 +10517,7 @@ pub mod quick_xml_deserialize { fn handle_simple_type<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::SimpleBaseType>, + output: DeserializerOutput<'de, super::LocalSimpleType>, fallback: &mut Option, ) -> Result, Error> { use AttributeTypeDeserializerState as S; @@ -12434,9 +12255,9 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, ), SimpleType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Facet( Option, @@ -12472,7 +12293,7 @@ pub mod quick_xml_deserialize { helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"simpleType") ) { - let output = ::init(helper, event)?; + let output = ::init(helper, event)?; return self.handle_simple_type(helper, Default::default(), None, output); } event = { @@ -12563,8 +12384,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_simple_type( - values: &mut Option, - value: super::SimpleBaseType, + values: &mut Option, + value: super::LocalSimpleType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -12632,9 +12453,9 @@ pub mod quick_xml_deserialize { fn handle_simple_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::SimpleBaseType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LocalSimpleType>, ) -> Result, Error> { use RestrictionElementTypeContentDeserializerState as S; let DeserializerOutput { @@ -12910,14 +12731,14 @@ pub mod quick_xml_deserialize { id: Option, item_type: Option, annotation: Option, - simple_type: Option, + simple_type: Option, state__: Box, } #[derive(Debug)] enum ListElementTypeDeserializerState { Init__, Annotation(Option<::Deserializer>), - SimpleType(Option<::Deserializer>), + SimpleType(Option<::Deserializer>), Done__, Unknown__, } @@ -12980,7 +12801,7 @@ pub mod quick_xml_deserialize { self.annotation = Some(value); Ok(()) } - fn store_simple_type(&mut self, value: super::SimpleBaseType) -> Result<(), Error> { + fn store_simple_type(&mut self, value: super::LocalSimpleType) -> Result<(), Error> { if self.simple_type.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( b"simpleType", @@ -13025,7 +12846,7 @@ pub mod quick_xml_deserialize { fn handle_simple_type<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::SimpleBaseType>, + output: DeserializerOutput<'de, super::LocalSimpleType>, fallback: &mut Option, ) -> Result, Error> { use ListElementTypeDeserializerState as S; @@ -13182,7 +13003,7 @@ pub mod quick_xml_deserialize { id: self.id, item_type: self.item_type, annotation: self.annotation, - simple_type: self.simple_type.map(Box::new), + simple_type: self.simple_type, }) } } @@ -13192,14 +13013,14 @@ pub mod quick_xml_deserialize { id: Option, member_types: Option, annotation: Option, - simple_type: Vec, + simple_type: Vec, state__: Box, } #[derive(Debug)] enum UnionElementTypeDeserializerState { Init__, Annotation(Option<::Deserializer>), - SimpleType(Option<::Deserializer>), + SimpleType(Option<::Deserializer>), Done__, Unknown__, } @@ -13262,7 +13083,7 @@ pub mod quick_xml_deserialize { self.annotation = Some(value); Ok(()) } - fn store_simple_type(&mut self, value: super::SimpleBaseType) -> Result<(), Error> { + fn store_simple_type(&mut self, value: super::LocalSimpleType) -> Result<(), Error> { self.simple_type.push(value); Ok(()) } @@ -13302,7 +13123,7 @@ pub mod quick_xml_deserialize { fn handle_simple_type<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::SimpleBaseType>, + output: DeserializerOutput<'de, super::LocalSimpleType>, fallback: &mut Option, ) -> Result, Error> { use UnionElementTypeDeserializerState as S; @@ -14879,34 +14700,30 @@ pub mod quick_xml_deserialize { } } #[derive(Debug)] - pub struct AnyAttributeElementTypeDeserializer { + pub struct ExplicitGroupTypeDeserializer { any_attribute: AnyAttributes, id: Option, - namespace: Option, - not_namespace: Option, - process_contents: super::ProcessContentsType, - not_q_name: Option, - annotation: Option, - state__: Box, + min_occurs: usize, + max_occurs: super::AllNniType, + content: Vec, + state__: Box, } #[derive(Debug)] - enum AnyAttributeElementTypeDeserializerState { + enum ExplicitGroupTypeDeserializerState { Init__, - Annotation(Option<::Deserializer>), - Done__, + Next__, + Content__(::Deserializer), Unknown__, } - impl AnyAttributeElementTypeDeserializer { + impl ExplicitGroupTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { let mut any_attribute = AnyAttributes::default(); let mut id: Option = None; - let mut namespace: Option = None; - let mut not_namespace: Option = None; - let mut process_contents: Option = None; - let mut not_q_name: Option = None; + let mut min_occurs: Option = None; + let mut max_occurs: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( @@ -14916,24 +14733,14 @@ pub mod quick_xml_deserialize { helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"namespace") - ) { - helper.read_attrib(&mut namespace, b"namespace", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"notNamespace") - ) { - helper.read_attrib(&mut not_namespace, b"notNamespace", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"processContents") + Some(b"minOccurs") ) { - helper.read_attrib(&mut process_contents, b"processContents", &attrib.value)?; + helper.read_attrib(&mut min_occurs, b"minOccurs", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"notQName") + Some(b"maxOccurs") ) { - helper.read_attrib(&mut not_q_name, b"notQName", &attrib.value)?; + helper.read_attrib(&mut max_occurs, b"maxOccurs", &attrib.value)?; } else { any_attribute.push(attrib)?; } @@ -14941,53 +14748,41 @@ pub mod quick_xml_deserialize { Ok(Self { any_attribute: any_attribute, id: id, - namespace: namespace, - not_namespace: not_namespace, - process_contents: process_contents - .unwrap_or_else(super::AnyAttributeElementType::default_process_contents), - not_q_name: not_q_name, - annotation: None, - state__: Box::new(AnyAttributeElementTypeDeserializerState::Init__), + min_occurs: min_occurs.unwrap_or_else(super::ExplicitGroupType::default_min_occurs), + max_occurs: max_occurs.unwrap_or_else(super::ExplicitGroupType::default_max_occurs), + content: Vec::new(), + state__: Box::new(ExplicitGroupTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: AnyAttributeElementTypeDeserializerState, + state: ExplicitGroupTypeDeserializerState, ) -> Result<(), Error> { - use AnyAttributeElementTypeDeserializerState as S; - match state { - S::Annotation(Some(deserializer)) => { - self.store_annotation(deserializer.finish(helper)?)? - } - _ => (), + if let ExplicitGroupTypeDeserializerState::Content__(deserializer) = state { + self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_annotation(&mut self, value: super::AnnotationElementType) -> Result<(), Error> { - if self.annotation.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"annotation", - )))?; - } - self.annotation = Some(value); + fn store_content(&mut self, value: super::ExplicitGroupTypeContent) -> Result<(), Error> { + self.content.push(value); Ok(()) } - fn handle_annotation<'de>( + fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::AnnotationElementType>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::ExplicitGroupTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use AnyAttributeElementTypeDeserializerState as S; + use ExplicitGroupTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + *self.state__ = fallback.take().unwrap_or(S::Next__); + return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); } if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; @@ -14995,99 +14790,73 @@ pub mod quick_xml_deserialize { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_annotation(data)?; - *self.state__ = S::Done__; + self.store_content(data)?; + *self.state__ = S::Next__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Annotation(Some(deserializer))); - *self.state__ = S::Done__; + *fallback = Some(S::Content__(deserializer)); + *self.state__ = S::Next__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::AnyAttributeElementType> - for AnyAttributeElementTypeDeserializer - { + impl<'de> Deserializer<'de, super::ExplicitGroupType> for ExplicitGroupTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AnyAttributeElementType> { + ) -> DeserializerResult<'de, super::ExplicitGroupType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AnyAttributeElementType> { - use AnyAttributeElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::ExplicitGroupType> { + use ExplicitGroupTypeDeserializerState as S; let mut event = event; let mut fallback = None; - let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Annotation(Some(deserializer)), event) => { + (S::Content__(deserializer), event) => { let output = deserializer.next(helper, event)?; - match self.handle_annotation(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } return Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), event: DeserializerEvent::None, allow_any: false, }); } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Annotation(None); - event - } - (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"annotation", - true, + (state @ (S::Init__ | S::Next__), event) => { + fallback.get_or_insert(state); + let output = ::init( + helper, event, )?; - match self.handle_annotation(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Break(event), false); - } } }; if let Some(fallback) = fallback { *self.state__ = fallback; } + let artifact = DeserializerArtifact::Deserializer(self); Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + artifact, event, allow_any, }) @@ -15095,270 +14864,715 @@ pub mod quick_xml_deserialize { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - AnyAttributeElementTypeDeserializerState::Unknown__, + ExplicitGroupTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::AnyAttributeElementType { + Ok(super::ExplicitGroupType { any_attribute: self.any_attribute, id: self.id, - namespace: self.namespace, - not_namespace: self.not_namespace, - process_contents: self.process_contents, - not_q_name: self.not_q_name, - annotation: self.annotation, + min_occurs: self.min_occurs, + max_occurs: self.max_occurs, + content: helper.finish_vec(0usize, None, self.content)?, }) } } #[derive(Debug)] - pub struct AssertionTypeDeserializer { - any_attribute: AnyAttributes, - id: Option, - test: Option, - xpath_default_namespace: Option, - annotation: Option, - state__: Box, + pub struct ExplicitGroupTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - enum AssertionTypeDeserializerState { + pub enum ExplicitGroupTypeContentDeserializerState { Init__, - Annotation(Option<::Deserializer>), - Done__, + Annotation( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Element( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Group( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Choice( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Sequence( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Any( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::ExplicitGroupTypeContent), Unknown__, } - impl AssertionTypeDeserializer { - fn from_bytes_start( + impl ExplicitGroupTypeContentDeserializer { + fn find_suitable<'de>( + &mut self, helper: &mut DeserializeHelper, - bytes_start: &BytesStart<'_>, - ) -> Result { - let mut any_attribute = AnyAttributes::default(); - let mut id: Option = None; - let mut test: Option = None; - let mut xpath_default_namespace: Option = None; - for attrib in helper.filter_xmlns_attributes(bytes_start) { - let attrib = attrib?; + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"id") + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"annotation") ) { - helper.read_attrib(&mut id, b"id", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"test") + let output = + ::init(helper, event)?; + return self.handle_annotation(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"element") ) { - helper.read_attrib(&mut test, b"test", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"xpathDefaultNamespace") + let output = + ::init(helper, event)?; + return self.handle_element(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"group") ) { - helper.read_attrib( - &mut xpath_default_namespace, - b"xpathDefaultNamespace", - &attrib.value, - )?; - } else { - any_attribute.push(attrib)?; + let output = ::init(helper, event)?; + return self.handle_group(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"choice") + ) { + let output = + ::init(helper, event)?; + return self.handle_choice(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"sequence") + ) { + let output = + ::init(helper, event)?; + return self.handle_sequence(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"any") + ) { + let output = ::init(helper, event)?; + return self.handle_any(helper, Default::default(), None, output); } } - Ok(Self { - any_attribute: any_attribute, - id: id, - test: test, - xpath_default_namespace: xpath_default_namespace, - annotation: None, - state__: Box::new(AssertionTypeDeserializerState::Init__), - }) + *self.state__ = ExplicitGroupTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( - &mut self, helper: &mut DeserializeHelper, - state: AssertionTypeDeserializerState, - ) -> Result<(), Error> { - use AssertionTypeDeserializerState as S; + state: ExplicitGroupTypeContentDeserializerState, + ) -> Result { + use ExplicitGroupTypeContentDeserializerState as S; match state { - S::Annotation(Some(deserializer)) => { - self.store_annotation(deserializer.finish(helper)?)? + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Annotation(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_annotation(&mut values, value)?; + } + Ok(super::ExplicitGroupTypeContent::Annotation( + helper.finish_element("annotation", values)?, + )) } - _ => (), + S::Element(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_element(&mut values, value)?; + } + Ok(super::ExplicitGroupTypeContent::Element( + helper.finish_element("element", values)?, + )) + } + S::Group(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_group(&mut values, value)?; + } + Ok(super::ExplicitGroupTypeContent::Group( + helper.finish_element("group", values)?, + )) + } + S::Choice(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_choice(&mut values, value)?; + } + Ok(super::ExplicitGroupTypeContent::Choice( + helper.finish_element("choice", values)?, + )) + } + S::Sequence(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_sequence(&mut values, value)?; + } + Ok(super::ExplicitGroupTypeContent::Sequence( + helper.finish_element("sequence", values)?, + )) + } + S::Any(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_any(&mut values, value)?; + } + Ok(super::ExplicitGroupTypeContent::Any( + helper.finish_element("any", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), } - Ok(()) } - fn store_annotation(&mut self, value: super::AnnotationElementType) -> Result<(), Error> { - if self.annotation.is_some() { + fn store_annotation( + values: &mut Option, + value: super::AnnotationElementType, + ) -> Result<(), Error> { + if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( b"annotation", )))?; } - self.annotation = Some(value); + *values = Some(value); Ok(()) } - fn handle_annotation<'de>( + fn store_element( + values: &mut Option, + value: super::LocalElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"element", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_group( + values: &mut Option, + value: super::RealGroupType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"group", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_choice( + values: &mut Option, + value: super::ExplicitGroupType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"choice", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_sequence( + values: &mut Option, + value: super::ExplicitGroupType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"sequence", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_any( + values: &mut Option, + value: super::AnyElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"any")))?; + } + *values = Some(value); + Ok(()) + } + fn handle_annotation<'de>( &mut self, helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AnnotationElementType>, - fallback: &mut Option, ) -> Result, Error> { - use AssertionTypeDeserializerState as S; + use ExplicitGroupTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_annotation(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_annotation(data)?; - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_annotation(&mut values, data)?; + let data = Self::finish_state(helper, S::Annotation(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Annotation(Some(deserializer))); - *self.state__ = S::Done__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::Annotation(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_element<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LocalElementType>, + ) -> Result, Error> { + use ExplicitGroupTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_element(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_element(&mut values, data)?; + let data = Self::finish_state(helper, S::Element(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Element(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_group<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::RealGroupType>, + ) -> Result, Error> { + use ExplicitGroupTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_group(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_group(&mut values, data)?; + let data = Self::finish_state(helper, S::Group(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Group(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_choice<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, + ) -> Result, Error> { + use ExplicitGroupTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_choice(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_choice(&mut values, data)?; + let data = Self::finish_state(helper, S::Choice(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Choice(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_sequence<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, + ) -> Result, Error> { + use ExplicitGroupTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_sequence(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_sequence(&mut values, data)?; + let data = Self::finish_state(helper, S::Sequence(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Sequence(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_any<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnyElementType>, + ) -> Result, Error> { + use ExplicitGroupTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_any(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_any(&mut values, data)?; + let data = Self::finish_state(helper, S::Any(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Any(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::AssertionType> for AssertionTypeDeserializer { + impl<'de> Deserializer<'de, super::ExplicitGroupTypeContent> + for ExplicitGroupTypeContentDeserializer + { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AssertionType> { - helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + ) -> DeserializerResult<'de, super::ExplicitGroupTypeContent> { + let deserializer = Self { + state__: Box::new(ExplicitGroupTypeContentDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!( + &*x.state__, + ExplicitGroupTypeContentDeserializerState::Init__ + ) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AssertionType> { - use AssertionTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::ExplicitGroupTypeContent> { + use ExplicitGroupTypeContentDeserializerState as S; let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Annotation(Some(deserializer)), event) => { + (S::Annotation(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_annotation(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_annotation(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Element(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_element(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (_, Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + (S::Group(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_group(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Choice(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_choice(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Sequence(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_sequence(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Any(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_any(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, } + } + (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::None, + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), allow_any: false, }); } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Annotation(None); - event - } - (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => { + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Annotation(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), b"annotation", true, )?; - match self.handle_annotation(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_annotation(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Element(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"element", + true, + )?; + match self.handle_element(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); + ( + S::Group(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"group", + true, + )?; + match self.handle_group(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Choice(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"choice", + true, + )?; + match self.handle_choice(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Sequence(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"sequence", + true, + )?; + match self.handle_sequence(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Any(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"any", + true, + )?; + match self.handle_any(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); } (state, event) => { *self.state__ = state; - break (DeserializerEvent::Break(event), false); + break (DeserializerEvent::Continue(event), false); } } }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + artifact, event, allow_any, }) } - fn finish(mut self, helper: &mut DeserializeHelper) -> Result { - let state = replace( - &mut *self.state__, - AssertionTypeDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::AssertionType { - any_attribute: self.any_attribute, - id: self.id, - test: self.test, - xpath_default_namespace: self.xpath_default_namespace, - annotation: self.annotation, - }) + fn finish( + self, + helper: &mut DeserializeHelper, + ) -> Result { + Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct AnyElementTypeDeserializer { + pub struct AttributeGroupRefTypeDeserializer { any_attribute: AnyAttributes, id: Option, - namespace: Option, - not_namespace: Option, - process_contents: super::ProcessContentsType, - not_q_name: Option, - min_occurs: usize, - max_occurs: super::AllNniType, + ref_: String, annotation: Option, - state__: Box, + state__: Box, } #[derive(Debug)] - enum AnyElementTypeDeserializerState { + enum AttributeGroupRefTypeDeserializerState { Init__, Annotation(Option<::Deserializer>), Done__, Unknown__, } - impl AnyElementTypeDeserializer { + impl AttributeGroupRefTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { let mut any_attribute = AnyAttributes::default(); let mut id: Option = None; - let mut namespace: Option = None; - let mut not_namespace: Option = None; - let mut process_contents: Option = None; - let mut not_q_name: Option = None; - let mut min_occurs: Option = None; - let mut max_occurs: Option = None; + let mut ref_: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( @@ -15368,34 +15582,9 @@ pub mod quick_xml_deserialize { helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"namespace") - ) { - helper.read_attrib(&mut namespace, b"namespace", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"notNamespace") - ) { - helper.read_attrib(&mut not_namespace, b"notNamespace", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"processContents") - ) { - helper.read_attrib(&mut process_contents, b"processContents", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"notQName") - ) { - helper.read_attrib(&mut not_q_name, b"notQName", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"minOccurs") - ) { - helper.read_attrib(&mut min_occurs, b"minOccurs", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"maxOccurs") + Some(b"ref") ) { - helper.read_attrib(&mut max_occurs, b"maxOccurs", &attrib.value)?; + helper.read_attrib(&mut ref_, b"ref", &attrib.value)?; } else { any_attribute.push(attrib)?; } @@ -15403,23 +15592,17 @@ pub mod quick_xml_deserialize { Ok(Self { any_attribute: any_attribute, id: id, - namespace: namespace, - not_namespace: not_namespace, - process_contents: process_contents - .unwrap_or_else(super::AnyElementType::default_process_contents), - not_q_name: not_q_name, - min_occurs: min_occurs.unwrap_or_else(super::AnyElementType::default_min_occurs), - max_occurs: max_occurs.unwrap_or_else(super::AnyElementType::default_max_occurs), + ref_: ref_.ok_or_else(|| ErrorKind::MissingAttribute("ref".into()))?, annotation: None, - state__: Box::new(AnyElementTypeDeserializerState::Init__), + state__: Box::new(AttributeGroupRefTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: AnyElementTypeDeserializerState, + state: AttributeGroupRefTypeDeserializerState, ) -> Result<(), Error> { - use AnyElementTypeDeserializerState as S; + use AttributeGroupRefTypeDeserializerState as S; match state { S::Annotation(Some(deserializer)) => { self.store_annotation(deserializer.finish(helper)?)? @@ -15441,9 +15624,9 @@ pub mod quick_xml_deserialize { &mut self, helper: &mut DeserializeHelper, output: DeserializerOutput<'de, super::AnnotationElementType>, - fallback: &mut Option, + fallback: &mut Option, ) -> Result, Error> { - use AnyElementTypeDeserializerState as S; + use AttributeGroupRefTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -15471,19 +15654,19 @@ pub mod quick_xml_deserialize { } } } - impl<'de> Deserializer<'de, super::AnyElementType> for AnyElementTypeDeserializer { + impl<'de> Deserializer<'de, super::AttributeGroupRefType> for AttributeGroupRefTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AnyElementType> { + ) -> DeserializerResult<'de, super::AttributeGroupRefType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AnyElementType> { - use AnyElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::AttributeGroupRefType> { + use AttributeGroupRefTypeDeserializerState as S; let mut event = event; let mut fallback = None; let mut allow_any_element = false; @@ -15557,52 +15740,49 @@ pub mod quick_xml_deserialize { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - AnyElementTypeDeserializerState::Unknown__, + AttributeGroupRefTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::AnyElementType { + Ok(super::AttributeGroupRefType { any_attribute: self.any_attribute, id: self.id, - namespace: self.namespace, - not_namespace: self.not_namespace, - process_contents: self.process_contents, - not_q_name: self.not_q_name, - min_occurs: self.min_occurs, - max_occurs: self.max_occurs, + ref_: self.ref_, annotation: self.annotation, }) } } #[derive(Debug)] - pub struct AltTypeDeserializer { + pub struct AnyAttributeElementTypeDeserializer { any_attribute: AnyAttributes, id: Option, - test: Option, - type_: Option, - xpath_default_namespace: Option, - content: Vec, - state__: Box, + namespace: Option, + not_namespace: Option, + process_contents: super::ProcessContentsType, + not_q_name: Option, + annotation: Option, + state__: Box, } #[derive(Debug)] - enum AltTypeDeserializerState { + enum AnyAttributeElementTypeDeserializerState { Init__, - Next__, - Content__(::Deserializer), + Annotation(Option<::Deserializer>), + Done__, Unknown__, } - impl AltTypeDeserializer { + impl AnyAttributeElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { let mut any_attribute = AnyAttributes::default(); let mut id: Option = None; - let mut test: Option = None; - let mut type_: Option = None; - let mut xpath_default_namespace: Option = None; + let mut namespace: Option = None; + let mut not_namespace: Option = None; + let mut process_contents: Option = None; + let mut not_q_name: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( @@ -15612,23 +15792,24 @@ pub mod quick_xml_deserialize { helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"test") + Some(b"namespace") ) { - helper.read_attrib(&mut test, b"test", &attrib.value)?; + helper.read_attrib(&mut namespace, b"namespace", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"type") + Some(b"notNamespace") ) { - helper.read_attrib(&mut type_, b"type", &attrib.value)?; + helper.read_attrib(&mut not_namespace, b"notNamespace", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"xpathDefaultNamespace") + Some(b"processContents") ) { - helper.read_attrib( - &mut xpath_default_namespace, - b"xpathDefaultNamespace", - &attrib.value, - )?; + helper.read_attrib(&mut process_contents, b"processContents", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"notQName") + ) { + helper.read_attrib(&mut not_q_name, b"notQName", &attrib.value)?; } else { any_attribute.push(attrib)?; } @@ -15636,42 +15817,53 @@ pub mod quick_xml_deserialize { Ok(Self { any_attribute: any_attribute, id: id, - test: test, - type_: type_, - xpath_default_namespace: xpath_default_namespace, - content: Vec::new(), - state__: Box::new(AltTypeDeserializerState::Init__), + namespace: namespace, + not_namespace: not_namespace, + process_contents: process_contents + .unwrap_or_else(super::AnyAttributeElementType::default_process_contents), + not_q_name: not_q_name, + annotation: None, + state__: Box::new(AnyAttributeElementTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: AltTypeDeserializerState, + state: AnyAttributeElementTypeDeserializerState, ) -> Result<(), Error> { - if let AltTypeDeserializerState::Content__(deserializer) = state { - self.store_content(deserializer.finish(helper)?)?; + use AnyAttributeElementTypeDeserializerState as S; + match state { + S::Annotation(Some(deserializer)) => { + self.store_annotation(deserializer.finish(helper)?)? + } + _ => (), } Ok(()) } - fn store_content(&mut self, value: super::AltTypeContent) -> Result<(), Error> { - self.content.push(value); + fn store_annotation(&mut self, value: super::AnnotationElementType) -> Result<(), Error> { + if self.annotation.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"annotation", + )))?; + } + self.annotation = Some(value); Ok(()) } - fn handle_content<'de>( + fn handle_annotation<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::AltTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::AnnotationElementType>, + fallback: &mut Option, ) -> Result, Error> { - use AltTypeDeserializerState as S; + use AnyAttributeElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = fallback.take().unwrap_or(S::Next__); - return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; @@ -15679,502 +15871,358 @@ pub mod quick_xml_deserialize { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_content(data)?; - *self.state__ = S::Next__; + self.store_annotation(data)?; + *self.state__ = S::Done__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - if self.content.len() < 1usize { - *fallback = Some(S::Content__(deserializer)); - *self.state__ = S::Next__; - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } else { - *self.state__ = S::Content__(deserializer); - Ok(ElementHandlerOutput::from_event_end(event, allow_any)) - } + fallback.get_or_insert(S::Annotation(Some(deserializer))); + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::AltType> for AltTypeDeserializer { + impl<'de> Deserializer<'de, super::AnyAttributeElementType> + for AnyAttributeElementTypeDeserializer + { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AltType> { + ) -> DeserializerResult<'de, super::AnyAttributeElementType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AltType> { - use AltTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::AnyAttributeElementType> { + use AnyAttributeElementTypeDeserializerState as S; let mut event = event; let mut fallback = None; + let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Content__(deserializer), event) => { + (S::Annotation(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_content(helper, output, &mut fallback)? { + match self.handle_annotation(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } return Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), event: DeserializerEvent::None, allow_any: false, }); } - (state @ (S::Init__ | S::Next__), event) => { - fallback.get_or_insert(state); - let output = - ::init(helper, event)?; - match self.handle_content(helper, output, &mut fallback)? { + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Annotation(None); + event + } + (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"annotation", + true, + )?; + match self.handle_annotation(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } } }; if let Some(fallback) = fallback { *self.state__ = fallback; } - let artifact = DeserializerArtifact::Deserializer(self); Ok(DeserializerOutput { - artifact, + artifact: DeserializerArtifact::Deserializer(self), event, allow_any, }) } - fn finish(mut self, helper: &mut DeserializeHelper) -> Result { - let state = replace(&mut *self.state__, AltTypeDeserializerState::Unknown__); + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + AnyAttributeElementTypeDeserializerState::Unknown__, + ); self.finish_state(helper, state)?; - Ok(super::AltType { + Ok(super::AnyAttributeElementType { any_attribute: self.any_attribute, id: self.id, - test: self.test, - type_: self.type_, - xpath_default_namespace: self.xpath_default_namespace, - content: helper.finish_vec(0usize, Some(2usize), self.content)?, + namespace: self.namespace, + not_namespace: self.not_namespace, + process_contents: self.process_contents, + not_q_name: self.not_q_name, + annotation: self.annotation, }) } } #[derive(Debug)] - pub struct AltTypeContentDeserializer { - state__: Box, + pub struct AssertionTypeDeserializer { + any_attribute: AnyAttributes, + id: Option, + test: Option, + xpath_default_namespace: Option, + annotation: Option, + state__: Box, } #[derive(Debug)] - pub enum AltTypeContentDeserializerState { + enum AssertionTypeDeserializerState { Init__, - Annotation( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - SimpleType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - ComplexType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Done__(super::AltTypeContent), + Annotation(Option<::Deserializer>), + Done__, Unknown__, } - impl AltTypeContentDeserializer { - fn find_suitable<'de>( - &mut self, + impl AssertionTypeDeserializer { + fn from_bytes_start( helper: &mut DeserializeHelper, - event: Event<'de>, - ) -> Result, Error> { - if let Event::Start(x) | Event::Empty(x) = &event { + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut any_attribute = AnyAttributes::default(); + let mut id: Option = None; + let mut test: Option = None; + let mut xpath_default_namespace: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"annotation") + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"id") ) { - let output = - ::init(helper, event)?; - return self.handle_annotation(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"simpleType") + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"test") ) { - let output = ::init(helper, event)?; - return self.handle_simple_type(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"complexType") + helper.read_attrib(&mut test, b"test", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"xpathDefaultNamespace") ) { - let output = ::init(helper, event)?; - return self.handle_complex_type(helper, Default::default(), None, output); + helper.read_attrib( + &mut xpath_default_namespace, + b"xpathDefaultNamespace", + &attrib.value, + )?; + } else { + any_attribute.push(attrib)?; } } - *self.state__ = AltTypeContentDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent(event, false)) + Ok(Self { + any_attribute: any_attribute, + id: id, + test: test, + xpath_default_namespace: xpath_default_namespace, + annotation: None, + state__: Box::new(AssertionTypeDeserializerState::Init__), + }) } fn finish_state( + &mut self, helper: &mut DeserializeHelper, - state: AltTypeContentDeserializerState, - ) -> Result { - use AltTypeContentDeserializerState as S; + state: AssertionTypeDeserializerState, + ) -> Result<(), Error> { + use AssertionTypeDeserializerState as S; match state { - S::Init__ => Err(ErrorKind::MissingContent.into()), - S::Annotation(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_annotation(&mut values, value)?; - } - Ok(super::AltTypeContent::Annotation( - helper.finish_element("annotation", values)?, - )) - } - S::SimpleType(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_simple_type(&mut values, value)?; - } - Ok(super::AltTypeContent::SimpleType( - helper.finish_element("simpleType", values)?, - )) - } - S::ComplexType(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_complex_type(&mut values, value)?; - } - Ok(super::AltTypeContent::ComplexType( - helper.finish_element("complexType", values)?, - )) + S::Annotation(Some(deserializer)) => { + self.store_annotation(deserializer.finish(helper)?)? } - S::Done__(data) => Ok(data), - _ => unreachable!(), - } - } - fn store_annotation( - values: &mut Option, - value: super::AnnotationElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"annotation", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_simple_type( - values: &mut Option, - value: super::SimpleBaseType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"simpleType", - )))?; + _ => (), } - *values = Some(value); Ok(()) } - fn store_complex_type( - values: &mut Option, - value: super::ComplexBaseType, - ) -> Result<(), Error> { - if values.is_some() { + fn store_annotation(&mut self, value: super::AnnotationElementType) -> Result<(), Error> { + if self.annotation.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"complexType", + b"annotation", )))?; } - *values = Some(value); + self.annotation = Some(value); Ok(()) } fn handle_annotation<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AnnotationElementType>, + fallback: &mut Option, ) -> Result, Error> { - use AltTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_annotation(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_annotation(&mut values, data)?; - let data = Self::finish_state(helper, S::Annotation(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Annotation(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_simple_type<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::SimpleBaseType>, - ) -> Result, Error> { - use AltTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_simple_type(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_simple_type(&mut values, data)?; - let data = Self::finish_state(helper, S::SimpleType(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::SimpleType(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_complex_type<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::ComplexBaseType>, - ) -> Result, Error> { - use AltTypeContentDeserializerState as S; + use AssertionTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_complex_type(&mut values, data)?; + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_complex_type(&mut values, data)?; - let data = Self::finish_state(helper, S::ComplexType(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) + self.store_annotation(data)?; + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::ComplexType(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) + fallback.get_or_insert(S::Annotation(Some(deserializer))); + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::AltTypeContent> for AltTypeContentDeserializer { + impl<'de> Deserializer<'de, super::AssertionType> for AssertionTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AltTypeContent> { - let deserializer = Self { - state__: Box::new(AltTypeContentDeserializerState::Init__), - }; - let mut output = deserializer.next(helper, event)?; - output.artifact = match output.artifact { - DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, AltTypeContentDeserializerState::Init__) => - { - DeserializerArtifact::None - } - artifact => artifact, - }; - Ok(output) + ) -> DeserializerResult<'de, super::AssertionType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::AltTypeContent> { - use AltTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::AssertionType> { + use AssertionTypeDeserializerState as S; let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Annotation(values, fallback, Some(deserializer)), event) => { + (S::Annotation(Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_annotation(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + match self.handle_annotation(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::SimpleType(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_simple_type(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (S::ComplexType(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_complex_type(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; } - } - (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(Self::finish_state( - helper, state, - )?), - event: DeserializerEvent::Continue(event), + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, allow_any: false, }); } - (S::Init__, event) => match self.find_suitable(helper, event)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - }, - ( - S::Annotation(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Annotation(None); + event + } + (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), b"annotation", true, )?; - match self.handle_annotation(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::SimpleType(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"simpleType", - true, - )?; - match self.handle_simple_type(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) + match self.handle_annotation(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::ComplexType(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"complexType", - true, - )?; - match self.handle_complex_type(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } - ElementHandlerOutput::Continue { event, .. } => event, } } - (state @ S::Done__(_), event) => { - *self.state__ = state; - break (DeserializerEvent::Continue(event), false); + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); } (state, event) => { *self.state__ = state; - break (DeserializerEvent::Continue(event), false); + break (DeserializerEvent::Break(event), false); } } }; - let artifact = if matches!(&*self.state__, S::Done__(_)) { - DeserializerArtifact::Data(self.finish(helper)?) - } else { - DeserializerArtifact::Deserializer(self) - }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } Ok(DeserializerOutput { - artifact, + artifact: DeserializerArtifact::Deserializer(self), event, allow_any, }) } - fn finish(self, helper: &mut DeserializeHelper) -> Result { - Self::finish_state(helper, *self.state__) + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace( + &mut *self.state__, + AssertionTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::AssertionType { + any_attribute: self.any_attribute, + id: self.id, + test: self.test, + xpath_default_namespace: self.xpath_default_namespace, + annotation: self.annotation, + }) } } #[derive(Debug)] - pub struct KeybaseTypeDeserializer { + pub struct LocalSimpleTypeDeserializer { any_attribute: AnyAttributes, id: Option, - name: Option, - ref_: Option, - content: Option, - state__: Box, + content: Vec, + state__: Box, } #[derive(Debug)] - enum KeybaseTypeDeserializerState { + enum LocalSimpleTypeDeserializerState { Init__, Next__, - Content__(::Deserializer), + Content__(::Deserializer), Unknown__, } - impl KeybaseTypeDeserializer { + impl LocalSimpleTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { let mut any_attribute = AnyAttributes::default(); let mut id: Option = None; - let mut name: Option = None; - let mut ref_: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( @@ -16182,16 +16230,6 @@ pub mod quick_xml_deserialize { Some(b"id") ) { helper.read_attrib(&mut id, b"id", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"name") - ) { - helper.read_attrib(&mut name, b"name", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"ref") - ) { - helper.read_attrib(&mut ref_, b"ref", &attrib.value)?; } else { any_attribute.push(attrib)?; } @@ -16199,36 +16237,31 @@ pub mod quick_xml_deserialize { Ok(Self { any_attribute: any_attribute, id: id, - name: name, - ref_: ref_, - content: None, - state__: Box::new(KeybaseTypeDeserializerState::Init__), + content: Vec::new(), + state__: Box::new(LocalSimpleTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: KeybaseTypeDeserializerState, + state: LocalSimpleTypeDeserializerState, ) -> Result<(), Error> { - if let KeybaseTypeDeserializerState::Content__(deserializer) = state { + if let LocalSimpleTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content(&mut self, value: super::KeybaseTypeContent) -> Result<(), Error> { - if self.content.is_some() { - Err(ErrorKind::DuplicateContent)?; - } - self.content = Some(value); + fn store_content(&mut self, value: super::LocalSimpleTypeContent) -> Result<(), Error> { + self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::KeybaseTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::LocalSimpleTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use KeybaseTypeDeserializerState as S; + use LocalSimpleTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -16249,25 +16282,31 @@ pub mod quick_xml_deserialize { Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Content__(deserializer); - Ok(ElementHandlerOutput::from_event_end(event, allow_any)) + if self.content.len() < 2usize { + *fallback = Some(S::Content__(deserializer)); + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } else { + *self.state__ = S::Content__(deserializer); + Ok(ElementHandlerOutput::from_event_end(event, allow_any)) + } } } } } - impl<'de> Deserializer<'de, super::KeybaseType> for KeybaseTypeDeserializer { + impl<'de> Deserializer<'de, super::LocalSimpleType> for LocalSimpleTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::KeybaseType> { + ) -> DeserializerResult<'de, super::LocalSimpleType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::KeybaseType> { - use KeybaseTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::LocalSimpleType> { + use LocalSimpleTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -16292,8 +16331,9 @@ pub mod quick_xml_deserialize { } (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); - let output = - ::init(helper, event)?; + let output = ::init( + helper, event, + )?; match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) @@ -16313,205 +16353,336 @@ pub mod quick_xml_deserialize { allow_any, }) } - fn finish(mut self, helper: &mut DeserializeHelper) -> Result { - let state = replace(&mut *self.state__, KeybaseTypeDeserializerState::Unknown__); + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + LocalSimpleTypeDeserializerState::Unknown__, + ); self.finish_state(helper, state)?; - Ok(super::KeybaseType { + Ok(super::LocalSimpleType { any_attribute: self.any_attribute, id: self.id, - name: self.name, - ref_: self.ref_, - content: self.content, + content: helper.finish_vec(1usize, Some(3usize), self.content)?, }) } } #[derive(Debug)] - pub struct KeybaseTypeContentDeserializer { - annotation: Option, - selector: Option, - field: Vec, - state__: Box, + pub struct LocalSimpleTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - enum KeybaseTypeContentDeserializerState { + pub enum LocalSimpleTypeContentDeserializerState { Init__, - Annotation(Option<::Deserializer>), - Selector(Option<::Deserializer>), - Field(Option<::Deserializer>), - Done__, + Restriction( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + List( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Union( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Annotation( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::LocalSimpleTypeContent), Unknown__, } - impl KeybaseTypeContentDeserializer { - fn finish_state( + impl LocalSimpleTypeContentDeserializer { + fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, - state: KeybaseTypeContentDeserializerState, - ) -> Result<(), Error> { - use KeybaseTypeContentDeserializerState as S; - match state { - S::Annotation(Some(deserializer)) => { - self.store_annotation(deserializer.finish(helper)?)? + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"restriction") + ) { + let output = + ::init(helper, event)?; + return self.handle_restriction(helper, Default::default(), None, output); } - S::Selector(Some(deserializer)) => { - self.store_selector(deserializer.finish(helper)?)? + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"list") + ) { + let output = ::init(helper, event)?; + return self.handle_list(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"union") + ) { + let output = + ::init(helper, event)?; + return self.handle_union_(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"annotation") + ) { + let output = + ::init(helper, event)?; + return self.handle_annotation(helper, Default::default(), None, output); } - S::Field(Some(deserializer)) => self.store_field(deserializer.finish(helper)?)?, - _ => (), } - Ok(()) + *self.state__ = LocalSimpleTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) } - fn store_annotation(&mut self, value: super::AnnotationElementType) -> Result<(), Error> { - if self.annotation.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"annotation", - )))?; + fn finish_state( + helper: &mut DeserializeHelper, + state: LocalSimpleTypeContentDeserializerState, + ) -> Result { + use LocalSimpleTypeContentDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Restriction(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_restriction(&mut values, value)?; + } + Ok(super::LocalSimpleTypeContent::Restriction( + helper.finish_element("restriction", values)?, + )) + } + S::List(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_list(&mut values, value)?; + } + Ok(super::LocalSimpleTypeContent::List( + helper.finish_element("list", values)?, + )) + } + S::Union(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_union_(&mut values, value)?; + } + Ok(super::LocalSimpleTypeContent::Union( + helper.finish_element("union", values)?, + )) + } + S::Annotation(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_annotation(&mut values, value)?; + } + Ok(super::LocalSimpleTypeContent::Annotation( + helper.finish_element("annotation", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), } - self.annotation = Some(value); - Ok(()) } - fn store_selector(&mut self, value: super::FieldElementType) -> Result<(), Error> { - if self.selector.is_some() { + fn store_restriction( + values: &mut Option, + value: super::RestrictionElementType, + ) -> Result<(), Error> { + if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"selector", + b"restriction", )))?; } - self.selector = Some(value); + *values = Some(value); Ok(()) } - fn store_field(&mut self, value: super::FieldElementType) -> Result<(), Error> { - self.field.push(value); + fn store_list( + values: &mut Option, + value: super::ListElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"list")))?; + } + *values = Some(value); Ok(()) } - fn handle_annotation<'de>( + fn store_union_( + values: &mut Option, + value: super::UnionElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"union", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_annotation( + values: &mut Option, + value: super::AnnotationElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"annotation", + )))?; + } + *values = Some(value); + Ok(()) + } + fn handle_restriction<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::AnnotationElementType>, - fallback: &mut Option, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::RestrictionElementType>, ) -> Result, Error> { - use KeybaseTypeContentDeserializerState as S; + use LocalSimpleTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - *self.state__ = S::Selector(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_restriction(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_annotation(data)?; - *self.state__ = S::Selector(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_restriction(&mut values, data)?; + let data = Self::finish_state(helper, S::Restriction(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Annotation(Some(deserializer))); - *self.state__ = S::Selector(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::Restriction(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_selector<'de>( + fn handle_list<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::FieldElementType>, - fallback: &mut Option, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ListElementType>, ) -> Result, Error> { - use KeybaseTypeContentDeserializerState as S; + use LocalSimpleTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - fallback.get_or_insert(S::Selector(None)); - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } else { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_list(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_selector(data)?; - *self.state__ = S::Field(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_list(&mut values, data)?; + let data = Self::finish_state(helper, S::List(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Selector(Some(deserializer))); - *self.state__ = S::Field(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::List(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_field<'de>( + fn handle_union_<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::FieldElementType>, - fallback: &mut Option, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::UnionElementType>, ) -> Result, Error> { - use KeybaseTypeContentDeserializerState as S; + use LocalSimpleTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_union_(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_union_(&mut values, data)?; + let data = Self::finish_state(helper, S::Union(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } - if self.field.len() < 1usize { - fallback.get_or_insert(S::Field(None)); - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } else { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Union(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + } + fn handle_annotation<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnnotationElementType>, + ) -> Result, Error> { + use LocalSimpleTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_annotation(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_field(data)?; - *self.state__ = S::Field(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + Self::store_annotation(&mut values, data)?; + let data = Self::finish_state(helper, S::Annotation(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Field(Some(deserializer))); - *self.state__ = S::Field(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + *self.state__ = S::Annotation(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::KeybaseTypeContent> for KeybaseTypeContentDeserializer { + impl<'de> Deserializer<'de, super::LocalSimpleTypeContent> for LocalSimpleTypeContentDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::KeybaseTypeContent> { + ) -> DeserializerResult<'de, super::LocalSimpleTypeContent> { let deserializer = Self { - annotation: None, - selector: None, - field: Vec::new(), - state__: Box::new(KeybaseTypeContentDeserializerState::Init__), + state__: Box::new(LocalSimpleTypeContentDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, KeybaseTypeContentDeserializerState::Init__) => + if matches!(&*x.state__, LocalSimpleTypeContentDeserializerState::Init__) => { DeserializerArtifact::None } @@ -16523,179 +16694,185 @@ pub mod quick_xml_deserialize { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::KeybaseTypeContent> { - use KeybaseTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::LocalSimpleTypeContent> { + use LocalSimpleTypeContentDeserializerState as S; let mut event = event; - let mut fallback = None; - let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Annotation(Some(deserializer)), event) => { + (S::Restriction(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_annotation(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_restriction(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Selector(Some(deserializer)), event) => { + (S::List(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_selector(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_list(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Field(Some(deserializer)), event) => { + (S::Union(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_field(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_union_(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (_, event @ Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; + (S::Annotation(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_annotation(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, } + } + (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { - artifact: DeserializerArtifact::Data(self.finish(helper)?), + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), event: DeserializerEvent::Continue(event), allow_any: false, }); } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Annotation(None); - event - } - (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => { + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Restriction(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"annotation", + b"restriction", true, )?; - match self.handle_annotation(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_restriction(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Selector(None), event @ (Event::Start(_) | Event::Empty(_))) => { + ( + S::List(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"selector", + b"list", true, )?; - match self.handle_selector(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_list(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Field(None), event @ (Event::Start(_) | Event::Empty(_))) => { + ( + S::Union(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"field", + b"union", true, )?; - match self.handle_field(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event + match self.handle_union_(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Annotation(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"annotation", + true, + )?; + match self.handle_annotation(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); } (state, event) => { *self.state__ = state; - break (DeserializerEvent::Break(event), false); + break (DeserializerEvent::Continue(event), false); } } }; - if let Some(fallback) = fallback { - *self.state__ = fallback; - } + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + artifact, event, allow_any, }) } fn finish( - mut self, + self, helper: &mut DeserializeHelper, - ) -> Result { - let state = replace( - &mut *self.state__, - KeybaseTypeContentDeserializerState::Unknown__, - ); - self.finish_state(helper, state)?; - Ok(super::KeybaseTypeContent { - annotation: self.annotation, - selector: helper.finish_element("selector", self.selector)?, - field: helper.finish_vec(1usize, None, self.field)?, - }) + ) -> Result { + Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct KeyrefElementTypeDeserializer { + pub struct LocalComplexTypeDeserializer { any_attribute: AnyAttributes, id: Option, - name: Option, - ref_: Option, - refer: Option, - content: Option, - state__: Box, + mixed: Option, + default_attributes_apply: bool, + content: Vec, + state__: Box, } #[derive(Debug)] - enum KeyrefElementTypeDeserializerState { + enum LocalComplexTypeDeserializerState { Init__, Next__, - Content__(::Deserializer), + Content__(::Deserializer), Unknown__, } - impl KeyrefElementTypeDeserializer { + impl LocalComplexTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { let mut any_attribute = AnyAttributes::default(); let mut id: Option = None; - let mut name: Option = None; - let mut ref_: Option = None; - let mut refer: Option = None; + let mut mixed: Option = None; + let mut default_attributes_apply: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( @@ -16705,19 +16882,18 @@ pub mod quick_xml_deserialize { helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"name") - ) { - helper.read_attrib(&mut name, b"name", &attrib.value)?; - } else if matches!( - helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"ref") + Some(b"mixed") ) { - helper.read_attrib(&mut ref_, b"ref", &attrib.value)?; + helper.read_attrib(&mut mixed, b"mixed", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"refer") + Some(b"defaultAttributesApply") ) { - helper.read_attrib(&mut refer, b"refer", &attrib.value)?; + helper.read_attrib( + &mut default_attributes_apply, + b"defaultAttributesApply", + &attrib.value, + )?; } else { any_attribute.push(attrib)?; } @@ -16725,37 +16901,34 @@ pub mod quick_xml_deserialize { Ok(Self { any_attribute: any_attribute, id: id, - name: name, - ref_: ref_, - refer: refer, - content: None, - state__: Box::new(KeyrefElementTypeDeserializerState::Init__), + mixed: mixed, + default_attributes_apply: default_attributes_apply + .unwrap_or_else(super::LocalComplexType::default_default_attributes_apply), + content: Vec::new(), + state__: Box::new(LocalComplexTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: KeyrefElementTypeDeserializerState, + state: LocalComplexTypeDeserializerState, ) -> Result<(), Error> { - if let KeyrefElementTypeDeserializerState::Content__(deserializer) = state { + if let LocalComplexTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content(&mut self, value: super::KeyrefElementTypeContent) -> Result<(), Error> { - if self.content.is_some() { - Err(ErrorKind::DuplicateContent)?; - } - self.content = Some(value); + fn store_content(&mut self, value: super::LocalComplexTypeContent) -> Result<(), Error> { + self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::KeyrefElementTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::LocalComplexTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use KeyrefElementTypeDeserializerState as S; + use LocalComplexTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -16776,25 +16949,26 @@ pub mod quick_xml_deserialize { Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Content__(deserializer); - Ok(ElementHandlerOutput::from_event_end(event, allow_any)) + *fallback = Some(S::Content__(deserializer)); + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::KeyrefElementType> for KeyrefElementTypeDeserializer { + impl<'de> Deserializer<'de, super::LocalComplexType> for LocalComplexTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::KeyrefElementType> { + ) -> DeserializerResult<'de, super::LocalComplexType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::KeyrefElementType> { - use KeyrefElementTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::LocalComplexType> { + use LocalComplexTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -16819,7 +16993,7 @@ pub mod quick_xml_deserialize { } (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); - let output = ::init( + let output = ::init( helper, event, )?; match self.handle_content(helper, output, &mut fallback)? { @@ -16844,175 +17018,4371 @@ pub mod quick_xml_deserialize { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - KeyrefElementTypeDeserializerState::Unknown__, + LocalComplexTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::KeyrefElementType { + Ok(super::LocalComplexType { any_attribute: self.any_attribute, id: self.id, - name: self.name, - ref_: self.ref_, - refer: self.refer, - content: self.content, + mixed: self.mixed, + default_attributes_apply: self.default_attributes_apply, + content: helper.finish_vec(0usize, None, self.content)?, }) } } #[derive(Debug)] - pub struct KeyrefElementTypeContentDeserializer { - annotation: Option, - selector: Option, - field: Vec, - state__: Box, + pub struct LocalComplexTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - enum KeyrefElementTypeContentDeserializerState { + pub enum LocalComplexTypeContentDeserializerState { Init__, - Annotation(Option<::Deserializer>), - Selector(Option<::Deserializer>), - Field(Option<::Deserializer>), - Done__, + SimpleContent( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + ComplexContent( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + OpenContent( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Group( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + All( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Choice( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Sequence( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Attribute( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + AttributeGroup( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + AnyAttribute( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Assert( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Annotation( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::LocalComplexTypeContent), Unknown__, } - impl KeyrefElementTypeContentDeserializer { - fn finish_state( + impl LocalComplexTypeContentDeserializer { + fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, - state: KeyrefElementTypeContentDeserializerState, - ) -> Result<(), Error> { - use KeyrefElementTypeContentDeserializerState as S; - match state { - S::Annotation(Some(deserializer)) => { - self.store_annotation(deserializer.finish(helper)?)? + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"simpleContent") + ) { + let output = + ::init(helper, event)?; + return self.handle_simple_content(helper, Default::default(), None, output); } - S::Selector(Some(deserializer)) => { - self.store_selector(deserializer.finish(helper)?)? + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"complexContent") + ) { + let output = ::init( + helper, event, + )?; + return self.handle_complex_content(helper, Default::default(), None, output); } - S::Field(Some(deserializer)) => self.store_field(deserializer.finish(helper)?)?, - _ => (), - } - Ok(()) - } - fn store_annotation(&mut self, value: super::AnnotationElementType) -> Result<(), Error> { - if self.annotation.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"annotation", - )))?; - } - self.annotation = Some(value); - Ok(()) - } - fn store_selector(&mut self, value: super::FieldElementType) -> Result<(), Error> { - if self.selector.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"selector", - )))?; - } - self.selector = Some(value); - Ok(()) - } - fn store_field(&mut self, value: super::FieldElementType) -> Result<(), Error> { - self.field.push(value); - Ok(()) - } - fn handle_annotation<'de>( - &mut self, - helper: &mut DeserializeHelper, + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"openContent") + ) { + let output = + ::init(helper, event)?; + return self.handle_open_content(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"group") + ) { + let output = ::init(helper, event)?; + return self.handle_group(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"all") + ) { + let output = + ::init(helper, event)?; + return self.handle_all(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"choice") + ) { + let output = + ::init(helper, event)?; + return self.handle_choice(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"sequence") + ) { + let output = + ::init(helper, event)?; + return self.handle_sequence(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"attribute") + ) { + let output = ::init(helper, event)?; + return self.handle_attribute(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"attributeGroup") + ) { + let output = + ::init(helper, event)?; + return self.handle_attribute_group(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"anyAttribute") + ) { + let output = + ::init(helper, event)?; + return self.handle_any_attribute(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"assert") + ) { + let output = ::init(helper, event)?; + return self.handle_assert(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"annotation") + ) { + let output = + ::init(helper, event)?; + return self.handle_annotation(helper, Default::default(), None, output); + } + } + *self.state__ = LocalComplexTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: LocalComplexTypeContentDeserializerState, + ) -> Result { + use LocalComplexTypeContentDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::SimpleContent(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_simple_content(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::SimpleContent( + helper.finish_element("simpleContent", values)?, + )) + } + S::ComplexContent(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_complex_content(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::ComplexContent( + helper.finish_element("complexContent", values)?, + )) + } + S::OpenContent(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_open_content(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::OpenContent( + helper.finish_element("openContent", values)?, + )) + } + S::Group(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_group(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::Group( + helper.finish_element("group", values)?, + )) + } + S::All(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_all(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::All( + helper.finish_element("all", values)?, + )) + } + S::Choice(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_choice(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::Choice( + helper.finish_element("choice", values)?, + )) + } + S::Sequence(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_sequence(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::Sequence( + helper.finish_element("sequence", values)?, + )) + } + S::Attribute(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_attribute(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::Attribute( + helper.finish_element("attribute", values)?, + )) + } + S::AttributeGroup(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_attribute_group(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::AttributeGroup( + helper.finish_element("attributeGroup", values)?, + )) + } + S::AnyAttribute(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_any_attribute(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::AnyAttribute( + helper.finish_element("anyAttribute", values)?, + )) + } + S::Assert(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_assert(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::Assert( + helper.finish_element("assert", values)?, + )) + } + S::Annotation(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_annotation(&mut values, value)?; + } + Ok(super::LocalComplexTypeContent::Annotation( + helper.finish_element("annotation", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_simple_content( + values: &mut Option, + value: super::SimpleContentElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"simpleContent", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_complex_content( + values: &mut Option, + value: super::ComplexContentElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"complexContent", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_open_content( + values: &mut Option, + value: super::OpenContentElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"openContent", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_group( + values: &mut Option, + value: super::RealGroupType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"group", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_all( + values: &mut Option, + value: super::ExplicitGroupType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"all")))?; + } + *values = Some(value); + Ok(()) + } + fn store_choice( + values: &mut Option, + value: super::ExplicitGroupType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"choice", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_sequence( + values: &mut Option, + value: super::ExplicitGroupType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"sequence", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_attribute( + values: &mut Option, + value: super::AttributeType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"attribute", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_attribute_group( + values: &mut Option, + value: super::AttributeGroupRefType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"attributeGroup", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_any_attribute( + values: &mut Option, + value: super::AnyAttributeElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"anyAttribute", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_assert( + values: &mut Option, + value: super::AssertionType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"assert", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_annotation( + values: &mut Option, + value: super::AnnotationElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"annotation", + )))?; + } + *values = Some(value); + Ok(()) + } + fn handle_simple_content<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::SimpleContentElementType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_simple_content(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_simple_content(&mut values, data)?; + let data = Self::finish_state(helper, S::SimpleContent(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::SimpleContent(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_complex_content<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ComplexContentElementType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_complex_content(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_complex_content(&mut values, data)?; + let data = Self::finish_state(helper, S::ComplexContent(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::ComplexContent(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_open_content<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::OpenContentElementType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_open_content(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_open_content(&mut values, data)?; + let data = Self::finish_state(helper, S::OpenContent(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::OpenContent(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_group<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::RealGroupType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_group(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_group(&mut values, data)?; + let data = Self::finish_state(helper, S::Group(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Group(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_all<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_all(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_all(&mut values, data)?; + let data = Self::finish_state(helper, S::All(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::All(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_choice<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_choice(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_choice(&mut values, data)?; + let data = Self::finish_state(helper, S::Choice(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Choice(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_sequence<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_sequence(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_sequence(&mut values, data)?; + let data = Self::finish_state(helper, S::Sequence(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Sequence(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_attribute<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AttributeType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_attribute(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_attribute(&mut values, data)?; + let data = Self::finish_state(helper, S::Attribute(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Attribute(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_attribute_group<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AttributeGroupRefType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_attribute_group(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_attribute_group(&mut values, data)?; + let data = Self::finish_state(helper, S::AttributeGroup(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::AttributeGroup(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_any_attribute<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnyAttributeElementType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_any_attribute(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_any_attribute(&mut values, data)?; + let data = Self::finish_state(helper, S::AnyAttribute(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::AnyAttribute(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_assert<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AssertionType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_assert(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_assert(&mut values, data)?; + let data = Self::finish_state(helper, S::Assert(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Assert(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_annotation<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnnotationElementType>, + ) -> Result, Error> { + use LocalComplexTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_annotation(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_annotation(&mut values, data)?; + let data = Self::finish_state(helper, S::Annotation(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Annotation(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::LocalComplexTypeContent> + for LocalComplexTypeContentDeserializer + { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LocalComplexTypeContent> { + let deserializer = Self { + state__: Box::new(LocalComplexTypeContentDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!( + &*x.state__, + LocalComplexTypeContentDeserializerState::Init__ + ) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::LocalComplexTypeContent> { + use LocalComplexTypeContentDeserializerState as S; + let mut event = event; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::SimpleContent(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_simple_content(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::ComplexContent(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_complex_content(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::OpenContent(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_open_content(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Group(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_group(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::All(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_all(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Choice(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_choice(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Sequence(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_sequence(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Attribute(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_attribute(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::AttributeGroup(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_attribute_group(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::AnyAttribute(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_any_attribute(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Assert(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_assert(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Annotation(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_annotation(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state, event @ Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::SimpleContent(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"simpleContent", + true, + )?; + match self.handle_simple_content(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::ComplexContent(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"complexContent", + true, + )?; + match self.handle_complex_content(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::OpenContent(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"openContent", + true, + )?; + match self.handle_open_content(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Group(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"group", + true, + )?; + match self.handle_group(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::All(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"all", + true, + )?; + match self.handle_all(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Choice(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"choice", + true, + )?; + match self.handle_choice(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Sequence(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"sequence", + true, + )?; + match self.handle_sequence(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Attribute(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"attribute", + true, + )?; + match self.handle_attribute(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::AttributeGroup(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"attributeGroup", + true, + )?; + match self.handle_attribute_group(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::AnyAttribute(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"anyAttribute", + true, + )?; + match self.handle_any_attribute(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Assert(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"assert", + true, + )?; + match self.handle_assert(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Annotation(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"annotation", + true, + )?; + match self.handle_annotation(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + } + }; + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish( + self, + helper: &mut DeserializeHelper, + ) -> Result { + Self::finish_state(helper, *self.state__) + } + } + #[derive(Debug)] + pub struct AltTypeDeserializer { + any_attribute: AnyAttributes, + id: Option, + test: Option, + type_: Option, + xpath_default_namespace: Option, + content: Vec, + state__: Box, + } + #[derive(Debug)] + enum AltTypeDeserializerState { + Init__, + Next__, + Content__(::Deserializer), + Unknown__, + } + impl AltTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut any_attribute = AnyAttributes::default(); + let mut id: Option = None; + let mut test: Option = None; + let mut type_: Option = None; + let mut xpath_default_namespace: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"test") + ) { + helper.read_attrib(&mut test, b"test", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"type") + ) { + helper.read_attrib(&mut type_, b"type", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"xpathDefaultNamespace") + ) { + helper.read_attrib( + &mut xpath_default_namespace, + b"xpathDefaultNamespace", + &attrib.value, + )?; + } else { + any_attribute.push(attrib)?; + } + } + Ok(Self { + any_attribute: any_attribute, + id: id, + test: test, + type_: type_, + xpath_default_namespace: xpath_default_namespace, + content: Vec::new(), + state__: Box::new(AltTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: AltTypeDeserializerState, + ) -> Result<(), Error> { + if let AltTypeDeserializerState::Content__(deserializer) = state { + self.store_content(deserializer.finish(helper)?)?; + } + Ok(()) + } + fn store_content(&mut self, value: super::AltTypeContent) -> Result<(), Error> { + self.content.push(value); + Ok(()) + } + fn handle_content<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::AltTypeContent>, + fallback: &mut Option, + ) -> Result, Error> { + use AltTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = fallback.take().unwrap_or(S::Next__); + return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_content(data)?; + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + if self.content.len() < 1usize { + *fallback = Some(S::Content__(deserializer)); + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } else { + *self.state__ = S::Content__(deserializer); + Ok(ElementHandlerOutput::from_event_end(event, allow_any)) + } + } + } + } + } + impl<'de> Deserializer<'de, super::AltType> for AltTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AltType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AltType> { + use AltTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Content__(deserializer), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (_, Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (state @ (S::Init__ | S::Next__), event) => { + fallback.get_or_insert(state); + let output = + ::init(helper, event)?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + let artifact = DeserializerArtifact::Deserializer(self); + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, AltTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::AltType { + any_attribute: self.any_attribute, + id: self.id, + test: self.test, + type_: self.type_, + xpath_default_namespace: self.xpath_default_namespace, + content: helper.finish_vec(0usize, Some(2usize), self.content)?, + }) + } + } + #[derive(Debug)] + pub struct AltTypeContentDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum AltTypeContentDeserializerState { + Init__, + Annotation( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + SimpleType( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + ComplexType( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::AltTypeContent), + Unknown__, + } + impl AltTypeContentDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"annotation") + ) { + let output = + ::init(helper, event)?; + return self.handle_annotation(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"simpleType") + ) { + let output = ::init(helper, event)?; + return self.handle_simple_type(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"complexType") + ) { + let output = + ::init(helper, event)?; + return self.handle_complex_type(helper, Default::default(), None, output); + } + } + *self.state__ = AltTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: AltTypeContentDeserializerState, + ) -> Result { + use AltTypeContentDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::Annotation(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_annotation(&mut values, value)?; + } + Ok(super::AltTypeContent::Annotation( + helper.finish_element("annotation", values)?, + )) + } + S::SimpleType(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_simple_type(&mut values, value)?; + } + Ok(super::AltTypeContent::SimpleType( + helper.finish_element("simpleType", values)?, + )) + } + S::ComplexType(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_complex_type(&mut values, value)?; + } + Ok(super::AltTypeContent::ComplexType( + helper.finish_element("complexType", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_annotation( + values: &mut Option, + value: super::AnnotationElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"annotation", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_simple_type( + values: &mut Option, + value: super::LocalSimpleType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"simpleType", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_complex_type( + values: &mut Option, + value: super::LocalComplexType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"complexType", + )))?; + } + *values = Some(value); + Ok(()) + } + fn handle_annotation<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnnotationElementType>, + ) -> Result, Error> { + use AltTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_annotation(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_annotation(&mut values, data)?; + let data = Self::finish_state(helper, S::Annotation(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Annotation(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_simple_type<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LocalSimpleType>, + ) -> Result, Error> { + use AltTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_simple_type(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_simple_type(&mut values, data)?; + let data = Self::finish_state(helper, S::SimpleType(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::SimpleType(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_complex_type<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LocalComplexType>, + ) -> Result, Error> { + use AltTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_complex_type(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_complex_type(&mut values, data)?; + let data = Self::finish_state(helper, S::ComplexType(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::ComplexType(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::AltTypeContent> for AltTypeContentDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AltTypeContent> { + let deserializer = Self { + state__: Box::new(AltTypeContentDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, AltTypeContentDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AltTypeContent> { + use AltTypeContentDeserializerState as S; + let mut event = event; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Annotation(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_annotation(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::SimpleType(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_simple_type(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::ComplexType(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_complex_type(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state, event @ Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::Annotation(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"annotation", + true, + )?; + match self.handle_annotation(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::SimpleType(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"simpleType", + true, + )?; + match self.handle_simple_type(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::ComplexType(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"complexType", + true, + )?; + match self.handle_complex_type(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + } + }; + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + Self::finish_state(helper, *self.state__) + } + } + #[derive(Debug)] + pub struct KeybaseTypeDeserializer { + any_attribute: AnyAttributes, + id: Option, + name: Option, + ref_: Option, + content: Option, + state__: Box, + } + #[derive(Debug)] + enum KeybaseTypeDeserializerState { + Init__, + Next__, + Content__(::Deserializer), + Unknown__, + } + impl KeybaseTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut any_attribute = AnyAttributes::default(); + let mut id: Option = None; + let mut name: Option = None; + let mut ref_: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"ref") + ) { + helper.read_attrib(&mut ref_, b"ref", &attrib.value)?; + } else { + any_attribute.push(attrib)?; + } + } + Ok(Self { + any_attribute: any_attribute, + id: id, + name: name, + ref_: ref_, + content: None, + state__: Box::new(KeybaseTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: KeybaseTypeDeserializerState, + ) -> Result<(), Error> { + if let KeybaseTypeDeserializerState::Content__(deserializer) = state { + self.store_content(deserializer.finish(helper)?)?; + } + Ok(()) + } + fn store_content(&mut self, value: super::KeybaseTypeContent) -> Result<(), Error> { + if self.content.is_some() { + Err(ErrorKind::DuplicateContent)?; + } + self.content = Some(value); + Ok(()) + } + fn handle_content<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::KeybaseTypeContent>, + fallback: &mut Option, + ) -> Result, Error> { + use KeybaseTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = fallback.take().unwrap_or(S::Next__); + return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_content(data)?; + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Content__(deserializer); + Ok(ElementHandlerOutput::from_event_end(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::KeybaseType> for KeybaseTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::KeybaseType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::KeybaseType> { + use KeybaseTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Content__(deserializer), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (_, Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (state @ (S::Init__ | S::Next__), event) => { + fallback.get_or_insert(state); + let output = + ::init(helper, event)?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + let artifact = DeserializerArtifact::Deserializer(self); + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + let state = replace(&mut *self.state__, KeybaseTypeDeserializerState::Unknown__); + self.finish_state(helper, state)?; + Ok(super::KeybaseType { + any_attribute: self.any_attribute, + id: self.id, + name: self.name, + ref_: self.ref_, + content: self.content, + }) + } + } + #[derive(Debug)] + pub struct KeybaseTypeContentDeserializer { + annotation: Option, + selector: Option, + field: Vec, + state__: Box, + } + #[derive(Debug)] + enum KeybaseTypeContentDeserializerState { + Init__, + Annotation(Option<::Deserializer>), + Selector(Option<::Deserializer>), + Field(Option<::Deserializer>), + Done__, + Unknown__, + } + impl KeybaseTypeContentDeserializer { + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: KeybaseTypeContentDeserializerState, + ) -> Result<(), Error> { + use KeybaseTypeContentDeserializerState as S; + match state { + S::Annotation(Some(deserializer)) => { + self.store_annotation(deserializer.finish(helper)?)? + } + S::Selector(Some(deserializer)) => { + self.store_selector(deserializer.finish(helper)?)? + } + S::Field(Some(deserializer)) => self.store_field(deserializer.finish(helper)?)?, + _ => (), + } + Ok(()) + } + fn store_annotation(&mut self, value: super::AnnotationElementType) -> Result<(), Error> { + if self.annotation.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"annotation", + )))?; + } + self.annotation = Some(value); + Ok(()) + } + fn store_selector(&mut self, value: super::FieldElementType) -> Result<(), Error> { + if self.selector.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"selector", + )))?; + } + self.selector = Some(value); + Ok(()) + } + fn store_field(&mut self, value: super::FieldElementType) -> Result<(), Error> { + self.field.push(value); + Ok(()) + } + fn handle_annotation<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::AnnotationElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use KeybaseTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Selector(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_annotation(data)?; + *self.state__ = S::Selector(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Annotation(Some(deserializer))); + *self.state__ = S::Selector(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_selector<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::FieldElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use KeybaseTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + fallback.get_or_insert(S::Selector(None)); + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } else { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_selector(data)?; + *self.state__ = S::Field(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Selector(Some(deserializer))); + *self.state__ = S::Field(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_field<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::FieldElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use KeybaseTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + if self.field.len() < 1usize { + fallback.get_or_insert(S::Field(None)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } else { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_field(data)?; + *self.state__ = S::Field(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Field(Some(deserializer))); + *self.state__ = S::Field(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::KeybaseTypeContent> for KeybaseTypeContentDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::KeybaseTypeContent> { + let deserializer = Self { + annotation: None, + selector: None, + field: Vec::new(), + state__: Box::new(KeybaseTypeContentDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, KeybaseTypeContentDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::KeybaseTypeContent> { + use KeybaseTypeContentDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Annotation(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_annotation(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Selector(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_selector(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Field(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_field(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, event @ Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Annotation(None); + event + } + (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"annotation", + true, + )?; + match self.handle_annotation(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Selector(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"selector", + true, + )?; + match self.handle_selector(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Field(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"field", + true, + )?; + match self.handle_field(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + KeybaseTypeContentDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::KeybaseTypeContent { + annotation: self.annotation, + selector: helper.finish_element("selector", self.selector)?, + field: helper.finish_vec(1usize, None, self.field)?, + }) + } + } + #[derive(Debug)] + pub struct KeyrefElementTypeDeserializer { + any_attribute: AnyAttributes, + id: Option, + name: Option, + ref_: Option, + refer: Option, + content: Option, + state__: Box, + } + #[derive(Debug)] + enum KeyrefElementTypeDeserializerState { + Init__, + Next__, + Content__(::Deserializer), + Unknown__, + } + impl KeyrefElementTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut any_attribute = AnyAttributes::default(); + let mut id: Option = None; + let mut name: Option = None; + let mut ref_: Option = None; + let mut refer: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"name") + ) { + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"ref") + ) { + helper.read_attrib(&mut ref_, b"ref", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"refer") + ) { + helper.read_attrib(&mut refer, b"refer", &attrib.value)?; + } else { + any_attribute.push(attrib)?; + } + } + Ok(Self { + any_attribute: any_attribute, + id: id, + name: name, + ref_: ref_, + refer: refer, + content: None, + state__: Box::new(KeyrefElementTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: KeyrefElementTypeDeserializerState, + ) -> Result<(), Error> { + if let KeyrefElementTypeDeserializerState::Content__(deserializer) = state { + self.store_content(deserializer.finish(helper)?)?; + } + Ok(()) + } + fn store_content(&mut self, value: super::KeyrefElementTypeContent) -> Result<(), Error> { + if self.content.is_some() { + Err(ErrorKind::DuplicateContent)?; + } + self.content = Some(value); + Ok(()) + } + fn handle_content<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::KeyrefElementTypeContent>, + fallback: &mut Option, + ) -> Result, Error> { + use KeyrefElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = fallback.take().unwrap_or(S::Next__); + return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_content(data)?; + *self.state__ = S::Next__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Content__(deserializer); + Ok(ElementHandlerOutput::from_event_end(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::KeyrefElementType> for KeyrefElementTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::KeyrefElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::KeyrefElementType> { + use KeyrefElementTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Content__(deserializer), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (_, Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (state @ (S::Init__ | S::Next__), event) => { + fallback.get_or_insert(state); + let output = ::init( + helper, event, + )?; + match self.handle_content(helper, output, &mut fallback)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + let artifact = DeserializerArtifact::Deserializer(self); + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + KeyrefElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::KeyrefElementType { + any_attribute: self.any_attribute, + id: self.id, + name: self.name, + ref_: self.ref_, + refer: self.refer, + content: self.content, + }) + } + } + #[derive(Debug)] + pub struct KeyrefElementTypeContentDeserializer { + annotation: Option, + selector: Option, + field: Vec, + state__: Box, + } + #[derive(Debug)] + enum KeyrefElementTypeContentDeserializerState { + Init__, + Annotation(Option<::Deserializer>), + Selector(Option<::Deserializer>), + Field(Option<::Deserializer>), + Done__, + Unknown__, + } + impl KeyrefElementTypeContentDeserializer { + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: KeyrefElementTypeContentDeserializerState, + ) -> Result<(), Error> { + use KeyrefElementTypeContentDeserializerState as S; + match state { + S::Annotation(Some(deserializer)) => { + self.store_annotation(deserializer.finish(helper)?)? + } + S::Selector(Some(deserializer)) => { + self.store_selector(deserializer.finish(helper)?)? + } + S::Field(Some(deserializer)) => self.store_field(deserializer.finish(helper)?)?, + _ => (), + } + Ok(()) + } + fn store_annotation(&mut self, value: super::AnnotationElementType) -> Result<(), Error> { + if self.annotation.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"annotation", + )))?; + } + self.annotation = Some(value); + Ok(()) + } + fn store_selector(&mut self, value: super::FieldElementType) -> Result<(), Error> { + if self.selector.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"selector", + )))?; + } + self.selector = Some(value); + Ok(()) + } + fn store_field(&mut self, value: super::FieldElementType) -> Result<(), Error> { + self.field.push(value); + Ok(()) + } + fn handle_annotation<'de>( + &mut self, + helper: &mut DeserializeHelper, output: DeserializerOutput<'de, super::AnnotationElementType>, fallback: &mut Option, ) -> Result, Error> { - use KeyrefElementTypeContentDeserializerState as S; + use KeyrefElementTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Selector(None); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_annotation(data)?; + *self.state__ = S::Selector(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Annotation(Some(deserializer))); + *self.state__ = S::Selector(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_selector<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::FieldElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use KeyrefElementTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + fallback.get_or_insert(S::Selector(None)); + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } else { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_selector(data)?; + *self.state__ = S::Field(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Selector(Some(deserializer))); + *self.state__ = S::Field(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + fn handle_field<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::FieldElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use KeyrefElementTypeContentDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + if matches!(&fallback, Some(S::Init__)) { + return Ok(ElementHandlerOutput::break_(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + if self.field.len() < 1usize { + fallback.get_or_insert(S::Field(None)); + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } else { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_field(data)?; + *self.state__ = S::Field(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Field(Some(deserializer))); + *self.state__ = S::Field(None); + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::KeyrefElementTypeContent> + for KeyrefElementTypeContentDeserializer + { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::KeyrefElementTypeContent> { + let deserializer = Self { + annotation: None, + selector: None, + field: Vec::new(), + state__: Box::new(KeyrefElementTypeContentDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!( + &*x.state__, + KeyrefElementTypeContentDeserializerState::Init__ + ) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::KeyrefElementTypeContent> { + use KeyrefElementTypeContentDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Annotation(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_annotation(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Selector(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_selector(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Field(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_field(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, event @ Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Annotation(None); + event + } + (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"annotation", + true, + )?; + match self.handle_annotation(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Selector(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"selector", + true, + )?; + match self.handle_selector(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Field(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"field", + true, + )?; + match self.handle_field(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + KeyrefElementTypeContentDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::KeyrefElementTypeContent { + annotation: self.annotation, + selector: helper.finish_element("selector", self.selector)?, + field: helper.finish_vec(1usize, None, self.field)?, + }) + } + } + #[derive(Debug)] + pub struct FacetDeserializer { + state__: Box, + } + #[derive(Debug)] + pub enum FacetDeserializerState { + Init__, + MinExclusive( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + MinInclusive( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + MaxExclusive( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + MaxInclusive( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + TotalDigits( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + FractionDigits( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Length( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + MinLength( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + MaxLength( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Enumeration( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + WhiteSpace( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Pattern( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Assertion( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + ExplicitTimezone( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Done__(super::Facet), + Unknown__, + } + impl FacetDeserializer { + fn find_suitable<'de>( + &mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> Result, Error> { + if let Event::Start(x) | Event::Empty(x) = &event { + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"minExclusive") + ) { + let output = ::init(helper, event)?; + return self.handle_min_exclusive(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"minInclusive") + ) { + let output = ::init(helper, event)?; + return self.handle_min_inclusive(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"maxExclusive") + ) { + let output = ::init(helper, event)?; + return self.handle_max_exclusive(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"maxInclusive") + ) { + let output = ::init(helper, event)?; + return self.handle_max_inclusive(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"totalDigits") + ) { + let output = ::init(helper, event)?; + return self.handle_total_digits(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"fractionDigits") + ) { + let output = ::init(helper, event)?; + return self.handle_fraction_digits(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"length") + ) { + let output = ::init(helper, event)?; + return self.handle_length(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"minLength") + ) { + let output = ::init(helper, event)?; + return self.handle_min_length(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"maxLength") + ) { + let output = ::init(helper, event)?; + return self.handle_max_length(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"enumeration") + ) { + let output = ::init(helper, event)?; + return self.handle_enumeration(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"whiteSpace") + ) { + let output = ::init(helper, event)?; + return self.handle_white_space(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"pattern") + ) { + let output = ::init(helper, event)?; + return self.handle_pattern(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"assertion") + ) { + let output = ::init(helper, event)?; + return self.handle_assertion(helper, Default::default(), None, output); + } + if matches!( + helper.resolve_local_name(x.name(), &super::NS_XS), + Some(b"explicitTimezone") + ) { + let output = ::init(helper, event)?; + return self.handle_explicit_timezone(helper, Default::default(), None, output); + } + } + *self.state__ = FacetDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) + } + fn finish_state( + helper: &mut DeserializeHelper, + state: FacetDeserializerState, + ) -> Result { + use FacetDeserializerState as S; + match state { + S::Init__ => Err(ErrorKind::MissingContent.into()), + S::MinExclusive(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_min_exclusive(&mut values, value)?; + } + Ok(super::Facet::MinExclusive( + helper.finish_element("minExclusive", values)?, + )) + } + S::MinInclusive(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_min_inclusive(&mut values, value)?; + } + Ok(super::Facet::MinInclusive( + helper.finish_element("minInclusive", values)?, + )) + } + S::MaxExclusive(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_max_exclusive(&mut values, value)?; + } + Ok(super::Facet::MaxExclusive( + helper.finish_element("maxExclusive", values)?, + )) + } + S::MaxInclusive(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_max_inclusive(&mut values, value)?; + } + Ok(super::Facet::MaxInclusive( + helper.finish_element("maxInclusive", values)?, + )) + } + S::TotalDigits(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_total_digits(&mut values, value)?; + } + Ok(super::Facet::TotalDigits( + helper.finish_element("totalDigits", values)?, + )) + } + S::FractionDigits(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_fraction_digits(&mut values, value)?; + } + Ok(super::Facet::FractionDigits( + helper.finish_element("fractionDigits", values)?, + )) + } + S::Length(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_length(&mut values, value)?; + } + Ok(super::Facet::Length( + helper.finish_element("length", values)?, + )) + } + S::MinLength(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_min_length(&mut values, value)?; + } + Ok(super::Facet::MinLength( + helper.finish_element("minLength", values)?, + )) + } + S::MaxLength(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_max_length(&mut values, value)?; + } + Ok(super::Facet::MaxLength( + helper.finish_element("maxLength", values)?, + )) + } + S::Enumeration(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_enumeration(&mut values, value)?; + } + Ok(super::Facet::Enumeration( + helper.finish_element("enumeration", values)?, + )) + } + S::WhiteSpace(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_white_space(&mut values, value)?; + } + Ok(super::Facet::WhiteSpace( + helper.finish_element("whiteSpace", values)?, + )) + } + S::Pattern(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_pattern(&mut values, value)?; + } + Ok(super::Facet::Pattern( + helper.finish_element("pattern", values)?, + )) + } + S::Assertion(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_assertion(&mut values, value)?; + } + Ok(super::Facet::Assertion( + helper.finish_element("assertion", values)?, + )) + } + S::ExplicitTimezone(mut values, None, deserializer) => { + if let Some(deserializer) = deserializer { + let value = deserializer.finish(helper)?; + Self::store_explicit_timezone(&mut values, value)?; + } + Ok(super::Facet::ExplicitTimezone( + helper.finish_element("explicitTimezone", values)?, + )) + } + S::Done__(data) => Ok(data), + _ => unreachable!(), + } + } + fn store_min_exclusive( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"minExclusive", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_min_inclusive( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"minInclusive", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_max_exclusive( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"maxExclusive", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_max_inclusive( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"maxInclusive", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_total_digits( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"totalDigits", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_fraction_digits( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"fractionDigits", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_length( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"length", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_min_length( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"minLength", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_max_length( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"maxLength", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_enumeration( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"enumeration", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_white_space( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"whiteSpace", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_pattern( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"pattern", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_assertion( + values: &mut Option, + value: super::AssertionType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"assertion", + )))?; + } + *values = Some(value); + Ok(()) + } + fn store_explicit_timezone( + values: &mut Option, + value: super::FacetType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"explicitTimezone", + )))?; + } + *values = Some(value); + Ok(()) + } + fn handle_min_exclusive<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_min_exclusive(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_min_exclusive(&mut values, data)?; + let data = Self::finish_state(helper, S::MinExclusive(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::MinExclusive(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_min_inclusive<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_min_inclusive(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_min_inclusive(&mut values, data)?; + let data = Self::finish_state(helper, S::MinInclusive(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::MinInclusive(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_max_exclusive<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_max_exclusive(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_max_exclusive(&mut values, data)?; + let data = Self::finish_state(helper, S::MaxExclusive(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::MaxExclusive(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_max_inclusive<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_max_inclusive(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_max_inclusive(&mut values, data)?; + let data = Self::finish_state(helper, S::MaxInclusive(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::MaxInclusive(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_total_digits<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_total_digits(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_total_digits(&mut values, data)?; + let data = Self::finish_state(helper, S::TotalDigits(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::TotalDigits(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_fraction_digits<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_fraction_digits(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_fraction_digits(&mut values, data)?; + let data = Self::finish_state(helper, S::FractionDigits(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::FractionDigits(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_length<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_length(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_length(&mut values, data)?; + let data = Self::finish_state(helper, S::Length(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Length(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_min_length<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_min_length(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_min_length(&mut values, data)?; + let data = Self::finish_state(helper, S::MinLength(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::MinLength(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_max_length<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_max_length(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_max_length(&mut values, data)?; + let data = Self::finish_state(helper, S::MaxLength(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::MaxLength(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_enumeration<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_enumeration(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_enumeration(&mut values, data)?; + let data = Self::finish_state(helper, S::Enumeration(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Enumeration(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_white_space<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_white_space(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_white_space(&mut values, data)?; + let data = Self::finish_state(helper, S::WhiteSpace(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::WhiteSpace(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_pattern<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_pattern(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_pattern(&mut values, data)?; + let data = Self::finish_state(helper, S::Pattern(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Pattern(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_assertion<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AssertionType>, + ) -> Result, Error> { + use FacetDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_assertion(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_assertion(&mut values, data)?; + let data = Self::finish_state(helper, S::Assertion(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::Assertion(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + fn handle_explicit_timezone<'de>( + &mut self, + helper: &mut DeserializeHelper, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::FacetType>, + ) -> Result, Error> { + use FacetDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, - } = output; - if artifact.is_none() { - *self.state__ = S::Selector(None); - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_annotation(data)?; - *self.state__ = S::Selector(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Annotation(Some(deserializer))); - *self.state__ = S::Selector(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) + } = output; + if artifact.is_none() { + return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + } + if let Some(deserializer) = fallback { + let data = deserializer.finish(helper)?; + Self::store_explicit_timezone(&mut values, data)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + Self::store_explicit_timezone(&mut values, data)?; + let data = Self::finish_state(helper, S::ExplicitTimezone(values, None, None))?; + *self.state__ = S::Done__(data); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + *self.state__ = S::ExplicitTimezone(values, None, Some(deserializer)); + Ok(ElementHandlerOutput::break_(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::Facet> for FacetDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Facet> { + let deserializer = Self { + state__: Box::new(FacetDeserializerState::Init__), + }; + let mut output = deserializer.next(helper, event)?; + output.artifact = match output.artifact { + DeserializerArtifact::Deserializer(x) + if matches!(&*x.state__, FacetDeserializerState::Init__) => + { + DeserializerArtifact::None + } + artifact => artifact, + }; + Ok(output) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::Facet> { + use FacetDeserializerState as S; + let mut event = event; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::MinExclusive(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_min_exclusive(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::MinInclusive(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_min_inclusive(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::MaxExclusive(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_max_exclusive(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::MaxInclusive(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_max_inclusive(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::TotalDigits(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_total_digits(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::FractionDigits(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_fraction_digits(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Length(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_length(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::MinLength(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_min_length(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::MaxLength(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_max_length(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Enumeration(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_enumeration(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::WhiteSpace(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_white_space(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Pattern(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_pattern(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::Assertion(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_assertion(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (S::ExplicitTimezone(values, fallback, Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_explicit_timezone(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state, event @ Event::End(_)) => { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(Self::finish_state( + helper, state, + )?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, + ( + S::MinExclusive(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"minExclusive", + true, + )?; + match self.handle_min_exclusive(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::MinInclusive(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"minInclusive", + true, + )?; + match self.handle_min_inclusive(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::MaxExclusive(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"maxExclusive", + true, + )?; + match self.handle_max_exclusive(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::MaxInclusive(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"maxInclusive", + true, + )?; + match self.handle_max_inclusive(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::TotalDigits(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"totalDigits", + true, + )?; + match self.handle_total_digits(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::FractionDigits(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"fractionDigits", + true, + )?; + match self.handle_fraction_digits(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Length(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"length", + true, + )?; + match self.handle_length(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::MinLength(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"minLength", + true, + )?; + match self.handle_min_length(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::MaxLength(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"maxLength", + true, + )?; + match self.handle_max_length(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Enumeration(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"enumeration", + true, + )?; + match self.handle_enumeration(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::WhiteSpace(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"whiteSpace", + true, + )?; + match self.handle_white_space(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Pattern(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"pattern", + true, + )?; + match self.handle_pattern(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::Assertion(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"assertion", + true, + )?; + match self.handle_assertion(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + ( + S::ExplicitTimezone(values, fallback, None), + event @ (Event::Start(_) | Event::Empty(_)), + ) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"explicitTimezone", + true, + )?; + match self.handle_explicit_timezone(helper, values, fallback, output)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + } + } + (state @ S::Done__(_), event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Continue(event), false); + } + } + }; + let artifact = if matches!(&*self.state__, S::Done__(_)) { + DeserializerArtifact::Data(self.finish(helper)?) + } else { + DeserializerArtifact::Deserializer(self) + }; + Ok(DeserializerOutput { + artifact, + event, + allow_any, + }) + } + fn finish(self, helper: &mut DeserializeHelper) -> Result { + Self::finish_state(helper, *self.state__) + } + } + #[derive(Debug)] + pub struct RestrictionTypeDeserializer { + any_attribute: AnyAttributes, + id: Option, + base: String, + content: Vec, + state__: Box, + } + #[derive(Debug)] + enum RestrictionTypeDeserializerState { + Init__, + Next__, + Content__(::Deserializer), + Unknown__, + } + impl RestrictionTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut any_attribute = AnyAttributes::default(); + let mut id: Option = None; + let mut base: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"base") + ) { + helper.read_attrib(&mut base, b"base", &attrib.value)?; + } else { + any_attribute.push(attrib)?; } } + Ok(Self { + any_attribute: any_attribute, + id: id, + base: base.ok_or_else(|| ErrorKind::MissingAttribute("base".into()))?, + content: Vec::new(), + state__: Box::new(RestrictionTypeDeserializerState::Init__), + }) } - fn handle_selector<'de>( + fn finish_state( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::FieldElementType>, - fallback: &mut Option, - ) -> Result, Error> { - use KeyrefElementTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - fallback.get_or_insert(S::Selector(None)); - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } else { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - self.store_selector(data)?; - *self.state__ = S::Field(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Selector(Some(deserializer))); - *self.state__ = S::Field(None); - Ok(ElementHandlerOutput::from_event(event, allow_any)) - } + state: RestrictionTypeDeserializerState, + ) -> Result<(), Error> { + if let RestrictionTypeDeserializerState::Content__(deserializer) = state { + self.store_content(deserializer.finish(helper)?)?; } + Ok(()) } - fn handle_field<'de>( + fn store_content(&mut self, value: super::RestrictionTypeContent) -> Result<(), Error> { + self.content.push(value); + Ok(()) + } + fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::FieldElementType>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::RestrictionTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use KeyrefElementTypeContentDeserializerState as S; + use RestrictionTypeDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - if matches!(&fallback, Some(S::Init__)) { - return Ok(ElementHandlerOutput::break_(event, allow_any)); - } - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } - if self.field.len() < 1usize { - fallback.get_or_insert(S::Field(None)); - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } else { - *self.state__ = S::Done__; - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } + *self.state__ = fallback.take().unwrap_or(S::Next__); + return Ok(ElementHandlerOutput::from_event_end(event, allow_any)); } if let Some(fallback) = fallback.take() { self.finish_state(helper, fallback)?; @@ -17020,175 +21390,73 @@ pub mod quick_xml_deserialize { match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - self.store_field(data)?; - *self.state__ = S::Field(None); + self.store_content(data)?; + *self.state__ = S::Next__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - fallback.get_or_insert(S::Field(Some(deserializer))); - *self.state__ = S::Field(None); + *fallback = Some(S::Content__(deserializer)); + *self.state__ = S::Next__; Ok(ElementHandlerOutput::from_event(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::KeyrefElementTypeContent> - for KeyrefElementTypeContentDeserializer - { + impl<'de> Deserializer<'de, super::RestrictionType> for RestrictionTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::KeyrefElementTypeContent> { - let deserializer = Self { - annotation: None, - selector: None, - field: Vec::new(), - state__: Box::new(KeyrefElementTypeContentDeserializerState::Init__), - }; - let mut output = deserializer.next(helper, event)?; - output.artifact = match output.artifact { - DeserializerArtifact::Deserializer(x) - if matches!( - &*x.state__, - KeyrefElementTypeContentDeserializerState::Init__ - ) => - { - DeserializerArtifact::None - } - artifact => artifact, - }; - Ok(output) + ) -> DeserializerResult<'de, super::RestrictionType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::KeyrefElementTypeContent> { - use KeyrefElementTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::RestrictionType> { + use RestrictionTypeDeserializerState as S; let mut event = event; let mut fallback = None; - let mut allow_any_element = false; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::Annotation(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_annotation(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Selector(Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_selector(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Field(Some(deserializer)), event) => { + (S::Content__(deserializer), event) => { let output = deserializer.next(helper, event)?; - match self.handle_field(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (_, event @ Event::End(_)) => { - if let Some(fallback) = fallback.take() { - self.finish_state(helper, fallback)?; - } + (_, Event::End(_)) => { return Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(self.finish(helper)?), - event: DeserializerEvent::Continue(event), + event: DeserializerEvent::None, allow_any: false, }); } - (S::Init__, event) => { - fallback.get_or_insert(S::Init__); - *self.state__ = S::Annotation(None); - event - } - (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"annotation", - true, - )?; - match self.handle_annotation(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Selector(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"selector", - true, - )?; - match self.handle_selector(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - } - } - (S::Field(None), event @ (Event::Start(_) | Event::Empty(_))) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"field", - true, + (state @ (S::Init__ | S::Next__), event) => { + fallback.get_or_insert(state); + let output = ::init( + helper, event, )?; - match self.handle_field(helper, output, &mut fallback)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } + match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } + ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Done__, event) => { - *self.state__ = S::Done__; - break (DeserializerEvent::Continue(event), allow_any_element); - } - (state, event) => { - *self.state__ = state; - break (DeserializerEvent::Break(event), false); - } } }; if let Some(fallback) = fallback { *self.state__ = fallback; } + let artifact = DeserializerArtifact::Deserializer(self); Ok(DeserializerOutput { - artifact: DeserializerArtifact::Deserializer(self), + artifact, event, allow_any, }) @@ -17196,555 +21464,503 @@ pub mod quick_xml_deserialize { fn finish( mut self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { let state = replace( &mut *self.state__, - KeyrefElementTypeContentDeserializerState::Unknown__, + RestrictionTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::KeyrefElementTypeContent { - annotation: self.annotation, - selector: helper.finish_element("selector", self.selector)?, - field: helper.finish_vec(1usize, None, self.field)?, + Ok(super::RestrictionType { + any_attribute: self.any_attribute, + id: self.id, + base: self.base, + content: helper.finish_vec(0usize, None, self.content)?, }) } } #[derive(Debug)] - pub struct FacetDeserializer { - state__: Box, + pub struct RestrictionTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - pub enum FacetDeserializerState { + pub enum RestrictionTypeContentDeserializerState { Init__, - MinExclusive( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - MinInclusive( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Annotation( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - MaxExclusive( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + OpenContent( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - MaxInclusive( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Group( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - TotalDigits( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + All( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - FractionDigits( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Choice( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Length( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Sequence( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - MinLength( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + SimpleType( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - MaxLength( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Facet( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Enumeration( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Any( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - WhiteSpace( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Attribute( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Pattern( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + AttributeGroup( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Assertion( + AnyAttribute( + Option, + Option<::Deserializer>, + Option<::Deserializer>, + ), + Assert( Option, Option<::Deserializer>, Option<::Deserializer>, ), - ExplicitTimezone( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Done__(super::Facet), + Done__(super::RestrictionTypeContent), Unknown__, } - impl FacetDeserializer { + impl RestrictionTypeContentDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, event: Event<'de>, ) -> Result, Error> { + let mut event = event; + let mut allow_any_element = false; if let Event::Start(x) | Event::Empty(x) = &event { if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"minExclusive") - ) { - let output = ::init(helper, event)?; - return self.handle_min_exclusive(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"minInclusive") - ) { - let output = ::init(helper, event)?; - return self.handle_min_inclusive(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"maxExclusive") + Some(b"annotation") ) { - let output = ::init(helper, event)?; - return self.handle_max_exclusive(helper, Default::default(), None, output); + let output = + ::init(helper, event)?; + return self.handle_annotation(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"maxInclusive") + Some(b"openContent") ) { - let output = ::init(helper, event)?; - return self.handle_max_inclusive(helper, Default::default(), None, output); + let output = + ::init(helper, event)?; + return self.handle_open_content(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"totalDigits") + Some(b"group") ) { - let output = ::init(helper, event)?; - return self.handle_total_digits(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_group(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"fractionDigits") + Some(b"all") ) { - let output = ::init(helper, event)?; - return self.handle_fraction_digits(helper, Default::default(), None, output); + let output = + ::init(helper, event)?; + return self.handle_all(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"length") + Some(b"choice") ) { - let output = ::init(helper, event)?; - return self.handle_length(helper, Default::default(), None, output); + let output = + ::init(helper, event)?; + return self.handle_choice(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"minLength") + Some(b"sequence") ) { - let output = ::init(helper, event)?; - return self.handle_min_length(helper, Default::default(), None, output); + let output = + ::init(helper, event)?; + return self.handle_sequence(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"maxLength") + Some(b"simpleType") ) { - let output = ::init(helper, event)?; - return self.handle_max_length(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_simple_type(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"enumeration") + Some(b"attribute") ) { - let output = ::init(helper, event)?; - return self.handle_enumeration(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_attribute(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"whiteSpace") + Some(b"attributeGroup") ) { - let output = ::init(helper, event)?; - return self.handle_white_space(helper, Default::default(), None, output); + let output = + ::init(helper, event)?; + return self.handle_attribute_group(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"pattern") + Some(b"anyAttribute") ) { - let output = ::init(helper, event)?; - return self.handle_pattern(helper, Default::default(), None, output); + let output = + ::init(helper, event)?; + return self.handle_any_attribute(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"assertion") + Some(b"assert") ) { let output = ::init(helper, event)?; - return self.handle_assertion(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"explicitTimezone") - ) { - let output = ::init(helper, event)?; - return self.handle_explicit_timezone(helper, Default::default(), None, output); + return self.handle_assert(helper, Default::default(), None, output); } + event = { + let output = ::init(helper, event)?; + match self.handle_facet(helper, Default::default(), None, output)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + output => { + return Ok(output); + } + } + }; + event = { + let output = ::init(helper, event)?; + match self.handle_any(helper, Default::default(), None, output)? { + ElementHandlerOutput::Continue { event, .. } => event, + output => { + return Ok(output); + } + } + }; } - *self.state__ = FacetDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent(event, false)) + *self.state__ = RestrictionTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent( + event, + allow_any_element, + )) } fn finish_state( helper: &mut DeserializeHelper, - state: FacetDeserializerState, - ) -> Result { - use FacetDeserializerState as S; + state: RestrictionTypeContentDeserializerState, + ) -> Result { + use RestrictionTypeContentDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), - S::MinExclusive(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_min_exclusive(&mut values, value)?; - } - Ok(super::Facet::MinExclusive( - helper.finish_element("minExclusive", values)?, - )) - } - S::MinInclusive(mut values, None, deserializer) => { + S::Annotation(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_min_inclusive(&mut values, value)?; + Self::store_annotation(&mut values, value)?; } - Ok(super::Facet::MinInclusive( - helper.finish_element("minInclusive", values)?, + Ok(super::RestrictionTypeContent::Annotation( + helper.finish_element("annotation", values)?, )) } - S::MaxExclusive(mut values, None, deserializer) => { + S::OpenContent(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_max_exclusive(&mut values, value)?; + Self::store_open_content(&mut values, value)?; } - Ok(super::Facet::MaxExclusive( - helper.finish_element("maxExclusive", values)?, + Ok(super::RestrictionTypeContent::OpenContent( + helper.finish_element("openContent", values)?, )) } - S::MaxInclusive(mut values, None, deserializer) => { + S::Group(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_max_inclusive(&mut values, value)?; + Self::store_group(&mut values, value)?; } - Ok(super::Facet::MaxInclusive( - helper.finish_element("maxInclusive", values)?, + Ok(super::RestrictionTypeContent::Group( + helper.finish_element("group", values)?, )) } - S::TotalDigits(mut values, None, deserializer) => { + S::All(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_total_digits(&mut values, value)?; + Self::store_all(&mut values, value)?; } - Ok(super::Facet::TotalDigits( - helper.finish_element("totalDigits", values)?, + Ok(super::RestrictionTypeContent::All( + helper.finish_element("all", values)?, )) } - S::FractionDigits(mut values, None, deserializer) => { + S::Choice(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_fraction_digits(&mut values, value)?; + Self::store_choice(&mut values, value)?; } - Ok(super::Facet::FractionDigits( - helper.finish_element("fractionDigits", values)?, + Ok(super::RestrictionTypeContent::Choice( + helper.finish_element("choice", values)?, )) } - S::Length(mut values, None, deserializer) => { + S::Sequence(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_length(&mut values, value)?; + Self::store_sequence(&mut values, value)?; } - Ok(super::Facet::Length( - helper.finish_element("length", values)?, + Ok(super::RestrictionTypeContent::Sequence( + helper.finish_element("sequence", values)?, )) } - S::MinLength(mut values, None, deserializer) => { + S::SimpleType(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_min_length(&mut values, value)?; + Self::store_simple_type(&mut values, value)?; } - Ok(super::Facet::MinLength( - helper.finish_element("minLength", values)?, + Ok(super::RestrictionTypeContent::SimpleType( + helper.finish_element("simpleType", values)?, )) } - S::MaxLength(mut values, None, deserializer) => { + S::Facet(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_max_length(&mut values, value)?; + Self::store_facet(&mut values, value)?; } - Ok(super::Facet::MaxLength( - helper.finish_element("maxLength", values)?, + Ok(super::RestrictionTypeContent::Facet( + helper.finish_element("facet", values)?, )) } - S::Enumeration(mut values, None, deserializer) => { + S::Any(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_enumeration(&mut values, value)?; + Self::store_any(&mut values, value)?; } - Ok(super::Facet::Enumeration( - helper.finish_element("enumeration", values)?, + Ok(super::RestrictionTypeContent::Any( + helper.finish_element("any45", values)?, )) } - S::WhiteSpace(mut values, None, deserializer) => { + S::Attribute(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_white_space(&mut values, value)?; + Self::store_attribute(&mut values, value)?; } - Ok(super::Facet::WhiteSpace( - helper.finish_element("whiteSpace", values)?, + Ok(super::RestrictionTypeContent::Attribute( + helper.finish_element("attribute", values)?, )) } - S::Pattern(mut values, None, deserializer) => { + S::AttributeGroup(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_pattern(&mut values, value)?; + Self::store_attribute_group(&mut values, value)?; } - Ok(super::Facet::Pattern( - helper.finish_element("pattern", values)?, + Ok(super::RestrictionTypeContent::AttributeGroup( + helper.finish_element("attributeGroup", values)?, )) } - S::Assertion(mut values, None, deserializer) => { + S::AnyAttribute(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_assertion(&mut values, value)?; + Self::store_any_attribute(&mut values, value)?; } - Ok(super::Facet::Assertion( - helper.finish_element("assertion", values)?, + Ok(super::RestrictionTypeContent::AnyAttribute( + helper.finish_element("anyAttribute", values)?, )) } - S::ExplicitTimezone(mut values, None, deserializer) => { + S::Assert(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_explicit_timezone(&mut values, value)?; + Self::store_assert(&mut values, value)?; } - Ok(super::Facet::ExplicitTimezone( - helper.finish_element("explicitTimezone", values)?, + Ok(super::RestrictionTypeContent::Assert( + helper.finish_element("assert", values)?, )) } S::Done__(data) => Ok(data), _ => unreachable!(), } } - fn store_min_exclusive( - values: &mut Option, - value: super::FacetType, + fn store_annotation( + values: &mut Option, + value: super::AnnotationElementType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"minExclusive", + b"annotation", )))?; } *values = Some(value); Ok(()) } - fn store_min_inclusive( - values: &mut Option, - value: super::FacetType, + fn store_open_content( + values: &mut Option, + value: super::OpenContentElementType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"minInclusive", + b"openContent", )))?; } *values = Some(value); Ok(()) } - fn store_max_exclusive( - values: &mut Option, - value: super::FacetType, + fn store_group( + values: &mut Option, + value: super::RealGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"maxExclusive", + b"group", )))?; } *values = Some(value); Ok(()) } - fn store_max_inclusive( - values: &mut Option, - value: super::FacetType, + fn store_all( + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"maxInclusive", - )))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"all")))?; } *values = Some(value); Ok(()) } - fn store_total_digits( - values: &mut Option, - value: super::FacetType, + fn store_choice( + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"totalDigits", + b"choice", )))?; } *values = Some(value); Ok(()) } - fn store_fraction_digits( - values: &mut Option, - value: super::FacetType, + fn store_sequence( + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"fractionDigits", + b"sequence", )))?; } *values = Some(value); Ok(()) } - fn store_length( - values: &mut Option, - value: super::FacetType, + fn store_simple_type( + values: &mut Option, + value: super::LocalSimpleType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"length", + b"simpleType", )))?; } *values = Some(value); Ok(()) } - fn store_min_length( - values: &mut Option, - value: super::FacetType, + fn store_facet( + values: &mut Option, + value: super::Facet, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"minLength", + b"facet", )))?; } *values = Some(value); Ok(()) } - fn store_max_length( - values: &mut Option, - value: super::FacetType, - ) -> Result<(), Error> { + fn store_any(values: &mut Option, value: AnyElement) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"maxLength", + b"any45", )))?; } *values = Some(value); Ok(()) } - fn store_enumeration( - values: &mut Option, - value: super::FacetType, + fn store_attribute( + values: &mut Option, + value: super::AttributeType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"enumeration", + b"attribute", )))?; } *values = Some(value); Ok(()) } - fn store_white_space( - values: &mut Option, - value: super::FacetType, + fn store_attribute_group( + values: &mut Option, + value: super::AttributeGroupRefType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"whiteSpace", + b"attributeGroup", )))?; } *values = Some(value); Ok(()) } - fn store_pattern( - values: &mut Option, - value: super::FacetType, + fn store_any_attribute( + values: &mut Option, + value: super::AnyAttributeElementType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"pattern", + b"anyAttribute", )))?; } *values = Some(value); Ok(()) } - fn store_assertion( + fn store_assert( values: &mut Option, value: super::AssertionType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"assertion", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_explicit_timezone( - values: &mut Option, - value: super::FacetType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"explicitTimezone", + b"assert", )))?; } *values = Some(value); Ok(()) } - fn handle_min_exclusive<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, - ) -> Result, Error> { - use FacetDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_min_exclusive(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_min_exclusive(&mut values, data)?; - let data = Self::finish_state(helper, S::MinExclusive(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::MinExclusive(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_min_inclusive<'de>( + fn handle_annotation<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnnotationElementType>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -17755,30 +21971,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_min_inclusive(&mut values, data)?; + Self::store_annotation(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_min_inclusive(&mut values, data)?; - let data = Self::finish_state(helper, S::MinInclusive(values, None, None))?; + Self::store_annotation(&mut values, data)?; + let data = Self::finish_state(helper, S::Annotation(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::MinInclusive(values, None, Some(deserializer)); + *self.state__ = S::Annotation(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_max_exclusive<'de>( + fn handle_open_content<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::OpenContentElementType>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -17789,30 +22005,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_max_exclusive(&mut values, data)?; + Self::store_open_content(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_max_exclusive(&mut values, data)?; - let data = Self::finish_state(helper, S::MaxExclusive(values, None, None))?; + Self::store_open_content(&mut values, data)?; + let data = Self::finish_state(helper, S::OpenContent(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::MaxExclusive(values, None, Some(deserializer)); + *self.state__ = S::OpenContent(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_max_inclusive<'de>( + fn handle_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::RealGroupType>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -17823,30 +22039,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_max_inclusive(&mut values, data)?; + Self::store_group(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_max_inclusive(&mut values, data)?; - let data = Self::finish_state(helper, S::MaxInclusive(values, None, None))?; + Self::store_group(&mut values, data)?; + let data = Self::finish_state(helper, S::Group(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::MaxInclusive(values, None, Some(deserializer)); + *self.state__ = S::Group(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_total_digits<'de>( + fn handle_all<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -17857,30 +22073,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_total_digits(&mut values, data)?; + Self::store_all(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_total_digits(&mut values, data)?; - let data = Self::finish_state(helper, S::TotalDigits(values, None, None))?; + Self::store_all(&mut values, data)?; + let data = Self::finish_state(helper, S::All(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::TotalDigits(values, None, Some(deserializer)); + *self.state__ = S::All(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_fraction_digits<'de>( + fn handle_choice<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -17891,30 +22107,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_fraction_digits(&mut values, data)?; + Self::store_choice(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_fraction_digits(&mut values, data)?; - let data = Self::finish_state(helper, S::FractionDigits(values, None, None))?; + Self::store_choice(&mut values, data)?; + let data = Self::finish_state(helper, S::Choice(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::FractionDigits(values, None, Some(deserializer)); + *self.state__ = S::Choice(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_length<'de>( + fn handle_sequence<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -17925,30 +22141,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_length(&mut values, data)?; + Self::store_sequence(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_length(&mut values, data)?; - let data = Self::finish_state(helper, S::Length(values, None, None))?; + Self::store_sequence(&mut values, data)?; + let data = Self::finish_state(helper, S::Sequence(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Length(values, None, Some(deserializer)); + *self.state__ = S::Sequence(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_min_length<'de>( + fn handle_simple_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LocalSimpleType>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -17959,64 +22175,64 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_min_length(&mut values, data)?; + Self::store_simple_type(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_min_length(&mut values, data)?; - let data = Self::finish_state(helper, S::MinLength(values, None, None))?; + Self::store_simple_type(&mut values, data)?; + let data = Self::finish_state(helper, S::SimpleType(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::MinLength(values, None, Some(deserializer)); + *self.state__ = S::SimpleType(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_max_length<'de>( + fn handle_facet<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::Facet>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, allow_any, } = output; if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); + return Ok(ElementHandlerOutput::from_event(event, allow_any)); } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_max_length(&mut values, data)?; + Self::store_facet(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_max_length(&mut values, data)?; - let data = Self::finish_state(helper, S::MaxLength(values, None, None))?; + Self::store_facet(&mut values, data)?; + let data = Self::finish_state(helper, S::Facet(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::MaxLength(values, None, Some(deserializer)); + *self.state__ = S::Facet(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_enumeration<'de>( + fn handle_any<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, AnyElement>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -18027,30 +22243,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_enumeration(&mut values, data)?; + Self::store_any(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_enumeration(&mut values, data)?; - let data = Self::finish_state(helper, S::Enumeration(values, None, None))?; + Self::store_any(&mut values, data)?; + let data = Self::finish_state(helper, S::Any(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Enumeration(values, None, Some(deserializer)); + *self.state__ = S::Any(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_white_space<'de>( + fn handle_attribute<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AttributeType>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -18061,30 +22277,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_white_space(&mut values, data)?; + Self::store_attribute(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_white_space(&mut values, data)?; - let data = Self::finish_state(helper, S::WhiteSpace(values, None, None))?; + Self::store_attribute(&mut values, data)?; + let data = Self::finish_state(helper, S::Attribute(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::WhiteSpace(values, None, Some(deserializer)); + *self.state__ = S::Attribute(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_pattern<'de>( + fn handle_attribute_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AttributeGroupRefType>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -18095,30 +22311,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_pattern(&mut values, data)?; + Self::store_attribute_group(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_pattern(&mut values, data)?; - let data = Self::finish_state(helper, S::Pattern(values, None, None))?; + Self::store_attribute_group(&mut values, data)?; + let data = Self::finish_state(helper, S::AttributeGroup(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Pattern(values, None, Some(deserializer)); + *self.state__ = S::AttributeGroup(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_assertion<'de>( + fn handle_any_attribute<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AssertionType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnyAttributeElementType>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -18129,30 +22345,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_assertion(&mut values, data)?; + Self::store_any_attribute(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_assertion(&mut values, data)?; - let data = Self::finish_state(helper, S::Assertion(values, None, None))?; + Self::store_any_attribute(&mut values, data)?; + let data = Self::finish_state(helper, S::AnyAttribute(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Assertion(values, None, Some(deserializer)); + *self.state__ = S::AnyAttribute(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_explicit_timezone<'de>( + fn handle_assert<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::FacetType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AssertionType>, ) -> Result, Error> { - use FacetDeserializerState as S; + use RestrictionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -18163,35 +22379,35 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_explicit_timezone(&mut values, data)?; + Self::store_assert(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_explicit_timezone(&mut values, data)?; - let data = Self::finish_state(helper, S::ExplicitTimezone(values, None, None))?; + Self::store_assert(&mut values, data)?; + let data = Self::finish_state(helper, S::Assert(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::ExplicitTimezone(values, None, Some(deserializer)); + *self.state__ = S::Assert(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::Facet> for FacetDeserializer { + impl<'de> Deserializer<'de, super::RestrictionTypeContent> for RestrictionTypeContentDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Facet> { + ) -> DeserializerResult<'de, super::RestrictionTypeContent> { let deserializer = Self { - state__: Box::new(FacetDeserializerState::Init__), + state__: Box::new(RestrictionTypeContentDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, FacetDeserializerState::Init__) => + if matches!(&*x.state__, RestrictionTypeContentDeserializerState::Init__) => { DeserializerArtifact::None } @@ -18203,133 +22419,124 @@ pub mod quick_xml_deserialize { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::Facet> { - use FacetDeserializerState as S; + ) -> DeserializerResult<'de, super::RestrictionTypeContent> { + use RestrictionTypeContentDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); event = match (state, event) { (S::Unknown__, _) => unreachable!(), - (S::MinExclusive(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_min_exclusive(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::MinInclusive(values, fallback, Some(deserializer)), event) => { + (S::Annotation(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_min_inclusive(helper, values, fallback, output)? { + match self.handle_annotation(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::MaxExclusive(values, fallback, Some(deserializer)), event) => { + (S::OpenContent(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_max_exclusive(helper, values, fallback, output)? { + match self.handle_open_content(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::MaxInclusive(values, fallback, Some(deserializer)), event) => { + (S::Group(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_max_inclusive(helper, values, fallback, output)? { + match self.handle_group(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::TotalDigits(values, fallback, Some(deserializer)), event) => { + (S::All(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_total_digits(helper, values, fallback, output)? { + match self.handle_all(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::FractionDigits(values, fallback, Some(deserializer)), event) => { + (S::Choice(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_fraction_digits(helper, values, fallback, output)? { + match self.handle_choice(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Length(values, fallback, Some(deserializer)), event) => { + (S::Sequence(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_length(helper, values, fallback, output)? { + match self.handle_sequence(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::MinLength(values, fallback, Some(deserializer)), event) => { + (S::SimpleType(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_min_length(helper, values, fallback, output)? { + match self.handle_simple_type(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::MaxLength(values, fallback, Some(deserializer)), event) => { + (S::Facet(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_max_length(helper, values, fallback, output)? { + match self.handle_facet(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Enumeration(values, fallback, Some(deserializer)), event) => { + (S::Any(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_enumeration(helper, values, fallback, output)? { + match self.handle_any(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::WhiteSpace(values, fallback, Some(deserializer)), event) => { + (S::Attribute(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_white_space(helper, values, fallback, output)? { + match self.handle_attribute(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Pattern(values, fallback, Some(deserializer)), event) => { + (S::AttributeGroup(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_pattern(helper, values, fallback, output)? { + match self.handle_attribute_group(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Assertion(values, fallback, Some(deserializer)), event) => { + (S::AnyAttribute(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_assertion(helper, values, fallback, output)? { + match self.handle_any_attribute(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::ExplicitTimezone(values, fallback, Some(deserializer)), event) => { + (S::Assert(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_explicit_timezone(helper, values, fallback, output)? { + match self.handle_assert(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18339,46 +22546,29 @@ pub mod quick_xml_deserialize { (state, event @ Event::End(_)) => { return Ok(DeserializerOutput { artifact: DeserializerArtifact::Data(Self::finish_state( - helper, state, - )?), - event: DeserializerEvent::Continue(event), - allow_any: false, - }); - } - (S::Init__, event) => match self.find_suitable(helper, event)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - }, - ( - S::MinExclusive(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"minExclusive", - true, - )?; - match self.handle_min_exclusive(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } + helper, state, + )?), + event: DeserializerEvent::Continue(event), + allow_any: false, + }); } + (S::Init__, event) => match self.find_suitable(helper, event)? { + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + ElementHandlerOutput::Continue { event, .. } => event, + }, ( - S::MinInclusive(values, fallback, None), + S::Annotation(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"minInclusive", + b"annotation", true, )?; - match self.handle_min_inclusive(helper, values, fallback, output)? { + match self.handle_annotation(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18386,16 +22576,16 @@ pub mod quick_xml_deserialize { } } ( - S::MaxExclusive(values, fallback, None), + S::OpenContent(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"maxExclusive", + b"openContent", true, )?; - match self.handle_max_exclusive(helper, values, fallback, output)? { + match self.handle_open_content(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18403,16 +22593,16 @@ pub mod quick_xml_deserialize { } } ( - S::MaxInclusive(values, fallback, None), + S::Group(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"maxInclusive", + b"group", true, )?; - match self.handle_max_inclusive(helper, values, fallback, output)? { + match self.handle_group(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18420,16 +22610,16 @@ pub mod quick_xml_deserialize { } } ( - S::TotalDigits(values, fallback, None), + S::All(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"totalDigits", + b"all", true, )?; - match self.handle_total_digits(helper, values, fallback, output)? { + match self.handle_all(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18437,16 +22627,16 @@ pub mod quick_xml_deserialize { } } ( - S::FractionDigits(values, fallback, None), + S::Choice(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"fractionDigits", + b"choice", true, )?; - match self.handle_fraction_digits(helper, values, fallback, output)? { + match self.handle_choice(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18454,16 +22644,16 @@ pub mod quick_xml_deserialize { } } ( - S::Length(values, fallback, None), + S::Sequence(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"length", + b"sequence", true, )?; - match self.handle_length(helper, values, fallback, output)? { + match self.handle_sequence(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18471,16 +22661,16 @@ pub mod quick_xml_deserialize { } } ( - S::MinLength(values, fallback, None), + S::SimpleType(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"minLength", + b"simpleType", true, )?; - match self.handle_min_length(helper, values, fallback, output)? { + match self.handle_simple_type(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18488,16 +22678,11 @@ pub mod quick_xml_deserialize { } } ( - S::MaxLength(values, fallback, None), + S::Facet(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"maxLength", - true, - )?; - match self.handle_max_length(helper, values, fallback, output)? { + let output = ::init(helper, event)?; + match self.handle_facet(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18505,16 +22690,11 @@ pub mod quick_xml_deserialize { } } ( - S::Enumeration(values, fallback, None), + S::Any(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"enumeration", - true, - )?; - match self.handle_enumeration(helper, values, fallback, output)? { + let output = ::init(helper, event)?; + match self.handle_any(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18522,16 +22702,16 @@ pub mod quick_xml_deserialize { } } ( - S::WhiteSpace(values, fallback, None), + S::Attribute(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"whiteSpace", + b"attribute", true, )?; - match self.handle_white_space(helper, values, fallback, output)? { + match self.handle_attribute(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18539,16 +22719,16 @@ pub mod quick_xml_deserialize { } } ( - S::Pattern(values, fallback, None), + S::AttributeGroup(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"pattern", + b"attributeGroup", true, )?; - match self.handle_pattern(helper, values, fallback, output)? { + match self.handle_attribute_group(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18556,16 +22736,16 @@ pub mod quick_xml_deserialize { } } ( - S::Assertion(values, fallback, None), + S::AnyAttribute(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"assertion", + b"anyAttribute", true, )?; - match self.handle_assertion(helper, values, fallback, output)? { + match self.handle_any_attribute(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18573,16 +22753,16 @@ pub mod quick_xml_deserialize { } } ( - S::ExplicitTimezone(values, fallback, None), + S::Assert(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"explicitTimezone", + b"assert", true, )?; - match self.handle_explicit_timezone(helper, values, fallback, output)? { + match self.handle_assert(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -18610,26 +22790,29 @@ pub mod quick_xml_deserialize { allow_any, }) } - fn finish(self, helper: &mut DeserializeHelper) -> Result { + fn finish( + self, + helper: &mut DeserializeHelper, + ) -> Result { Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct RestrictionTypeDeserializer { + pub struct ExtensionTypeDeserializer { any_attribute: AnyAttributes, id: Option, base: String, - content: Vec, - state__: Box, + content: Vec, + state__: Box, } #[derive(Debug)] - enum RestrictionTypeDeserializerState { + enum ExtensionTypeDeserializerState { Init__, Next__, - Content__(::Deserializer), + Content__(::Deserializer), Unknown__, } - impl RestrictionTypeDeserializer { + impl ExtensionTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, @@ -18658,30 +22841,30 @@ pub mod quick_xml_deserialize { id: id, base: base.ok_or_else(|| ErrorKind::MissingAttribute("base".into()))?, content: Vec::new(), - state__: Box::new(RestrictionTypeDeserializerState::Init__), + state__: Box::new(ExtensionTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: RestrictionTypeDeserializerState, + state: ExtensionTypeDeserializerState, ) -> Result<(), Error> { - if let RestrictionTypeDeserializerState::Content__(deserializer) = state { + if let ExtensionTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content(&mut self, value: super::RestrictionTypeContent) -> Result<(), Error> { + fn store_content(&mut self, value: super::ExtensionTypeContent) -> Result<(), Error> { self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::RestrictionTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::ExtensionTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use RestrictionTypeDeserializerState as S; + use ExtensionTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -18709,19 +22892,19 @@ pub mod quick_xml_deserialize { } } } - impl<'de> Deserializer<'de, super::RestrictionType> for RestrictionTypeDeserializer { + impl<'de> Deserializer<'de, super::ExtensionType> for ExtensionTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::RestrictionType> { + ) -> DeserializerResult<'de, super::ExtensionType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::RestrictionType> { - use RestrictionTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::ExtensionType> { + use ExtensionTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -18746,9 +22929,8 @@ pub mod quick_xml_deserialize { } (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); - let output = ::init( - helper, event, - )?; + let output = + ::init(helper, event)?; match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) @@ -18768,16 +22950,13 @@ pub mod quick_xml_deserialize { allow_any, }) } - fn finish( - mut self, - helper: &mut DeserializeHelper, - ) -> Result { + fn finish(mut self, helper: &mut DeserializeHelper) -> Result { let state = replace( &mut *self.state__, - RestrictionTypeDeserializerState::Unknown__, + ExtensionTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::RestrictionType { + Ok(super::ExtensionType { any_attribute: self.any_attribute, id: self.id, base: self.base, @@ -18786,11 +22965,11 @@ pub mod quick_xml_deserialize { } } #[derive(Debug)] - pub struct RestrictionTypeContentDeserializer { - state__: Box, + pub struct ExtensionTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - pub enum RestrictionTypeContentDeserializerState { + pub enum ExtensionTypeContentDeserializerState { Init__, Annotation( Option, @@ -18803,39 +22982,24 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, ), Group( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), All( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Choice( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Sequence( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - SimpleType( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Facet( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Any( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), Attribute( Option, @@ -18843,9 +23007,9 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, ), AttributeGroup( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), AnyAttribute( Option, @@ -18857,17 +23021,15 @@ pub mod quick_xml_deserialize { Option<::Deserializer>, Option<::Deserializer>, ), - Done__(super::RestrictionTypeContent), + Done__(super::ExtensionTypeContent), Unknown__, } - impl RestrictionTypeContentDeserializer { + impl ExtensionTypeContentDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, event: Event<'de>, ) -> Result, Error> { - let mut event = event; - let mut allow_any_element = false; if let Event::Start(x) | Event::Empty(x) = &event { if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), @@ -18889,37 +23051,33 @@ pub mod quick_xml_deserialize { helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"group") ) { - let output = ::init(helper, event)?; + let output = ::init(helper, event)?; return self.handle_group(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"all") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_all(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"choice") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_choice(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"sequence") ) { - let output = ::init(helper, event)?; + let output = + ::init(helper, event)?; return self.handle_sequence(helper, Default::default(), None, output); } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"simpleType") - ) { - let output = ::init(helper, event)?; - return self.handle_simple_type(helper, Default::default(), None, output); - } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), Some(b"attribute") @@ -18932,7 +23090,7 @@ pub mod quick_xml_deserialize { Some(b"attributeGroup") ) { let output = - ::init(helper, event)?; + ::init(helper, event)?; return self.handle_attribute_group(helper, Default::default(), None, output); } if matches!( @@ -18950,39 +23108,15 @@ pub mod quick_xml_deserialize { let output = ::init(helper, event)?; return self.handle_assert(helper, Default::default(), None, output); } - event = { - let output = ::init(helper, event)?; - match self.handle_facet(helper, Default::default(), None, output)? { - ElementHandlerOutput::Continue { event, allow_any } => { - allow_any_element = allow_any_element || allow_any; - event - } - output => { - return Ok(output); - } - } - }; - event = { - let output = ::init(helper, event)?; - match self.handle_any(helper, Default::default(), None, output)? { - ElementHandlerOutput::Continue { event, .. } => event, - output => { - return Ok(output); - } - } - }; } - *self.state__ = RestrictionTypeContentDeserializerState::Init__; - Ok(ElementHandlerOutput::return_to_parent( - event, - allow_any_element, - )) + *self.state__ = ExtensionTypeContentDeserializerState::Init__; + Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( helper: &mut DeserializeHelper, - state: RestrictionTypeContentDeserializerState, - ) -> Result { - use RestrictionTypeContentDeserializerState as S; + state: ExtensionTypeContentDeserializerState, + ) -> Result { + use ExtensionTypeContentDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), S::Annotation(mut values, None, deserializer) => { @@ -18990,7 +23124,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_annotation(&mut values, value)?; } - Ok(super::RestrictionTypeContent::Annotation( + Ok(super::ExtensionTypeContent::Annotation( helper.finish_element("annotation", values)?, )) } @@ -18999,7 +23133,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_open_content(&mut values, value)?; } - Ok(super::RestrictionTypeContent::OpenContent( + Ok(super::ExtensionTypeContent::OpenContent( helper.finish_element("openContent", values)?, )) } @@ -19008,7 +23142,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_group(&mut values, value)?; } - Ok(super::RestrictionTypeContent::Group( + Ok(super::ExtensionTypeContent::Group( helper.finish_element("group", values)?, )) } @@ -19017,7 +23151,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_all(&mut values, value)?; } - Ok(super::RestrictionTypeContent::All( + Ok(super::ExtensionTypeContent::All( helper.finish_element("all", values)?, )) } @@ -19026,44 +23160,17 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_choice(&mut values, value)?; } - Ok(super::RestrictionTypeContent::Choice( + Ok(super::ExtensionTypeContent::Choice( helper.finish_element("choice", values)?, )) } - S::Sequence(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_sequence(&mut values, value)?; - } - Ok(super::RestrictionTypeContent::Sequence( - helper.finish_element("sequence", values)?, - )) - } - S::SimpleType(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_simple_type(&mut values, value)?; - } - Ok(super::RestrictionTypeContent::SimpleType( - helper.finish_element("simpleType", values)?, - )) - } - S::Facet(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_facet(&mut values, value)?; - } - Ok(super::RestrictionTypeContent::Facet( - helper.finish_element("facet", values)?, - )) - } - S::Any(mut values, None, deserializer) => { + S::Sequence(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_any(&mut values, value)?; + Self::store_sequence(&mut values, value)?; } - Ok(super::RestrictionTypeContent::Any( - helper.finish_element("any45", values)?, + Ok(super::ExtensionTypeContent::Sequence( + helper.finish_element("sequence", values)?, )) } S::Attribute(mut values, None, deserializer) => { @@ -19071,7 +23178,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_attribute(&mut values, value)?; } - Ok(super::RestrictionTypeContent::Attribute( + Ok(super::ExtensionTypeContent::Attribute( helper.finish_element("attribute", values)?, )) } @@ -19080,7 +23187,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_attribute_group(&mut values, value)?; } - Ok(super::RestrictionTypeContent::AttributeGroup( + Ok(super::ExtensionTypeContent::AttributeGroup( helper.finish_element("attributeGroup", values)?, )) } @@ -19089,7 +23196,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_any_attribute(&mut values, value)?; } - Ok(super::RestrictionTypeContent::AnyAttribute( + Ok(super::ExtensionTypeContent::AnyAttribute( helper.finish_element("anyAttribute", values)?, )) } @@ -19098,7 +23205,7 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_assert(&mut values, value)?; } - Ok(super::RestrictionTypeContent::Assert( + Ok(super::ExtensionTypeContent::Assert( helper.finish_element("assert", values)?, )) } @@ -19131,8 +23238,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_group( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::RealGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -19143,8 +23250,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_all( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"all")))?; @@ -19153,8 +23260,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_choice( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -19165,8 +23272,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_sequence( - values: &mut Option, - value: super::GroupType, + values: &mut Option, + value: super::ExplicitGroupType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -19176,39 +23283,6 @@ pub mod quick_xml_deserialize { *values = Some(value); Ok(()) } - fn store_simple_type( - values: &mut Option, - value: super::SimpleBaseType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"simpleType", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_facet( - values: &mut Option, - value: super::Facet, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"facet", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_any(values: &mut Option, value: AnyElement) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"any45", - )))?; - } - *values = Some(value); - Ok(()) - } fn store_attribute( values: &mut Option, value: super::AttributeType, @@ -19222,8 +23296,8 @@ pub mod quick_xml_deserialize { Ok(()) } fn store_attribute_group( - values: &mut Option, - value: super::AttributeGroupType, + values: &mut Option, + value: super::AttributeGroupRefType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( @@ -19264,7 +23338,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AnnotationElementType>, ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; + use ExtensionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -19298,7 +23372,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::OpenContentElementType>, ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; + use ExtensionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -19328,11 +23402,11 @@ pub mod quick_xml_deserialize { fn handle_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::RealGroupType>, ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; + use ExtensionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -19362,11 +23436,11 @@ pub mod quick_xml_deserialize { fn handle_all<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; + use ExtensionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -19396,11 +23470,11 @@ pub mod quick_xml_deserialize { fn handle_choice<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; + use ExtensionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -19430,11 +23504,11 @@ pub mod quick_xml_deserialize { fn handle_sequence<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::ExplicitGroupType>, ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; + use ExtensionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -19461,108 +23535,6 @@ pub mod quick_xml_deserialize { } } } - fn handle_simple_type<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::SimpleBaseType>, - ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_simple_type(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_simple_type(&mut values, data)?; - let data = Self::finish_state(helper, S::SimpleType(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::SimpleType(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_facet<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::Facet>, - ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::from_event(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_facet(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_facet(&mut values, data)?; - let data = Self::finish_state(helper, S::Facet(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Facet(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_any<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, AnyElement>, - ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_any(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_any(&mut values, data)?; - let data = Self::finish_state(helper, S::Any(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Any(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } fn handle_attribute<'de>( &mut self, helper: &mut DeserializeHelper, @@ -19570,7 +23542,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AttributeType>, ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; + use ExtensionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -19600,11 +23572,11 @@ pub mod quick_xml_deserialize { fn handle_attribute_group<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AttributeGroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AttributeGroupRefType>, ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; + use ExtensionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -19638,7 +23610,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AnyAttributeElementType>, ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; + use ExtensionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -19672,7 +23644,7 @@ pub mod quick_xml_deserialize { fallback: Option<::Deserializer>, output: DeserializerOutput<'de, super::AssertionType>, ) -> Result, Error> { - use RestrictionTypeContentDeserializerState as S; + use ExtensionTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -19700,18 +23672,18 @@ pub mod quick_xml_deserialize { } } } - impl<'de> Deserializer<'de, super::RestrictionTypeContent> for RestrictionTypeContentDeserializer { + impl<'de> Deserializer<'de, super::ExtensionTypeContent> for ExtensionTypeContentDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::RestrictionTypeContent> { + ) -> DeserializerResult<'de, super::ExtensionTypeContent> { let deserializer = Self { - state__: Box::new(RestrictionTypeContentDeserializerState::Init__), + state__: Box::new(ExtensionTypeContentDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, RestrictionTypeContentDeserializerState::Init__) => + if matches!(&*x.state__, ExtensionTypeContentDeserializerState::Init__) => { DeserializerArtifact::None } @@ -19723,8 +23695,8 @@ pub mod quick_xml_deserialize { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::RestrictionTypeContent> { - use RestrictionTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::ExtensionTypeContent> { + use ExtensionTypeContentDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); @@ -19784,33 +23756,6 @@ pub mod quick_xml_deserialize { ElementHandlerOutput::Continue { event, .. } => event, } } - (S::SimpleType(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_simple_type(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Facet(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_facet(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Any(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_any(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } (S::Attribute(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; match self.handle_attribute(helper, values, fallback, output)? { @@ -19897,67 +23842,16 @@ pub mod quick_xml_deserialize { } } ( - S::Group(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"group", - true, - )?; - match self.handle_group(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::All(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"all", - true, - )?; - match self.handle_all(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::Choice(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"choice", - true, - )?; - match self.handle_choice(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::Sequence(values, fallback, None), + S::Group(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"sequence", + b"group", true, )?; - match self.handle_sequence(helper, values, fallback, output)? { + match self.handle_group(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -19965,16 +23859,16 @@ pub mod quick_xml_deserialize { } } ( - S::SimpleType(values, fallback, None), + S::All(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"simpleType", + b"all", true, )?; - match self.handle_simple_type(helper, values, fallback, output)? { + match self.handle_all(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -19982,11 +23876,16 @@ pub mod quick_xml_deserialize { } } ( - S::Facet(values, fallback, None), + S::Choice(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = ::init(helper, event)?; - match self.handle_facet(helper, values, fallback, output)? { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"choice", + true, + )?; + match self.handle_choice(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -19994,11 +23893,16 @@ pub mod quick_xml_deserialize { } } ( - S::Any(values, fallback, None), + S::Sequence(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { - let output = ::init(helper, event)?; - match self.handle_any(helper, values, fallback, output)? { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"sequence", + true, + )?; + match self.handle_sequence(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -20097,33 +24001,53 @@ pub mod quick_xml_deserialize { fn finish( self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { Self::finish_state(helper, *self.state__) } } #[derive(Debug)] - pub struct ExtensionTypeDeserializer { + pub struct LocalElementTypeDeserializer { any_attribute: AnyAttributes, id: Option, - base: String, - content: Vec, - state__: Box, + name: Option, + ref_: Option, + type_: Option, + min_occurs: usize, + max_occurs: super::AllNniType, + default: Option, + fixed: Option, + nillable: Option, + block: Option, + form: Option, + target_namespace: Option, + content: Vec, + state__: Box, } #[derive(Debug)] - enum ExtensionTypeDeserializerState { + enum LocalElementTypeDeserializerState { Init__, Next__, - Content__(::Deserializer), + Content__(::Deserializer), Unknown__, } - impl ExtensionTypeDeserializer { + impl LocalElementTypeDeserializer { fn from_bytes_start( helper: &mut DeserializeHelper, bytes_start: &BytesStart<'_>, ) -> Result { let mut any_attribute = AnyAttributes::default(); let mut id: Option = None; - let mut base: Option = None; + let mut name: Option = None; + let mut ref_: Option = None; + let mut type_: Option = None; + let mut min_occurs: Option = None; + let mut max_occurs: Option = None; + let mut default: Option = None; + let mut fixed: Option = None; + let mut nillable: Option = None; + let mut block: Option = None; + let mut form: Option = None; + let mut target_namespace: Option = None; for attrib in helper.filter_xmlns_attributes(bytes_start) { let attrib = attrib?; if matches!( @@ -20133,9 +24057,59 @@ pub mod quick_xml_deserialize { helper.read_attrib(&mut id, b"id", &attrib.value)?; } else if matches!( helper.resolve_local_name(attrib.key, &super::NS_XS), - Some(b"base") + Some(b"name") ) { - helper.read_attrib(&mut base, b"base", &attrib.value)?; + helper.read_attrib(&mut name, b"name", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"ref") + ) { + helper.read_attrib(&mut ref_, b"ref", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"type") + ) { + helper.read_attrib(&mut type_, b"type", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"minOccurs") + ) { + helper.read_attrib(&mut min_occurs, b"minOccurs", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"maxOccurs") + ) { + helper.read_attrib(&mut max_occurs, b"maxOccurs", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"default") + ) { + helper.read_attrib(&mut default, b"default", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"fixed") + ) { + helper.read_attrib(&mut fixed, b"fixed", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"nillable") + ) { + helper.read_attrib(&mut nillable, b"nillable", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"block") + ) { + helper.read_attrib(&mut block, b"block", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"form") + ) { + helper.read_attrib(&mut form, b"form", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"targetNamespace") + ) { + helper.read_attrib(&mut target_namespace, b"targetNamespace", &attrib.value)?; } else { any_attribute.push(attrib)?; } @@ -20143,32 +24117,42 @@ pub mod quick_xml_deserialize { Ok(Self { any_attribute: any_attribute, id: id, - base: base.ok_or_else(|| ErrorKind::MissingAttribute("base".into()))?, + name: name, + ref_: ref_, + type_: type_, + min_occurs: min_occurs.unwrap_or_else(super::LocalElementType::default_min_occurs), + max_occurs: max_occurs.unwrap_or_else(super::LocalElementType::default_max_occurs), + default: default, + fixed: fixed, + nillable: nillable, + block: block, + form: form, + target_namespace: target_namespace, content: Vec::new(), - state__: Box::new(ExtensionTypeDeserializerState::Init__), + state__: Box::new(LocalElementTypeDeserializerState::Init__), }) } fn finish_state( &mut self, helper: &mut DeserializeHelper, - state: ExtensionTypeDeserializerState, + state: LocalElementTypeDeserializerState, ) -> Result<(), Error> { - if let ExtensionTypeDeserializerState::Content__(deserializer) = state { + if let LocalElementTypeDeserializerState::Content__(deserializer) = state { self.store_content(deserializer.finish(helper)?)?; } Ok(()) } - fn store_content(&mut self, value: super::ExtensionTypeContent) -> Result<(), Error> { + fn store_content(&mut self, value: super::LocalElementTypeContent) -> Result<(), Error> { self.content.push(value); Ok(()) } fn handle_content<'de>( &mut self, helper: &mut DeserializeHelper, - output: DeserializerOutput<'de, super::ExtensionTypeContent>, - fallback: &mut Option, + output: DeserializerOutput<'de, super::LocalElementTypeContent>, + fallback: &mut Option, ) -> Result, Error> { - use ExtensionTypeDeserializerState as S; + use LocalElementTypeDeserializerState as S; let DeserializerOutput { artifact, event, @@ -20196,19 +24180,19 @@ pub mod quick_xml_deserialize { } } } - impl<'de> Deserializer<'de, super::ExtensionType> for ExtensionTypeDeserializer { + impl<'de> Deserializer<'de, super::LocalElementType> for LocalElementTypeDeserializer { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::ExtensionType> { + ) -> DeserializerResult<'de, super::LocalElementType> { helper.init_deserializer_from_start_event(event, Self::from_bytes_start) } fn next( mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::ExtensionType> { - use ExtensionTypeDeserializerState as S; + ) -> DeserializerResult<'de, super::LocalElementType> { + use LocalElementTypeDeserializerState as S; let mut event = event; let mut fallback = None; let (event, allow_any) = loop { @@ -20233,8 +24217,9 @@ pub mod quick_xml_deserialize { } (state @ (S::Init__ | S::Next__), event) => { fallback.get_or_insert(state); - let output = - ::init(helper, event)?; + let output = ::init( + helper, event, + )?; match self.handle_content(helper, output, &mut fallback)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) @@ -20254,81 +24239,79 @@ pub mod quick_xml_deserialize { allow_any, }) } - fn finish(mut self, helper: &mut DeserializeHelper) -> Result { + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { let state = replace( &mut *self.state__, - ExtensionTypeDeserializerState::Unknown__, + LocalElementTypeDeserializerState::Unknown__, ); self.finish_state(helper, state)?; - Ok(super::ExtensionType { + Ok(super::LocalElementType { any_attribute: self.any_attribute, id: self.id, - base: self.base, + name: self.name, + ref_: self.ref_, + type_: self.type_, + min_occurs: self.min_occurs, + max_occurs: self.max_occurs, + default: self.default, + fixed: self.fixed, + nillable: self.nillable, + block: self.block, + form: self.form, + target_namespace: self.target_namespace, content: helper.finish_vec(0usize, None, self.content)?, }) } } #[derive(Debug)] - pub struct ExtensionTypeContentDeserializer { - state__: Box, + pub struct LocalElementTypeContentDeserializer { + state__: Box, } #[derive(Debug)] - pub enum ExtensionTypeContentDeserializerState { + pub enum LocalElementTypeContentDeserializerState { Init__, Annotation( Option, Option<::Deserializer>, Option<::Deserializer>, ), - OpenContent( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Group( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - All( - Option, - Option<::Deserializer>, - Option<::Deserializer>, - ), - Choice( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + SimpleType( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Sequence( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + ComplexType( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Attribute( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Alternative( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - AttributeGroup( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Unique( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - AnyAttribute( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Key( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Assert( - Option, - Option<::Deserializer>, - Option<::Deserializer>, + Keyref( + Option, + Option<::Deserializer>, + Option<::Deserializer>, ), - Done__(super::ExtensionTypeContent), + Done__(super::LocalElementTypeContent), Unknown__, } - impl ExtensionTypeContentDeserializer { + impl LocalElementTypeContentDeserializer { fn find_suitable<'de>( &mut self, helper: &mut DeserializeHelper, @@ -20345,79 +24328,57 @@ pub mod quick_xml_deserialize { } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"openContent") - ) { - let output = - ::init(helper, event)?; - return self.handle_open_content(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"group") - ) { - let output = ::init(helper, event)?; - return self.handle_group(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"all") - ) { - let output = ::init(helper, event)?; - return self.handle_all(helper, Default::default(), None, output); - } - if matches!( - helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"choice") + Some(b"simpleType") ) { - let output = ::init(helper, event)?; - return self.handle_choice(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_simple_type(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"sequence") + Some(b"complexType") ) { - let output = ::init(helper, event)?; - return self.handle_sequence(helper, Default::default(), None, output); + let output = + ::init(helper, event)?; + return self.handle_complex_type(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"attribute") + Some(b"alternative") ) { - let output = ::init(helper, event)?; - return self.handle_attribute(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_alternative(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"attributeGroup") + Some(b"unique") ) { - let output = - ::init(helper, event)?; - return self.handle_attribute_group(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_unique(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"anyAttribute") + Some(b"key") ) { - let output = - ::init(helper, event)?; - return self.handle_any_attribute(helper, Default::default(), None, output); + let output = ::init(helper, event)?; + return self.handle_key(helper, Default::default(), None, output); } if matches!( helper.resolve_local_name(x.name(), &super::NS_XS), - Some(b"assert") + Some(b"keyref") ) { - let output = ::init(helper, event)?; - return self.handle_assert(helper, Default::default(), None, output); + let output = + ::init(helper, event)?; + return self.handle_keyref(helper, Default::default(), None, output); } } - *self.state__ = ExtensionTypeContentDeserializerState::Init__; + *self.state__ = LocalElementTypeContentDeserializerState::Init__; Ok(ElementHandlerOutput::return_to_parent(event, false)) } fn finish_state( helper: &mut DeserializeHelper, - state: ExtensionTypeContentDeserializerState, - ) -> Result { - use ExtensionTypeContentDeserializerState as S; + state: LocalElementTypeContentDeserializerState, + ) -> Result { + use LocalElementTypeContentDeserializerState as S; match state { S::Init__ => Err(ErrorKind::MissingContent.into()), S::Annotation(mut values, None, deserializer) => { @@ -20425,89 +24386,62 @@ pub mod quick_xml_deserialize { let value = deserializer.finish(helper)?; Self::store_annotation(&mut values, value)?; } - Ok(super::ExtensionTypeContent::Annotation( + Ok(super::LocalElementTypeContent::Annotation( helper.finish_element("annotation", values)?, )) } - S::OpenContent(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_open_content(&mut values, value)?; - } - Ok(super::ExtensionTypeContent::OpenContent( - helper.finish_element("openContent", values)?, - )) - } - S::Group(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_group(&mut values, value)?; - } - Ok(super::ExtensionTypeContent::Group( - helper.finish_element("group", values)?, - )) - } - S::All(mut values, None, deserializer) => { - if let Some(deserializer) = deserializer { - let value = deserializer.finish(helper)?; - Self::store_all(&mut values, value)?; - } - Ok(super::ExtensionTypeContent::All( - helper.finish_element("all", values)?, - )) - } - S::Choice(mut values, None, deserializer) => { + S::SimpleType(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_choice(&mut values, value)?; + Self::store_simple_type(&mut values, value)?; } - Ok(super::ExtensionTypeContent::Choice( - helper.finish_element("choice", values)?, + Ok(super::LocalElementTypeContent::SimpleType( + helper.finish_element("simpleType", values)?, )) } - S::Sequence(mut values, None, deserializer) => { + S::ComplexType(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_sequence(&mut values, value)?; + Self::store_complex_type(&mut values, value)?; } - Ok(super::ExtensionTypeContent::Sequence( - helper.finish_element("sequence", values)?, + Ok(super::LocalElementTypeContent::ComplexType( + helper.finish_element("complexType", values)?, )) } - S::Attribute(mut values, None, deserializer) => { + S::Alternative(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_attribute(&mut values, value)?; + Self::store_alternative(&mut values, value)?; } - Ok(super::ExtensionTypeContent::Attribute( - helper.finish_element("attribute", values)?, + Ok(super::LocalElementTypeContent::Alternative( + helper.finish_element("alternative", values)?, )) } - S::AttributeGroup(mut values, None, deserializer) => { + S::Unique(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_attribute_group(&mut values, value)?; + Self::store_unique(&mut values, value)?; } - Ok(super::ExtensionTypeContent::AttributeGroup( - helper.finish_element("attributeGroup", values)?, + Ok(super::LocalElementTypeContent::Unique( + helper.finish_element("unique", values)?, )) } - S::AnyAttribute(mut values, None, deserializer) => { + S::Key(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_any_attribute(&mut values, value)?; + Self::store_key(&mut values, value)?; } - Ok(super::ExtensionTypeContent::AnyAttribute( - helper.finish_element("anyAttribute", values)?, + Ok(super::LocalElementTypeContent::Key( + helper.finish_element("key", values)?, )) } - S::Assert(mut values, None, deserializer) => { + S::Keyref(mut values, None, deserializer) => { if let Some(deserializer) = deserializer { let value = deserializer.finish(helper)?; - Self::store_assert(&mut values, value)?; + Self::store_keyref(&mut values, value)?; } - Ok(super::ExtensionTypeContent::Assert( - helper.finish_element("assert", values)?, + Ok(super::LocalElementTypeContent::Keyref( + helper.finish_element("keyref", values)?, )) } S::Done__(data) => Ok(data), @@ -20526,222 +24460,84 @@ pub mod quick_xml_deserialize { *values = Some(value); Ok(()) } - fn store_open_content( - values: &mut Option, - value: super::OpenContentElementType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"openContent", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_group( - values: &mut Option, - value: super::GroupType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"group", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_all( - values: &mut Option, - value: super::GroupType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"all")))?; - } - *values = Some(value); - Ok(()) - } - fn store_choice( - values: &mut Option, - value: super::GroupType, - ) -> Result<(), Error> { - if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"choice", - )))?; - } - *values = Some(value); - Ok(()) - } - fn store_sequence( - values: &mut Option, - value: super::GroupType, + fn store_simple_type( + values: &mut Option, + value: super::LocalSimpleType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"sequence", + b"simpleType", )))?; } *values = Some(value); Ok(()) } - fn store_attribute( - values: &mut Option, - value: super::AttributeType, + fn store_complex_type( + values: &mut Option, + value: super::LocalComplexType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"attribute", + b"complexType", )))?; } *values = Some(value); Ok(()) } - fn store_attribute_group( - values: &mut Option, - value: super::AttributeGroupType, + fn store_alternative( + values: &mut Option, + value: super::AltType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"attributeGroup", + b"alternative", )))?; } *values = Some(value); Ok(()) } - fn store_any_attribute( - values: &mut Option, - value: super::AnyAttributeElementType, + fn store_unique( + values: &mut Option, + value: super::KeybaseType, ) -> Result<(), Error> { if values.is_some() { Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"anyAttribute", + b"unique", )))?; } *values = Some(value); Ok(()) } - fn store_assert( - values: &mut Option, - value: super::AssertionType, + fn store_key( + values: &mut Option, + value: super::KeybaseType, ) -> Result<(), Error> { if values.is_some() { - Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( - b"assert", - )))?; + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"key")))?; } *values = Some(value); - Ok(()) - } - fn handle_annotation<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AnnotationElementType>, - ) -> Result, Error> { - use ExtensionTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_annotation(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_annotation(&mut values, data)?; - let data = Self::finish_state(helper, S::Annotation(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Annotation(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_open_content<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::OpenContentElementType>, - ) -> Result, Error> { - use ExtensionTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_open_content(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_open_content(&mut values, data)?; - let data = Self::finish_state(helper, S::OpenContent(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::OpenContent(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - } - } - fn handle_group<'de>( - &mut self, - helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, - ) -> Result, Error> { - use ExtensionTypeContentDeserializerState as S; - let DeserializerOutput { - artifact, - event, - allow_any, - } = output; - if artifact.is_none() { - return Ok(ElementHandlerOutput::return_to_root(event, allow_any)); - } - if let Some(deserializer) = fallback { - let data = deserializer.finish(helper)?; - Self::store_group(&mut values, data)?; - } - match artifact { - DeserializerArtifact::None => unreachable!(), - DeserializerArtifact::Data(data) => { - Self::store_group(&mut values, data)?; - let data = Self::finish_state(helper, S::Group(values, None, None))?; - *self.state__ = S::Done__(data); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } - DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Group(values, None, Some(deserializer)); - Ok(ElementHandlerOutput::break_(event, allow_any)) - } + Ok(()) + } + fn store_keyref( + values: &mut Option, + value: super::KeyrefElementType, + ) -> Result<(), Error> { + if values.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"keyref", + )))?; } + *values = Some(value); + Ok(()) } - fn handle_all<'de>( + fn handle_annotation<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AnnotationElementType>, ) -> Result, Error> { - use ExtensionTypeContentDeserializerState as S; + use LocalElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -20752,30 +24548,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_all(&mut values, data)?; + Self::store_annotation(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_all(&mut values, data)?; - let data = Self::finish_state(helper, S::All(values, None, None))?; + Self::store_annotation(&mut values, data)?; + let data = Self::finish_state(helper, S::Annotation(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::All(values, None, Some(deserializer)); + *self.state__ = S::Annotation(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_choice<'de>( + fn handle_simple_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LocalSimpleType>, ) -> Result, Error> { - use ExtensionTypeContentDeserializerState as S; + use LocalElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -20786,30 +24582,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_choice(&mut values, data)?; + Self::store_simple_type(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_choice(&mut values, data)?; - let data = Self::finish_state(helper, S::Choice(values, None, None))?; + Self::store_simple_type(&mut values, data)?; + let data = Self::finish_state(helper, S::SimpleType(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Choice(values, None, Some(deserializer)); + *self.state__ = S::SimpleType(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_sequence<'de>( + fn handle_complex_type<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::GroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::LocalComplexType>, ) -> Result, Error> { - use ExtensionTypeContentDeserializerState as S; + use LocalElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -20820,30 +24616,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_sequence(&mut values, data)?; + Self::store_complex_type(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_sequence(&mut values, data)?; - let data = Self::finish_state(helper, S::Sequence(values, None, None))?; + Self::store_complex_type(&mut values, data)?; + let data = Self::finish_state(helper, S::ComplexType(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Sequence(values, None, Some(deserializer)); + *self.state__ = S::ComplexType(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_attribute<'de>( + fn handle_alternative<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AttributeType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::AltType>, ) -> Result, Error> { - use ExtensionTypeContentDeserializerState as S; + use LocalElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -20854,30 +24650,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_attribute(&mut values, data)?; + Self::store_alternative(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_attribute(&mut values, data)?; - let data = Self::finish_state(helper, S::Attribute(values, None, None))?; + Self::store_alternative(&mut values, data)?; + let data = Self::finish_state(helper, S::Alternative(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Attribute(values, None, Some(deserializer)); + *self.state__ = S::Alternative(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_attribute_group<'de>( + fn handle_unique<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AttributeGroupType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::KeybaseType>, ) -> Result, Error> { - use ExtensionTypeContentDeserializerState as S; + use LocalElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -20888,30 +24684,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_attribute_group(&mut values, data)?; + Self::store_unique(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_attribute_group(&mut values, data)?; - let data = Self::finish_state(helper, S::AttributeGroup(values, None, None))?; + Self::store_unique(&mut values, data)?; + let data = Self::finish_state(helper, S::Unique(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::AttributeGroup(values, None, Some(deserializer)); + *self.state__ = S::Unique(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_any_attribute<'de>( + fn handle_key<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AnyAttributeElementType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::KeybaseType>, ) -> Result, Error> { - use ExtensionTypeContentDeserializerState as S; + use LocalElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -20922,30 +24718,30 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_any_attribute(&mut values, data)?; + Self::store_key(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_any_attribute(&mut values, data)?; - let data = Self::finish_state(helper, S::AnyAttribute(values, None, None))?; + Self::store_key(&mut values, data)?; + let data = Self::finish_state(helper, S::Key(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::AnyAttribute(values, None, Some(deserializer)); + *self.state__ = S::Key(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } - fn handle_assert<'de>( + fn handle_keyref<'de>( &mut self, helper: &mut DeserializeHelper, - mut values: Option, - fallback: Option<::Deserializer>, - output: DeserializerOutput<'de, super::AssertionType>, + mut values: Option, + fallback: Option<::Deserializer>, + output: DeserializerOutput<'de, super::KeyrefElementType>, ) -> Result, Error> { - use ExtensionTypeContentDeserializerState as S; + use LocalElementTypeContentDeserializerState as S; let DeserializerOutput { artifact, event, @@ -20956,35 +24752,40 @@ pub mod quick_xml_deserialize { } if let Some(deserializer) = fallback { let data = deserializer.finish(helper)?; - Self::store_assert(&mut values, data)?; + Self::store_keyref(&mut values, data)?; } match artifact { DeserializerArtifact::None => unreachable!(), DeserializerArtifact::Data(data) => { - Self::store_assert(&mut values, data)?; - let data = Self::finish_state(helper, S::Assert(values, None, None))?; + Self::store_keyref(&mut values, data)?; + let data = Self::finish_state(helper, S::Keyref(values, None, None))?; *self.state__ = S::Done__(data); Ok(ElementHandlerOutput::break_(event, allow_any)) } DeserializerArtifact::Deserializer(deserializer) => { - *self.state__ = S::Assert(values, None, Some(deserializer)); + *self.state__ = S::Keyref(values, None, Some(deserializer)); Ok(ElementHandlerOutput::break_(event, allow_any)) } } } } - impl<'de> Deserializer<'de, super::ExtensionTypeContent> for ExtensionTypeContentDeserializer { + impl<'de> Deserializer<'de, super::LocalElementTypeContent> + for LocalElementTypeContentDeserializer + { fn init( helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::ExtensionTypeContent> { + ) -> DeserializerResult<'de, super::LocalElementTypeContent> { let deserializer = Self { - state__: Box::new(ExtensionTypeContentDeserializerState::Init__), + state__: Box::new(LocalElementTypeContentDeserializerState::Init__), }; let mut output = deserializer.next(helper, event)?; output.artifact = match output.artifact { DeserializerArtifact::Deserializer(x) - if matches!(&*x.state__, ExtensionTypeContentDeserializerState::Init__) => + if matches!( + &*x.state__, + LocalElementTypeContentDeserializerState::Init__ + ) => { DeserializerArtifact::None } @@ -20996,8 +24797,8 @@ pub mod quick_xml_deserialize { mut self, helper: &mut DeserializeHelper, event: Event<'de>, - ) -> DeserializerResult<'de, super::ExtensionTypeContent> { - use ExtensionTypeContentDeserializerState as S; + ) -> DeserializerResult<'de, super::LocalElementTypeContent> { + use LocalElementTypeContentDeserializerState as S; let mut event = event; let (event, allow_any) = loop { let state = replace(&mut *self.state__, S::Unknown__); @@ -21012,81 +24813,54 @@ pub mod quick_xml_deserialize { ElementHandlerOutput::Continue { event, .. } => event, } } - (S::OpenContent(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_open_content(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Group(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_group(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::All(values, fallback, Some(deserializer)), event) => { - let output = deserializer.next(helper, event)?; - match self.handle_all(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - (S::Choice(values, fallback, Some(deserializer)), event) => { + (S::SimpleType(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_choice(helper, values, fallback, output)? { + match self.handle_simple_type(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Sequence(values, fallback, Some(deserializer)), event) => { + (S::ComplexType(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_sequence(helper, values, fallback, output)? { + match self.handle_complex_type(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Attribute(values, fallback, Some(deserializer)), event) => { + (S::Alternative(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_attribute(helper, values, fallback, output)? { + match self.handle_alternative(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::AttributeGroup(values, fallback, Some(deserializer)), event) => { + (S::Unique(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_attribute_group(helper, values, fallback, output)? { + match self.handle_unique(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::AnyAttribute(values, fallback, Some(deserializer)), event) => { + (S::Key(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_any_attribute(helper, values, fallback, output)? { + match self.handle_key(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } ElementHandlerOutput::Continue { event, .. } => event, } } - (S::Assert(values, fallback, Some(deserializer)), event) => { + (S::Keyref(values, fallback, Some(deserializer)), event) => { let output = deserializer.next(helper, event)?; - match self.handle_assert(helper, values, fallback, output)? { + match self.handle_keyref(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -21126,67 +24900,16 @@ pub mod quick_xml_deserialize { } } ( - S::OpenContent(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"openContent", - true, - )?; - match self.handle_open_content(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::Group(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"group", - true, - )?; - match self.handle_group(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::All(values, fallback, None), - event @ (Event::Start(_) | Event::Empty(_)), - ) => { - let output = helper.init_start_tag_deserializer( - event, - Some(&super::NS_XS), - b"all", - true, - )?; - match self.handle_all(helper, values, fallback, output)? { - ElementHandlerOutput::Break { event, allow_any } => { - break (event, allow_any) - } - ElementHandlerOutput::Continue { event, .. } => event, - } - } - ( - S::Choice(values, fallback, None), + S::SimpleType(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"choice", + b"simpleType", true, )?; - match self.handle_choice(helper, values, fallback, output)? { + match self.handle_simple_type(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -21194,16 +24917,16 @@ pub mod quick_xml_deserialize { } } ( - S::Sequence(values, fallback, None), + S::ComplexType(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"sequence", + b"complexType", true, )?; - match self.handle_sequence(helper, values, fallback, output)? { + match self.handle_complex_type(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -21211,16 +24934,16 @@ pub mod quick_xml_deserialize { } } ( - S::Attribute(values, fallback, None), + S::Alternative(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"attribute", + b"alternative", true, )?; - match self.handle_attribute(helper, values, fallback, output)? { + match self.handle_alternative(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -21228,16 +24951,16 @@ pub mod quick_xml_deserialize { } } ( - S::AttributeGroup(values, fallback, None), + S::Unique(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"attributeGroup", + b"unique", true, )?; - match self.handle_attribute_group(helper, values, fallback, output)? { + match self.handle_unique(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -21245,16 +24968,16 @@ pub mod quick_xml_deserialize { } } ( - S::AnyAttribute(values, fallback, None), + S::Key(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"anyAttribute", + b"key", true, )?; - match self.handle_any_attribute(helper, values, fallback, output)? { + match self.handle_key(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -21262,16 +24985,16 @@ pub mod quick_xml_deserialize { } } ( - S::Assert(values, fallback, None), + S::Keyref(values, fallback, None), event @ (Event::Start(_) | Event::Empty(_)), ) => { let output = helper.init_start_tag_deserializer( event, Some(&super::NS_XS), - b"assert", + b"keyref", true, )?; - match self.handle_assert(helper, values, fallback, output)? { + match self.handle_keyref(helper, values, fallback, output)? { ElementHandlerOutput::Break { event, allow_any } => { break (event, allow_any) } @@ -21302,11 +25025,261 @@ pub mod quick_xml_deserialize { fn finish( self, helper: &mut DeserializeHelper, - ) -> Result { + ) -> Result { Self::finish_state(helper, *self.state__) } } #[derive(Debug)] + pub struct AnyElementTypeDeserializer { + any_attribute: AnyAttributes, + id: Option, + namespace: Option, + not_namespace: Option, + process_contents: super::ProcessContentsType, + not_q_name: Option, + min_occurs: usize, + max_occurs: super::AllNniType, + annotation: Option, + state__: Box, + } + #[derive(Debug)] + enum AnyElementTypeDeserializerState { + Init__, + Annotation(Option<::Deserializer>), + Done__, + Unknown__, + } + impl AnyElementTypeDeserializer { + fn from_bytes_start( + helper: &mut DeserializeHelper, + bytes_start: &BytesStart<'_>, + ) -> Result { + let mut any_attribute = AnyAttributes::default(); + let mut id: Option = None; + let mut namespace: Option = None; + let mut not_namespace: Option = None; + let mut process_contents: Option = None; + let mut not_q_name: Option = None; + let mut min_occurs: Option = None; + let mut max_occurs: Option = None; + for attrib in helper.filter_xmlns_attributes(bytes_start) { + let attrib = attrib?; + if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"id") + ) { + helper.read_attrib(&mut id, b"id", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"namespace") + ) { + helper.read_attrib(&mut namespace, b"namespace", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"notNamespace") + ) { + helper.read_attrib(&mut not_namespace, b"notNamespace", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"processContents") + ) { + helper.read_attrib(&mut process_contents, b"processContents", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"notQName") + ) { + helper.read_attrib(&mut not_q_name, b"notQName", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"minOccurs") + ) { + helper.read_attrib(&mut min_occurs, b"minOccurs", &attrib.value)?; + } else if matches!( + helper.resolve_local_name(attrib.key, &super::NS_XS), + Some(b"maxOccurs") + ) { + helper.read_attrib(&mut max_occurs, b"maxOccurs", &attrib.value)?; + } else { + any_attribute.push(attrib)?; + } + } + Ok(Self { + any_attribute: any_attribute, + id: id, + namespace: namespace, + not_namespace: not_namespace, + process_contents: process_contents + .unwrap_or_else(super::AnyElementType::default_process_contents), + not_q_name: not_q_name, + min_occurs: min_occurs.unwrap_or_else(super::AnyElementType::default_min_occurs), + max_occurs: max_occurs.unwrap_or_else(super::AnyElementType::default_max_occurs), + annotation: None, + state__: Box::new(AnyElementTypeDeserializerState::Init__), + }) + } + fn finish_state( + &mut self, + helper: &mut DeserializeHelper, + state: AnyElementTypeDeserializerState, + ) -> Result<(), Error> { + use AnyElementTypeDeserializerState as S; + match state { + S::Annotation(Some(deserializer)) => { + self.store_annotation(deserializer.finish(helper)?)? + } + _ => (), + } + Ok(()) + } + fn store_annotation(&mut self, value: super::AnnotationElementType) -> Result<(), Error> { + if self.annotation.is_some() { + Err(ErrorKind::DuplicateElement(RawByteStr::from_slice( + b"annotation", + )))?; + } + self.annotation = Some(value); + Ok(()) + } + fn handle_annotation<'de>( + &mut self, + helper: &mut DeserializeHelper, + output: DeserializerOutput<'de, super::AnnotationElementType>, + fallback: &mut Option, + ) -> Result, Error> { + use AnyElementTypeDeserializerState as S; + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + if artifact.is_none() { + *self.state__ = S::Done__; + return Ok(ElementHandlerOutput::from_event(event, allow_any)); + } + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + match artifact { + DeserializerArtifact::None => unreachable!(), + DeserializerArtifact::Data(data) => { + self.store_annotation(data)?; + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + DeserializerArtifact::Deserializer(deserializer) => { + fallback.get_or_insert(S::Annotation(Some(deserializer))); + *self.state__ = S::Done__; + Ok(ElementHandlerOutput::from_event(event, allow_any)) + } + } + } + } + impl<'de> Deserializer<'de, super::AnyElementType> for AnyElementTypeDeserializer { + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnyElementType> { + helper.init_deserializer_from_start_event(event, Self::from_bytes_start) + } + fn next( + mut self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, super::AnyElementType> { + use AnyElementTypeDeserializerState as S; + let mut event = event; + let mut fallback = None; + let mut allow_any_element = false; + let (event, allow_any) = loop { + let state = replace(&mut *self.state__, S::Unknown__); + event = match (state, event) { + (S::Unknown__, _) => unreachable!(), + (S::Annotation(Some(deserializer)), event) => { + let output = deserializer.next(helper, event)?; + match self.handle_annotation(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (_, Event::End(_)) => { + if let Some(fallback) = fallback.take() { + self.finish_state(helper, fallback)?; + } + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::Data(self.finish(helper)?), + event: DeserializerEvent::None, + allow_any: false, + }); + } + (S::Init__, event) => { + fallback.get_or_insert(S::Init__); + *self.state__ = S::Annotation(None); + event + } + (S::Annotation(None), event @ (Event::Start(_) | Event::Empty(_))) => { + let output = helper.init_start_tag_deserializer( + event, + Some(&super::NS_XS), + b"annotation", + true, + )?; + match self.handle_annotation(helper, output, &mut fallback)? { + ElementHandlerOutput::Continue { event, allow_any } => { + allow_any_element = allow_any_element || allow_any; + event + } + ElementHandlerOutput::Break { event, allow_any } => { + break (event, allow_any) + } + } + } + (S::Done__, event) => { + *self.state__ = S::Done__; + break (DeserializerEvent::Continue(event), allow_any_element); + } + (state, event) => { + *self.state__ = state; + break (DeserializerEvent::Break(event), false); + } + } + }; + if let Some(fallback) = fallback { + *self.state__ = fallback; + } + Ok(DeserializerOutput { + artifact: DeserializerArtifact::Deserializer(self), + event, + allow_any, + }) + } + fn finish( + mut self, + helper: &mut DeserializeHelper, + ) -> Result { + let state = replace( + &mut *self.state__, + AnyElementTypeDeserializerState::Unknown__, + ); + self.finish_state(helper, state)?; + Ok(super::AnyElementType { + any_attribute: self.any_attribute, + id: self.id, + namespace: self.namespace, + not_namespace: self.not_namespace, + process_contents: self.process_contents, + not_q_name: self.not_q_name, + min_occurs: self.min_occurs, + max_occurs: self.max_occurs, + annotation: self.annotation, + }) + } + } + #[derive(Debug)] pub struct FieldElementTypeDeserializer { any_attribute: AnyAttributes, id: Option, From 137683db663dca180b2d99f86b05c4abf89de7c6 Mon Sep 17 00:00:00 2001 From: Bergmann89 Date: Mon, 22 Jun 2026 18:43:52 +0000 Subject: [PATCH 2/3] Implement support for custom generator code Types defined by the user using `CustomMeta` type variant may want to execute additional code, once the type is executed by the generator. This commits adds a new `CustomGenerator` trait that can be added to the `CustomMeta` and is executed by the generator when the type is executed. This allows users to instruct the generator to generate other dependent types, use the generator context to resolve type paths or to just execute any kind of custom code. --- xsd-parser/src/config/mod.rs | 11 +++ xsd-parser/src/models/code/ident_path.rs | 6 ++ xsd-parser/src/models/meta/custom.rs | 23 ++++- xsd-parser/src/models/meta/types.rs | 30 +++++++ xsd-parser/src/pipeline/generator/context.rs | 90 +++++++++++-------- xsd-parser/src/pipeline/generator/custom.rs | 43 +++++++++ .../src/pipeline/generator/data/custom.rs | 20 +++++ xsd-parser/src/pipeline/generator/data/mod.rs | 13 +-- .../src/pipeline/generator/data/type_.rs | 2 +- xsd-parser/src/pipeline/generator/mod.rs | 7 +- xsd-parser/src/pipeline/generator/state.rs | 13 ++- xsd-parser/src/pipeline/renderer/mod.rs | 28 +----- 12 files changed, 206 insertions(+), 80 deletions(-) create mode 100644 xsd-parser/src/pipeline/generator/data/custom.rs diff --git a/xsd-parser/src/config/mod.rs b/xsd-parser/src/config/mod.rs index dc2ee213..06d928c3 100644 --- a/xsd-parser/src/config/mod.rs +++ b/xsd-parser/src/config/mod.rs @@ -841,6 +841,17 @@ impl IdentQuadruple { } } +impl From for IdentQuadruple { + fn from(value: TypeIdent) -> Self { + Self { + ns: Some(NamespaceIdent::Id(value.ns)), + schema: Some(SchemaIdent::Id(value.schema)), + name: value.name.into(), + type_: value.type_, + } + } +} + impl From<(IdentType, X)> for IdentQuadruple where X: AsRef, diff --git a/xsd-parser/src/models/code/ident_path.rs b/xsd-parser/src/models/code/ident_path.rs index 5cb713c6..1ecddcc8 100644 --- a/xsd-parser/src/models/code/ident_path.rs +++ b/xsd-parser/src/models/code/ident_path.rs @@ -273,6 +273,12 @@ impl ToTokens for IdentPath { } impl ModulePath { + /// Creates a new [`ModulePath`] instance that represents the root module. + #[must_use] + pub fn root() -> Self { + Self::default() + } + /// Create a new [`ModulePath`] instance from the passed namespace id `ns` and the /// `types` information. /// diff --git a/xsd-parser/src/models/meta/custom.rs b/xsd-parser/src/models/meta/custom.rs index b08bfd22..9d891fe6 100644 --- a/xsd-parser/src/models/meta/custom.rs +++ b/xsd-parser/src/models/meta/custom.rs @@ -6,7 +6,9 @@ use std::hash::{Hash, Hasher}; use xsd_parser_types::misc::Namespace; use crate::config::NamespaceId; -use crate::pipeline::generator::{ValueGenerator, ValueGeneratorBox}; +use crate::pipeline::generator::{ + CustomGenerator, CustomGeneratorBox, ValueGenerator, ValueGeneratorBox, +}; /// Type information for a custom defined type. pub struct CustomMeta { @@ -24,6 +26,11 @@ pub struct CustomMeta { /// to suitable rust code. pub default: Option, + /// The generator step that is execute if a custom type is processed by the generator. + /// + /// This can be used to add custom code to the generated code for a custom type. + pub generator: Option, + /// The namespaces needed by this custom type. pub namespaces: Vec, @@ -42,6 +49,7 @@ impl CustomMeta { name: name.into(), include: None, default: None, + generator: None, namespaces: Vec::new(), allow_any: false, } @@ -80,6 +88,14 @@ impl CustomMeta { self } + /// Set the generator step that is execute if a custom type is processed by the generator. + #[must_use] + pub fn with_generator(mut self, x: X) -> Self { + self.generator = Some(Box::new(x)); + + self + } + /// Add a namespace that is needed by this custom type. /// /// The namespace may be added to the root element during serialization. @@ -120,6 +136,10 @@ impl Clone for CustomMeta { name: self.name.clone(), include: self.include.clone(), default: self.default.as_ref().map(|x| ValueGenerator::clone(&**x)), + generator: self + .generator + .as_ref() + .map(|x| CustomGenerator::clone(&**x)), namespaces: self.namespaces.clone(), allow_any: self.allow_any, } @@ -132,6 +152,7 @@ impl Debug for CustomMeta { .field("name", &self.name) .field("include", &self.include) .field("default", &self.default.is_some()) + .field("generator", &self.generator.is_some()) .field("namespaces", &self.namespaces) .field("allow_any", &self.allow_any) .finish() diff --git a/xsd-parser/src/models/meta/types.rs b/xsd-parser/src/models/meta/types.rs index 6e948363..2ddcc70c 100644 --- a/xsd-parser/src/models/meta/types.rs +++ b/xsd-parser/src/models/meta/types.rs @@ -1,8 +1,12 @@ use std::collections::BTreeMap; +use inflector::Inflector; +use quote::format_ident; use xsd_parser_types::misc::Namespace; use crate::models::{ + code::IdentPath, + data::PathData, schema::{xs::FormChoiceType, NamespaceId, SchemaId}, Name, Naming, TypeIdent, }; @@ -156,6 +160,32 @@ impl ModuleMeta { pub fn prefix(&self) -> Option<&Name> { self.prefix.as_ref().or(self.name.as_ref()) } + + /// Create a path to the contstant that represents the namespace of this module. + #[must_use] + pub fn make_ns_const(&self) -> Option { + self.namespace.as_ref()?; + let name = self.name().map_or_else( + || format!("UNNAMED_{}", self.namespace_id.0), + |name| name.as_str().to_screaming_snake_case(), + ); + let ident = format_ident!("NS_{name}"); + let path = IdentPath::from_parts([], ident); + + Some(PathData::from_path(path)) + } + + /// Create a path to the contstant that represents the prefix of this module. + #[must_use] + pub fn make_prefix_const(&self) -> Option { + self.namespace.as_ref()?; + let name = self.name()?; + let name = name.as_str().to_screaming_snake_case(); + let ident = format_ident!("PREFIX_{name}"); + let path = IdentPath::from_parts([], ident); + + Some(PathData::from_path(path)) + } } fn get_resolved_impl<'a>( diff --git a/xsd-parser/src/pipeline/generator/context.rs b/xsd-parser/src/pipeline/generator/context.rs index 8d9c02d7..989e8380 100644 --- a/xsd-parser/src/pipeline/generator/context.rs +++ b/xsd-parser/src/pipeline/generator/context.rs @@ -40,46 +40,25 @@ impl<'a, 'types> Context<'a, 'types> { self.namespaces.last() } - pub(super) fn new( - meta: &'a MetaData<'types>, - ident: &'a TypeIdent, - state: &'a mut State<'types>, - ) -> Self { - let reachable = state.loop_detection.get_reachable(&state.cache, ident); - - Self { - meta, - ident, - state, - reachable, - namespaces: Vec::new(), - } - } - - pub(super) fn current_module(&self) -> ModuleIdent { - ModuleIdent::new( - self.meta.types, - self.ident, - self.check_generator_flags(GeneratorFlags::USE_NAMESPACE_MODULES), - self.check_generator_flags(GeneratorFlags::USE_SCHEMA_MODULES), - ) - } - - pub(super) fn current_type_ref(&self) -> &TypeRef { - self.state.cache.get(self.ident).unwrap() - } - - pub(super) fn get_trait_infos(&mut self) -> &TraitInfos { - &self.state.trait_infos - } - - pub(super) fn get_or_create_type_ref(&mut self, ident: &TypeIdent) -> Result<&TypeRef, Error> { + /// Get the [`TypeRef`] for the passed `ident`, creating it (and scheduling + /// the type for generation) if it does not exist yet. + /// + /// # Errors + /// + /// Forwards the errors raised while creating the type reference. + pub fn get_or_create_type_ref(&mut self, ident: &TypeIdent) -> Result<&TypeRef, Error> { let type_ref = self.state.get_or_create_type_ref_mut(self.meta, ident)?; Ok(type_ref) } - pub(super) fn get_or_create_type_ref_for_value( + /// Like [`get_or_create_type_ref`](Self::get_or_create_type_ref), but also + /// marks the type as reachable by value if `by_value` is set. + /// + /// # Errors + /// + /// Forwards the errors raised while creating the type reference. + pub fn get_or_create_type_ref_for_value( &mut self, ident: &TypeIdent, by_value: bool, @@ -93,7 +72,14 @@ impl<'a, 'types> Context<'a, 'types> { Ok(type_ref) } - pub(super) fn get_or_create_type_ref_for_element( + /// Like [`get_or_create_type_ref`](Self::get_or_create_type_ref), but for an + /// element. Returns the [`TypeRef`] together with a flag that indicates if + /// the type needs to be boxed. + /// + /// # Errors + /// + /// Forwards the errors raised while creating the type reference. + pub fn get_or_create_type_ref_for_element( &mut self, ident: &TypeIdent, by_value: bool, @@ -108,6 +94,38 @@ impl<'a, 'types> Context<'a, 'types> { Ok((type_ref, boxed)) } + pub(super) fn new( + meta: &'a MetaData<'types>, + ident: &'a TypeIdent, + state: &'a mut State<'types>, + ) -> Self { + let reachable = state.loop_detection.get_reachable(&state.cache, ident); + + Self { + meta, + ident, + state, + reachable, + namespaces: Vec::new(), + } + } + + pub(super) fn current_module(&self) -> ModuleIdent { + ModuleIdent::new( + self.meta.types, + self.ident, + self.check_generator_flags(GeneratorFlags::USE_NAMESPACE_MODULES), + self.check_generator_flags(GeneratorFlags::USE_SCHEMA_MODULES), + ) + } + + pub(super) fn current_type_ref(&self) -> &TypeRef { + self.state.cache.get(self.ident).unwrap() + } + + pub(super) fn get_trait_infos(&mut self) -> &TraitInfos { + &self.state.trait_infos + } pub(super) fn make_trait_impls(&mut self) -> Result, Error> { let ident = self.ident.clone(); let current_module = self.current_module(); diff --git a/xsd-parser/src/pipeline/generator/custom.rs b/xsd-parser/src/pipeline/generator/custom.rs index 01953c1f..e763cb41 100644 --- a/xsd-parser/src/pipeline/generator/custom.rs +++ b/xsd-parser/src/pipeline/generator/custom.rs @@ -1,9 +1,52 @@ use std::fmt::{Debug, Formatter, Result as FmtResult}; +use crate::models::meta::CustomMeta; use crate::pipeline::renderer::ValueRenderer; use super::{Context, Error}; +/// Boxed version of [`CustomGenerator`]. +pub type CustomGeneratorBox = Box; + +impl Debug for CustomGeneratorBox { + fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { + f.debug_struct("CustomGeneratorBox").finish() + } +} + +/// Implements a custom generator step that is execute if a custom type is +/// processed by the generator. +pub trait CustomGenerator: 'static { + /// Execute this generator step. + fn exec<'types>( + &self, + ctx: &mut Context<'_, 'types>, + meta: &'types CustomMeta, + ) -> Result<(), Error>; + + /// Clone this instance and return it as a box. + fn clone(&self) -> Box; +} + +impl CustomGenerator for X +where + X: for<'types> Fn(&mut Context<'_, 'types>, &'types CustomMeta) -> Result<(), Error> + + Clone + + 'static, +{ + fn exec<'types>( + &self, + ctx: &mut Context<'_, 'types>, + meta: &'types CustomMeta, + ) -> Result<(), Error> { + (*self)(ctx, meta) + } + + fn clone(&self) -> Box { + Box::new(self.clone()) + } +} + /// Boxed version of [`ValueGenerator`]. pub type ValueGeneratorBox = Box; diff --git a/xsd-parser/src/pipeline/generator/data/custom.rs b/xsd-parser/src/pipeline/generator/data/custom.rs new file mode 100644 index 00000000..939974ef --- /dev/null +++ b/xsd-parser/src/pipeline/generator/data/custom.rs @@ -0,0 +1,20 @@ +use std::borrow::Cow; + +use crate::models::{data::CustomData, meta::CustomMeta}; + +use super::super::{Context, Error}; + +impl<'types> CustomData<'types> { + pub(super) fn new( + meta: &'types CustomMeta, + ctx: &mut Context<'_, 'types>, + ) -> Result { + if let Some(generator) = &meta.generator { + generator.exec(ctx, meta)?; + } + + Ok(Self { + meta: Cow::Borrowed(meta), + }) + } +} diff --git a/xsd-parser/src/pipeline/generator/data/mod.rs b/xsd-parser/src/pipeline/generator/data/mod.rs index 9aed97a7..f3810ece 100644 --- a/xsd-parser/src/pipeline/generator/data/mod.rs +++ b/xsd-parser/src/pipeline/generator/data/mod.rs @@ -1,5 +1,6 @@ mod complex; mod constrains; +mod custom; mod dynamic; mod enumeration; mod reference; @@ -13,8 +14,8 @@ use std::mem::swap; use crate::config::GeneratorFlags; use crate::models::{ code::IdentPath, - data::{BuildInData, CustomData, PathData}, - meta::{BuildInMeta, CustomMeta}, + data::{BuildInData, PathData}, + meta::BuildInMeta, }; use super::Context; @@ -27,14 +28,6 @@ impl<'types> BuildInData<'types> { } } -impl<'types> CustomData<'types> { - fn new(meta: &'types CustomMeta) -> Self { - Self { - meta: Cow::Borrowed(meta), - } - } -} - impl Context<'_, '_> { fn path_data_nillable(&self, is_mixed: bool, mut path: PathData) -> PathData { if !is_mixed { diff --git a/xsd-parser/src/pipeline/generator/data/type_.rs b/xsd-parser/src/pipeline/generator/data/type_.rs index b3f739ba..ff97a5b6 100644 --- a/xsd-parser/src/pipeline/generator/data/type_.rs +++ b/xsd-parser/src/pipeline/generator/data/type_.rs @@ -21,7 +21,7 @@ impl<'types> DataType<'types> { let derive = ConfigValue::Default; let variant = match &meta.variant { M::BuildIn(x) => D::BuildIn(BuildInData::new(x)), - M::Custom(x) => D::Custom(CustomData::new(x)), + M::Custom(x) => D::Custom(CustomData::new(x, ctx)?), M::Union(x) => D::Union(UnionData::new(x, ctx)?), M::Dynamic(x) => D::Dynamic(DynamicData::new(x, ctx)?), M::Reference(x) => D::Reference(ReferenceData::new(x, ctx)?), diff --git a/xsd-parser/src/pipeline/generator/mod.rs b/xsd-parser/src/pipeline/generator/mod.rs index 3a3b4d39..7d63f29a 100644 --- a/xsd-parser/src/pipeline/generator/mod.rs +++ b/xsd-parser/src/pipeline/generator/mod.rs @@ -44,11 +44,14 @@ use crate::models::{ use crate::traits::Naming; pub use self::context::Context; -pub use self::custom::{ValueGenerator, ValueGeneratorBox, ValueGeneratorMode}; +pub use self::custom::{ + CustomGenerator, CustomGeneratorBox, ValueGenerator, ValueGeneratorBox, ValueGeneratorMode, +}; pub use self::error::Error; pub use self::meta::MetaData; +pub use self::state::TypeRef; -use self::state::{LoopDetection, PendingType, State, TraitInfos, TypeRef}; +use self::state::{LoopDetection, PendingType, State, TraitInfos}; /// Configurable Rust code generator for schema-derived type information. /// diff --git a/xsd-parser/src/pipeline/generator/state.rs b/xsd-parser/src/pipeline/generator/state.rs index 3699e0ab..ebf76c7f 100644 --- a/xsd-parser/src/pipeline/generator/state.rs +++ b/xsd-parser/src/pipeline/generator/state.rs @@ -30,11 +30,18 @@ pub(super) struct PendingType<'types> { /* TypeRef */ +/// Reference to a type that is processed by the generator. +/// +/// It mainly carries the resolved [`PathData`] of the type, which can be used +/// to reference the type from the generated code. #[derive(Debug)] -pub(super) struct TypeRef { - pub id: usize, +pub struct TypeRef { + pub(super) id: usize, + + /// Resolved path of the type. pub path: PathData, - pub reachable: BitSet, + + pub(super) reachable: BitSet, } impl TypeRef { diff --git a/xsd-parser/src/pipeline/renderer/mod.rs b/xsd-parser/src/pipeline/renderer/mod.rs index 6cc74449..e579139f 100644 --- a/xsd-parser/src/pipeline/renderer/mod.rs +++ b/xsd-parser/src/pipeline/renderer/mod.rs @@ -27,15 +27,13 @@ mod steps; use std::fmt::{Debug, Display}; use std::str::FromStr; -use inflector::Inflector; use proc_macro2::TokenStream; use quote::{format_ident, quote}; use crate::config::{DynTypeTraits, RendererFlags}; use crate::models::{ code::{IdentPath, Module}, - data::{DataTypeVariant, DataTypes, Occurs, PathData}, - meta::ModuleMeta, + data::{DataTypeVariant, DataTypes, Occurs}, }; pub use self::context::{Context, ValueKey, Values}; @@ -325,30 +323,6 @@ impl RenderStepType { } } -impl ModuleMeta { - pub(super) fn make_ns_const(&self) -> Option { - self.namespace.as_ref()?; - let name = self.name().map_or_else( - || format!("UNNAMED_{}", self.namespace_id.0), - |name| name.as_str().to_screaming_snake_case(), - ); - let ident = format_ident!("NS_{name}"); - let path = IdentPath::from_parts([], ident); - - Some(PathData::from_path(path)) - } - - pub(super) fn make_prefix_const(&self) -> Option { - self.namespace.as_ref()?; - let name = self.name()?; - let name = name.as_str().to_screaming_snake_case(); - let ident = format_ident!("PREFIX_{name}"); - let path = IdentPath::from_parts([], ident); - - Some(PathData::from_path(path)) - } -} - impl Occurs { /// Wrapped the passed type `ident` into a suitable rust type depending on /// the occurrence and the need of indirection (boxing). From 95ecfbec00f7b690740f8b3a1a0c5f4ddaee8153 Mon Sep 17 00:00:00 2001 From: Bergmann89 Date: Mon, 22 Jun 2026 18:53:42 +0000 Subject: [PATCH 3/3] Fix and simplify the `vsme` example --- Cargo.lock | 2 + examples/README.md | 1 + examples/vsme/Cargo.toml | 2 + examples/vsme/README.md | 51 +++++++ examples/vsme/build.rs | 287 +++++++++++++++++++++++++++++++++++++- examples/vsme/src/item.rs | 272 ++++++++++++++++++++++++++++++++++++ examples/vsme/src/main.rs | 19 ++- 7 files changed, 625 insertions(+), 9 deletions(-) create mode 100644 examples/vsme/README.md create mode 100644 examples/vsme/src/item.rs diff --git a/Cargo.lock b/Cargo.lock index 22f1b4ce..85cd49fd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2357,6 +2357,8 @@ version = "0.1.0" dependencies = [ "anyhow", "num", + "proc-macro2", + "quote", "xsd-parser", "xsd-parser-types", ] diff --git a/examples/README.md b/examples/README.md index 61efef49..2b8e3916 100644 --- a/examples/README.md +++ b/examples/README.md @@ -4,3 +4,4 @@ Examples contained in this directory: - [`read_write`](./read_write/README.md) - Generates code from a simple schema using a build script and then uses the generated code to deserialize and serialize a XML file during runtime. - [`bpmn`](./bpmn/README.md) - Example that generates code for BPMN 2.0 and loads a diagram file. +- [`vsme`](./vsme/README.md) - Example that generates code for the XBRL based VSME taxonomy. It shows how a custom render step can be used to collapse the huge `xbrli:item` substitution group into a few `ItemWrapper` based types instead of generating one type per element. diff --git a/examples/vsme/Cargo.toml b/examples/vsme/Cargo.toml index f7c11387..c536698e 100644 --- a/examples/vsme/Cargo.toml +++ b/examples/vsme/Cargo.toml @@ -16,6 +16,8 @@ xsd-parser-types = { workspace = true, features = [ "quick-xml" ] } [build-dependencies] anyhow = { workspace = true } +proc-macro2 = { workspace = true } +quote = { workspace = true } xsd-parser = { workspace = true } [lints] diff --git a/examples/vsme/README.md b/examples/vsme/README.md new file mode 100644 index 00000000..9e8e408e --- /dev/null +++ b/examples/vsme/README.md @@ -0,0 +1,51 @@ +# VSME example + +This example generates and uses the code for the XBRL based [VSME](https://xbrl.efrag.org/) taxonomy (the *Voluntary standard for non-listed Small- and Medium-sized Enterprises*). + +XBRL instance documents store their facts as members of the `xbrli:item` substitution group. The VSME taxonomy defines **thousands** of such facts, but most of them share the same underlying type and only differ by their XML tag name (e.g. `vsme:Assets`, `vsme:AverageNumberOfAnnualTrainingHoursPerMaleEmployee`, ...). Generating a dedicated Rust type (and `enum` variant) for every single element would produce a huge, unwieldy amount of code. + +## What this example shows + +Instead of generating one type per element, the [build script](build.rs) installs a custom [`RenderStep`] (`FixItemType`) that: + +1. Looks up the content of the `xbrli:item` element (a big `xs:choice`). +2. Groups all element variants of the choice by their type and removes them from the choice. +3. Adds a single group element per type that references a synthetic `XxxWrapped` custom type. +4. Emits a type definition and an [`ItemTags`](src/item.rs) implementation for each of those wrapper types: + + ```rust,ignore + pub type AmountOfEmissionToAirWrapped = + crate::item::ItemWrapper; + + pub struct AmountOfEmissionToAirWrappedTags; + + impl crate::item::ItemTags for AmountOfEmissionToAirWrappedTags { + fn tags() -> &'static [crate::item::ItemTag] { + static TAGS: [crate::item::ItemTag; 78] = [ + crate::item::ItemTag { + tag: "vsme:Assets", + name: "Assets", + namespace: NS_VSME, + }, + /* ... */ + ]; + + &TAGS + } + } + ``` + +The [`ItemWrapper`](src/item.rs) type defined in this example provides the runtime support for this. It wraps the shared inner type and implements a `Serializer` and `Deserializer` that: + +- on **deserialization**, only accept an element whose namespace-resolved tag is part of the associated `ItemTags` (so a document may use any prefix for the namespace), and remember which tag was used; and +- on **serialization**, write the value back using that remembered tag. + +This way a few hundred elements collapse into just a handful of generated types while the round-trip still preserves the exact XML tag of every fact. + +## Running + +```sh +cargo run -p vsme +``` + +This deserializes [`xml/example.xml`](xml/example.xml), prints the parsed object and serializes it back to XML. diff --git a/examples/vsme/build.rs b/examples/vsme/build.rs index da870451..ac2b293c 100644 --- a/examples/vsme/build.rs +++ b/examples/vsme/build.rs @@ -1,15 +1,35 @@ //! This is a build script to generate the code for the `vsme` schema. +use std::cell::RefCell; +use std::collections::BTreeMap; use std::env::var; use std::fs::{create_dir_all, remove_dir_all}; use std::path::PathBuf; +use std::rc::Rc; use anyhow::{Context, Error}; +use proc_macro2::TokenStream; +use quote::{format_ident, quote}; +use xsd_parser::models::data::TagName; use xsd_parser::{ - config::{GeneratorFlags, InterpreterFlags, OptimizerFlags, Schema}, - generate_modules, - models::{meta::MetaType, Naming}, + config::{GeneratorFlags, IdentQuadruple, InterpreterFlags, OptimizerFlags, Schema}, + exec_generator_with_ident_cache, exec_interpreter_with_ident_cache, exec_optimizer, + exec_parser, exec_render, + models::{ + code::{Module, ModulePath}, + data::PathData, + meta::{ + CustomMeta, ElementMeta, ElementMetaVariant, ElementMode, MetaType, MetaTypeVariant, + MetaTypes, + }, + schema::{xs::FormChoiceType, Schemas}, + ElementIdent, IdentType, Naming, + }, + pipeline::{ + generator::{Context as GeneratorContext, Error as GeneratorError}, + renderer::{MetaData, RenderStep, RenderStepType}, + }, traits::{NameBuilder as NameBuilderTrait, Naming as NamingTrait}, Config, Name, TypeIdent, }; @@ -26,16 +46,33 @@ fn main() -> Result<(), Error> { .context("Missing or invalid schema file!")?; // This is almost the starting point defined in the main `[README.md]`. + let fix_item_type = FixItemType::default(); let config = Config::default() .with_schema(Schema::File(schema_file)) + .with_generate([(IdentType::Element, "xbrli:xbrl")]) .with_interpreter_flags(InterpreterFlags::all() - InterpreterFlags::WITH_NUM_BIG_INT) .with_optimizer_flags(OptimizerFlags::all()) .with_generator_flags(GeneratorFlags::all() - GeneratorFlags::ADVANCED_ENUMS) .with_naming(CustomNaming::default()) - .with_quick_xml(); + .with_quick_xml() + .with_render_step(fix_item_type.clone()); - // Generate the code based on the configuration above. - let modules = generate_modules(config)?; + // Generate the code based on the configuration above. We run the pipeline + // manually instead of using `generate_modules`, because we need to inject + // the `FixItemType` transformation in between the optimizer and the + // generator. + let schemas = exec_parser(config.parser)?; + let (meta_types, ident_cache) = + exec_interpreter_with_ident_cache(config.interpreter, &schemas)?; + let meta_types = exec_optimizer(config.optimizer, meta_types)?; + let meta_types = fix_item_type.prepare_types(meta_types, &schemas)?; + let data_types = exec_generator_with_ident_cache( + config.generator, + &schemas, + Some(&ident_cache), + &meta_types, + )?; + let modules = exec_render(config.renderer, &data_types)?; // Write the generated code to the module directory specified by Cargo. let target_dir = cargo_dir.join("src/schema"); @@ -99,3 +136,241 @@ impl NamingTrait for CustomNaming { format!("{s}_attr") } } + +/// Render step (and meta type transformation) that collapses the many concrete +/// element variants of the `xbrli:item` choice into a few `ItemWrapper` based +/// types. +/// +/// XBRL defines hundreds of facts as members of the `xbrli:item` substitution +/// group. Most of them share the same (Rust) type and only differ by their XML +/// tag name. Generating a dedicated enum variant for each of them would be +/// wasteful, so we instead group the elements by their type and represent each +/// group with a single [`ItemWrapper`](crate::item::ItemWrapper) that keeps the +/// list of supported tags around at runtime. +#[derive(Default, Debug, Clone)] +struct FixItemType(Rc>>); + +/// A [`WrappedType`] that is shared between the custom generator step (which +/// resolves and stores the path to the concrete type) and the render step +/// (which uses that information to render the actual code). +type SharedWrapped = Rc>; + +/// Information about a single synthetic `XxxWrapped` type. +#[derive(Debug)] +struct WrappedType { + /// Identifier of the synthetic `XxxWrapped` custom type. + ident: TypeIdent, + + /// Identifier of the concrete type that is shared by all elements + /// represented by this wrapper. + type_: TypeIdent, + + /// XML tags of all elements that are represented by this wrapper. + tags: Vec, + + /// Path to the concrete type relative to the root module (e.g. + /// `vsme :: AmountOfEmissionToAirDyn`). This is resolved and stored by the + /// custom generator step (see [`WrappedType::resolve`]). + target_type: Option, +} + +/// Information about a single XML tag represented by an [`ItemWrapper`]. +#[derive(Debug)] +struct TagInfo { + /// Identifier (namespace and local name) of the element. + ident: ElementIdent, + + /// Form of the element, used to decide whether the tag needs a namespace + /// prefix. + form: FormChoiceType, +} + +impl FixItemType { + fn prepare_types(&self, mut types: MetaTypes, schemas: &Schemas) -> Result { + let item_ident = IdentQuadruple::from((IdentType::Element, "xbrli:item")); + let item_ident = item_ident + .resolve(schemas) + .context("Unable to resolve `xbrli:item` element")?; + + let item_ty = types + .items + .get(&item_ident) + .context("Unknown element: `xbrli:item`")?; + let MetaTypeVariant::ComplexType(meta) = &item_ty.variant else { + anyhow::bail!("`xbrli:item` is not a complex type") + }; + let content_ident = meta + .content + .clone() + .context("`xbrli:item` is missing a content type")?; + + let content_ty = types + .items + .get_mut(&content_ident) + .context("Unknown content type for `xbrli:item`")?; + let MetaTypeVariant::Choice(meta) = &mut content_ty.variant else { + anyhow::bail!("Content type of `xbrli:item` is not a choice") + }; + + // Group all concrete element variants of the choice by their type and + // remove them from the choice. We use a `BTreeMap` to get a stable + // order of the generated types. For each removed element we remember the + // information needed to reconstruct its XML tag name later on. + let mut map = BTreeMap::>::new(); + meta.elements.0.retain(|el| { + let ElementMetaVariant::Type { + type_, + mode: ElementMode::Element, + } = &el.variant + else { + return true; + }; + + map.entry(type_.clone()) + .or_default() + .push((el.ident.clone(), el.form)); + + false + }); + + // Add one group element per type that references the synthetic wrapper + // type instead of the removed elements. + let mut pending = Vec::new(); + for (concrete, tags) in map { + let mut wrapped = concrete.clone(); + wrapped.name = Name::new_named(format!("{}Wrapped", wrapped.name)); + + meta.elements.0.push(ElementMeta::new( + concrete.to_property_ident(), + wrapped.clone(), + ElementMode::Group, + FormChoiceType::Unqualified, + )); + + pending.push((wrapped, concrete, tags)); + } + + // `meta` (and therefore the mutable borrow of `types`) is not used + // beyond this point, so we can now resolve the tag names and register + // the synthetic wrapper types as custom types. + for (ident, type_, tags) in pending { + let tags = tags + .into_iter() + .map(|(ident, form)| TagInfo::new(ident, form)) + .collect::>(); + + let wrapped = Rc::new(RefCell::new(WrappedType { + ident: ident.clone(), + type_, + tags, + target_type: None, + })); + self.0.borrow_mut().push(wrapped.clone()); + + // The custom generator step resolves the path to the concrete type + // during code generation and stores it in the (shared) wrapper. + let custom = CustomMeta::new(ident.name.clone()).with_generator( + move |ctx: &mut GeneratorContext<'_, '_>, _: &CustomMeta| { + wrapped.borrow_mut().resolve(ctx) + }, + ); + types + .items + .insert(ident, MetaType::new(MetaTypeVariant::Custom(custom))); + } + + Ok(types) + } +} + +impl RenderStep for FixItemType { + fn render_step_type(&self) -> RenderStepType { + RenderStepType::ExtraTypes + } + + fn finish(&mut self, meta: &MetaData<'_>, module: &mut Module) { + for wrapped in self.0.borrow().iter() { + wrapped.borrow().render(meta, module); + } + } +} + +impl WrappedType { + /// Resolve the path to the concrete type (relative to the root module) and + /// store it. This is called by the custom generator step during code + /// generation, where the path information is available. Requesting the type + /// reference also makes sure the concrete type is actually generated. + fn resolve(&mut self, ctx: &mut GeneratorContext<'_, '_>) -> Result<(), GeneratorError> { + let target_type = ctx.get_or_create_type_ref(&self.type_)?.path.clone(); + + self.target_type = Some(target_type); + + Ok(()) + } + + /// Render the type definition and the `ItemTags` implementation for this + /// wrapper into the given `module`. + fn render(&self, meta: &MetaData<'_>, module: &mut Module) { + let wrapped_ident = format_ident!("{}", self.ident.name.as_str()); + let tags_ident = format_ident!("{}Tags", self.ident.name.as_str()); + + let target_type = self + .target_type + .as_ref() + .expect("the concrete type path is resolved by the custom generator step") + .resolve_relative_to(&ModulePath::root()); + + let tags = self.tags.iter().map(|tag| tag.render(meta)); + let count = self.tags.len(); + + module.append(quote! { + pub type #wrapped_ident = crate::item::ItemWrapper<#target_type, #tags_ident>; + + #[derive(Debug)] + pub struct #tags_ident; + + impl crate::item::ItemTags for #tags_ident { + fn tags() -> &'static [crate::item::ItemTag] { + static TAGS: [crate::item::ItemTag; #count] = [ #( #tags ),* ]; + + &TAGS + } + } + }); + } +} + +impl TagInfo { + /// Resolve the information for a single tag from the passed element data. + fn new(ident: ElementIdent, form: FormChoiceType) -> Self { + Self { ident, form } + } + + /// Render this tag as a `crate::item::ItemTag` value. + fn render(&self, meta: &MetaData<'_>) -> TokenStream { + let Self { ident, form } = self; + + let types = meta.types.meta.types; + let module = types + .modules + .get(&ident.ns) + .expect("the module for the tag's namespace exists"); + + // Reuse the namespace constant generated next to the schema types + // (e.g. `NS_VSME`) instead of repeating the namespace URI. + let namespace = module + .make_ns_const() + .expect("the tag has a namespace") + .resolve_relative_to(&ModulePath::root()); + let tag = TagName::new(types, ident.ns, &ident.name, *form).get(true); + let name = ident.name.as_str(); + + quote! { + crate::item::ItemTag { + tag: #tag, + name: #name, + namespace: #namespace, + } + } + } +} diff --git a/examples/vsme/src/item.rs b/examples/vsme/src/item.rs new file mode 100644 index 00000000..edbd669f --- /dev/null +++ b/examples/vsme/src/item.rs @@ -0,0 +1,272 @@ +//! Runtime support type for the `xbrli:item` substitution group. +//! +//! XBRL declares hundreds of facts as members of the `xbrli:item` substitution +//! group. Most of them share the same type and only differ by their XML tag +//! name. Instead of generating one dedicated type (and enum variant) per +//! element, the `vsme` build script groups the elements by their type and +//! represents each group with a single [`ItemWrapper`]. +//! +//! An [`ItemWrapper`] wraps the shared inner type `T` and remembers which of the +//! supported tags (provided by the [`ItemTags`] implementation `TTags`) the +//! value was deserialized from, so it can be serialized back using the correct +//! tag name. + +use std::fmt::{Debug, Formatter, Result as FmtResult}; +use std::marker::PhantomData; +use std::ops::{Deref, DerefMut}; + +use xsd_parser_types::{ + misc::Namespace, + quick_xml::{ + DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent, + DeserializerOutput, DeserializerResult, Error, Event, ResolveResult, WithDeserializer, + WithSerializer, + }, +}; + +/// Wraps a value of type `T` that can be represented by one of multiple XML tags +/// at runtime. +/// +/// The set of supported tags is provided by the [`ItemTags`] implementation +/// `TTags`. The [`index`](Self::index) stores which of those tags the value +/// actually uses, so it can be serialized back to the original tag name. +pub(crate) struct ItemWrapper +where + TTags: ItemTags, +{ + index: usize, + pub inner: T, + _tags: PhantomData, +} + +impl ItemWrapper +where + TTags: ItemTags, +{ + /// Create a new [`ItemWrapper`] for the tag with the passed `index`. + #[must_use] + pub(crate) fn new(index: usize, inner: T) -> Self { + Self { + index, + inner, + _tags: PhantomData, + } + } + + /// Get the (qualified) XML tag name this value uses. + #[must_use] + pub(crate) fn tag(&self) -> &'static ItemTag { + &TTags::tags()[self.index] + } +} + +impl Deref for ItemWrapper +where + TTags: ItemTags, +{ + type Target = T; + + fn deref(&self) -> &Self::Target { + &self.inner + } +} + +impl DerefMut for ItemWrapper +where + TTags: ItemTags, +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} + +impl Debug for ItemWrapper +where + T: Debug, + TTags: ItemTags, +{ + fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { + f.debug_struct("ItemWrapper") + .field("tag", self.tag()) + .field("inner", &self.inner) + .finish_non_exhaustive() + } +} + +/// A single XML tag that is supported by an [`ItemWrapper`]. +#[derive(Debug)] +pub(crate) struct ItemTag { + /// Tag name to be used for this element. + pub tag: &'static str, + + /// Local name of the tag (without any namespace prefix). + pub name: &'static str, + + /// Namespace of the tag (`None` if the tag has no namespace). + /// + /// This is usually initialized from one of the namespace constants + /// generated next to the schema types (e.g. `NS_VSME`). It is used together + /// with [`name`](Self::name) to match incoming elements in a namespace + /// aware way during deserialization. + pub namespace: Namespace, +} + +/// Provides the list of XML tags that are supported by an [`ItemWrapper`]. +pub(crate) trait ItemTags { + /// The XML tags that are represented by the [`ItemWrapper`]. + fn tags() -> &'static [ItemTag]; +} + +/* Serialize */ + +impl WithSerializer for ItemWrapper +where + T: WithSerializer, + TTags: ItemTags, +{ + type Serializer<'x> + = T::Serializer<'x> + where + Self: 'x; + + fn serializer<'ser>( + &'ser self, + name: Option<&'ser str>, + is_root: bool, + ) -> Result, Error> { + // The actual XML tag is determined by the wrapped value, not by the name + // passed in by the parent (which would just be the name of the grouped + // Rust type). + let _name = name; + + self.inner.serializer(Some(self.tag().tag), is_root) + } +} + +/* Deserialize */ + +impl WithDeserializer for ItemWrapper +where + T: WithDeserializer, + TTags: ItemTags, +{ + type Deserializer = ItemWrapperDeserializer; +} + +/// Deserializer for the [`ItemWrapper`] type. +pub(crate) struct ItemWrapperDeserializer +where + T: WithDeserializer, +{ + index: usize, + inner: T::Deserializer, + _tags: PhantomData, +} + +impl Debug for ItemWrapperDeserializer +where + T: WithDeserializer, +{ + fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { + f.debug_struct("ItemWrapperDeserializer") + .field("index", &self.index) + .field("inner", &self.inner) + .finish() + } +} + +impl<'de, T, TTags> Deserializer<'de, ItemWrapper> for ItemWrapperDeserializer +where + T: WithDeserializer, + TTags: ItemTags, +{ + fn init( + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, ItemWrapper> { + // Find the tag index of the current element. The lookup is namespace + // aware (so a document is free to use a different prefix than the + // schema): we resolve the element's namespace only once (resolving is + // not free) and then search the tag list using the resolved namespace + // and local name. If the element is not one of the supported tags, we + // do not handle it and return the event back to the caller (so the next + // variant of the choice can try it). + let index = match &event { + Event::Start(bytes) | Event::Empty(bytes) => { + let (resolved, local) = helper.resolve(bytes.name(), true); + let local = local.into_inner(); + let namespace = match resolved { + ResolveResult::Bound(namespace) => Some(namespace.0), + _ => None, + }; + + TTags::tags().iter().position(|tag| { + tag.name.as_bytes() == local + && namespace.is_none_or(|ns| ns == tag.namespace.as_ref()) + }) + } + _ => None, + }; + + let Some(index) = index else { + return Ok(DeserializerOutput { + artifact: DeserializerArtifact::None, + event: DeserializerEvent::Continue(event), + allow_any: false, + }); + }; + + let output = ::Deserializer::init(helper, event)?; + + Ok(map_output(index, output)) + } + + fn next( + self, + helper: &mut DeserializeHelper, + event: Event<'de>, + ) -> DeserializerResult<'de, ItemWrapper> { + let index = self.index; + let output = self.inner.next(helper, event)?; + + Ok(map_output(index, output)) + } + + fn finish(self, helper: &mut DeserializeHelper) -> Result, Error> { + let inner = self.inner.finish(helper)?; + + Ok(ItemWrapper::new(self.index, inner)) + } +} + +/// Map the [`DeserializerOutput`] of the wrapped type `T` to a suitable output +/// for the [`ItemWrapper`], keeping track of the resolved tag `index`. +fn map_output( + index: usize, + output: DeserializerOutput<'_, T>, +) -> DeserializerOutput<'_, ItemWrapper> +where + T: WithDeserializer, + TTags: ItemTags, +{ + let DeserializerOutput { + artifact, + event, + allow_any, + } = output; + + let artifact = artifact.map( + |inner| ItemWrapper::new(index, inner), + |inner| ItemWrapperDeserializer { + index, + inner, + _tags: PhantomData, + }, + ); + + DeserializerOutput { + artifact, + event, + allow_any, + } +} diff --git a/examples/vsme/src/main.rs b/examples/vsme/src/main.rs index a4504234..c0e71e6d 100644 --- a/examples/vsme/src/main.rs +++ b/examples/vsme/src/main.rs @@ -1,18 +1,22 @@ //! Example how to generate code for the VSME schema and use it to deserialize an XML file. -#[allow(clippy::all, dead_code, missing_docs, unreachable_pub, unused)] +#[allow(clippy::all, clippy::pedantic, clippy::nursery, dead_code, missing_docs, unreachable_pub, unused)] #[rustfmt::skip] mod schema; +mod item; use std::fs::File; use std::io::BufReader; use anyhow::{Context, Error}; -use xsd_parser_types::quick_xml::{DeserializeSync, IoReader, XmlReader}; +use xsd_parser_types::quick_xml::{DeserializeSync, IoReader, SerializeSync, Writer, XmlReader}; -use schema::xbrli::Xbrl; +use self::schema::xbrli::Xbrl; fn main() -> Result<(), Error> { + // Deserialize the example XBRL instance document. The facts (members of the + // `xbrli:item` substitution group) are deserialized into `ItemWrapper` + // values that remember their original XML tag name (see `item.rs`). let input_file = File::open("xml/example.xml").context("Unable to open example XML for reading")?; let reader = BufReader::new(input_file); @@ -21,5 +25,14 @@ fn main() -> Result<(), Error> { println!("{obj:#?}"); + // Serialize the document back to XML. This round-trip shows that the + // `ItemWrapper` based facts are written back using their original tag name. + let mut buffer = Vec::new(); + let mut writer = Writer::new_with_indent(&mut buffer, b' ', 2); + obj.serialize("xbrli:xbrl", &mut writer) + .context("Error while serializing XML content")?; + + println!("\n{}", String::from_utf8(buffer)?); + Ok(()) }