WIP

Author: Bergmann89

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,
 }
 

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<IdentQuadruple>,
+
     /// 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),

xsd-parser/src/config/mod.rs

@@ -507,6 +507,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<I>(mut self, types: I) -> Self
+    where
+        I: IntoIterator,
+        I::Item: Into<IdentQuadruple>,
+    {
+        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<T>(mut self, ident: T) -> Self
+    where
+        T: Into<IdentQuadruple>,
+    {
+        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.

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 {
@@ -384,7 +389,11 @@ pub fn exec_generator_with_ident_cache<'types>(
         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,
     );
 

xsd-parser/src/meta_types_printer.rs

@@ -191,12 +191,11 @@ 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}={value:?}");
                 }
 
                 s.level -= 2;

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() {

xsd-parser/src/models/meta/attribute.rs

@@ -192,7 +192,7 @@ impl DerefMut for AttributesMeta {
 
 impl TypeEq for AttributesMeta {
     fn type_hash<H: Hasher>(&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 {

xsd-parser/src/models/meta/dynamic.rs

@@ -1,81 +1,80 @@
-//! 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<TypeIdent>,
 
-    /// List of derived types.
-    pub derived_types: Vec<DerivedTypeMeta>,
-}
+    /// 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<String>,
+    /// Map of the derived types of this dynamic type.
+    pub derived_types: IndexMap<TypeIdent, DerivedTypeMeta>,
 }
 
 impl TypeEq for DynamicMeta {
     fn type_hash<H: Hasher>(&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)
     }
 }
 
-impl DerivedTypeMeta {
-    /// Creates a new [`DerivedTypeMeta`] instance with the given `type_`.
-    #[must_use]
-    pub fn new(type_: TypeIdent) -> Self {
-        Self {
-            type_,
-            display_name: None,
-        }
-    }
+/// Meta information about a single derived type of a dynamic type.
+#[derive(Default, Debug, Clone)]
+pub struct DerivedTypeMeta {
+    /// Is set to `true` if this derived type is directly defined in the dynamic type,
+    /// otherwise it is inherited from another dynamic type.
+    pub is_direct: bool,
+
+    /// Name of the element to use inside the generated code.
+    pub display_name: Option<String>,
 }
 
 impl TypeEq for DerivedTypeMeta {
-    fn type_hash<H: Hasher>(&self, hasher: &mut H, types: &MetaTypes) {
+    fn type_hash<H: Hasher>(&self, hasher: &mut H, _types: &MetaTypes) {
         let Self {
-            type_,
             display_name,
+            is_direct,
         } = self;
 
-        type_.type_hash(hasher, types);
         display_name.hash(hasher);
+        is_direct.hash(hasher);
     }
 
-    fn type_eq(&self, other: &Self, types: &MetaTypes) -> bool {
+    fn type_eq(&self, other: &Self, _types: &MetaTypes) -> bool {
         let Self {
-            type_,
             display_name,
+            is_direct,
         } = self;
 
-        type_.type_eq(&other.type_, types) && display_name == &other.display_name
+        display_name == &other.display_name && is_direct == &other.is_direct
     }
 }

xsd-parser/src/models/meta/element.rs

@@ -258,7 +258,7 @@ impl DerefMut for ElementsMeta {
 
 impl TypeEq for ElementsMeta {
     fn type_hash<H: Hasher>(&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 {

xsd-parser/src/models/meta/enumeration.rs

@@ -157,7 +157,7 @@ impl DerefMut for EnumerationMetaVariants {
 
 impl TypeEq for EnumerationMetaVariants {
     fn type_hash<H: Hasher>(&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 {