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(()) } 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..06d928c3 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. @@ -823,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/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/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/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/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/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..2ddcc70c 100644 --- a/xsd-parser/src/models/meta/types.rs +++ b/xsd-parser/src/models/meta/types.rs @@ -1,9 +1,13 @@ use std::collections::BTreeMap; +use inflector::Inflector; +use quote::format_ident; use xsd_parser_types::misc::Namespace; use crate::models::{ - schema::{NamespaceId, SchemaId}, + code::IdentPath, + data::PathData, + schema::{xs::FormChoiceType, NamespaceId, SchemaId}, Name, Naming, TypeIdent, }; use crate::traits::{NameBuilder as NameBuilderTrait, Naming as NamingTrait}; @@ -70,6 +74,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. /// @@ -146,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/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..989e8380 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, @@ -40,48 +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 - .get_or_insert_with(|| TraitInfos::new(self.meta.types)) - } - - 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, @@ -95,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, @@ -110,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(); @@ -118,7 +134,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 +149,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/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/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/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/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/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/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..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. /// @@ -103,7 +106,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 +122,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 +447,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..ebf76c7f 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, } @@ -29,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 { @@ -61,67 +69,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 +118,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/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). 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,