How to identify inline element type by real name?

[imamatory]

According to the custom_names.rs example, I try to find types that represent inline xs:element (<xs:element name="MyElement">). However, their names in Types struct are somewhat MyElementContent72. How can I match such elements against the names in xsd?

[Bergmann89]

Hey @imamatory,

I ran into naming conflicts with one of my test schemas, so names for inline xs:elements currently get generated with postfixes to avoid collisions.

If you could share the schema with me, I’ll check if it’s possible to use the element’s name directly and adjust the behavior accordingly.

[imamatory]

Hey @Bergmann89, sure!

Here is my schema:

<?xml version='1.0'?>
<xs:schema
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:doc="urn:exch:document:1.0"
  xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
  elementFormDefault="qualified" attributeFormDefault="unqualified">
  <xs:element name="myElement">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="created_date" type="RecordDateType" />
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="RecordDateType">
    <xs:attribute name="RecordDate" type="xs:date" use="required" />
  </xs:complexType>
</xs:schema>

Here, myElement is represented in Type as MyElementContent1.

Additional context

My general goal is to replace all the names in the schema with my own. In certain cases, I need to replace an element's name based on the name of its parent element. So it would be great to have access to the original name of the parent element (myElement for created_at in the example above).

[Bergmann89]

In this case your myElement is a top level element. This should definitely use the name from the schema for code generation. Inline elements (with the generated names) would look like this:

 <xs:element name="myElement">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="created_date">
           <!-- 
               No known name for "RecordDateType" here, so one is generated. 
               Should be something like MyElementCreatedData123.
           -->
           <xs:complexType>
             <xs:attribute name="RecordDate" type="xs:date" use="required" />
           </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

If I run your schema through the simple example (using the latest master), I got the following result:

#[derive(Debug)]
pub struct RecordDateType {
    pub record_date: String,
}
pub type MyElement = MyElementElementType;
#[derive(Debug)]
pub struct MyElementElementType {
    pub created_date: RecordDateType,
}

Looks good to me (the type postfixes aka XXXElementType can be changed/removed via GeneratorConfig::type_postfix). With disabled optimizations you'll get the MyElementElementTypeContent (without the number):

#[derive(Debug)]
pub struct RecordDateType {
    pub record_date: DateType,
}
pub type MyElement = MyElementElementType;
#[derive(Debug)]
pub struct MyElementElementType {
    pub content: MyElementElementTypeContent,
}
#[derive(Debug)]
pub struct MyElementElementTypeContent {
    pub created_date: RecordDateType,
}
pub type DateType = String;

But this is also ok. Without optimization (in this case GeneratorFlags::FLATTEN_CONTENT) elements always are represented using two types. A element type and a content type:

struct MyElement {
    attrib_1: usize,
    attrib_2: usize,
    attrib_n: usize,
    content: MyElementContent,
}

struct MyElementContent {
    sub_element_1: SubElementType,
    sub_element_2: SubElementType,
    sub_element_n: SubElementType,
}

With the FLATTEN_CONTENT flag set, the content is merged into the element type, if possible. Depends on the content type (all/choice/sequence) and the min/max occurrence.

I'm still curious where you got the MyElementContent1 from 🤔 Which version do you use? Could you also share the code you used to generate it?

[imamatory]

You're right! I oversimplified my example and lost some important details. More accurate is below:

<?xml version='1.0'?>
<xs:schema
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:doc="urn:exch:document:1.0"
  xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
  elementFormDefault="qualified" attributeFormDefault="unqualified">
  <xs:element name="rootElement">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="myElement">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="created_date" type="RecordDateType" />
            </xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name="myOtherElement">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="created_date" type="RecordDateType" />
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:complexType name="RecordDateType">
    <xs:attribute name="RecordDate" type="xs:date" use="required" />
  </xs:complexType>
</xs:schema>

My actual problem is that I need to distinguish created_date from myElement and from myOtherElement to give it a proper name. Because in my domain those date elements mean a bit different, but in xsd they have the same name. So I don't know how to filter them by the containing element to rename properly.
To find the exact name of each type, I decided to print all of them, and here is what I came up with:

pub fn print_types(types: &Types) -> Result<(), Error> {
    // Print all available identifiers for debugging
    println!("\nAvailable types:");
    println!("{:-<80}", "");
    println!("{:<20} | {:<20} | {:<30}", "Type", "Namespace", "Name");
    println!("{:-<80}", "");

    let user_types = types
        .iter()
        .filter(|(ident, _)| !matches!(ident.type_, IdentType::BuildIn) && ident.ns.is_none());

    for (ident, _) in user_types {
        match types.get_variant(ident) {
            Some(TypeVariant::Sequence(GroupInfo { elements, .. })) => {
                // Here we don't have real ident.name that appear in xsd
                println!("{:<20} | {:<20} | {:<20}",
                    "Sequence",
                    format!("{:?}", ident.ns),
                    format!("{:?}", ident.name)
                );
                for element in elements.iter() {
                    println!("{:<20} | {:<20} | {:<20}",
                        " - Element",
                        format!("{:?}", ident.ns),
                        element.ident.name.to_string()
                    );
                }
            }
            Some(TypeVariant::ComplexType(ComplexInfo { attributes, .. })) => {
                println!(
                    "{:<20} | {:<20} | {:<30}",
                    "ComplexType",
                    format!("{:?}", ident.ns),
                    format!("{:}", ident.name.to_string())
                );
                for attr in attributes.iter() {
                    println!("{:<20} | {:<20} | {:<20}",
                        " - Attribute",
                        format!("{:?}", ident.ns),
                        attr.ident.name.to_string()
                    );
                }
            }
            _ => {
                println!(
                    "{:<20} | {:<20} | {:<30}",
                    format!("{:?}", ident.type_),
                    format!("{:?}", ident.ns),
                    ident.name
                );
            }
        }
        println!("{:_<80}\n", "");
    }
    Ok(())
}

With output for my latest example:

Available types:
--------------------------------------------------------------------------------
Type                 | Namespace            | Name                          
--------------------------------------------------------------------------------
Type                 | None                 | BigInt
________________________________________________________________________________

Type                 | None                 | BigUint
________________________________________________________________________________

ComplexType          | None                 | RecordDateType                
 - Attribute         | None                 | RecordDate          
________________________________________________________________________________

Element              | None                 | rootElement
________________________________________________________________________________

ComplexType          | None                 | rootElement                   
________________________________________________________________________________

Sequence             | None                 | Generated("RootElementContent1")
 - Element           | None                 | myElement           
 - Element           | None                 | myOtherElement      
________________________________________________________________________________

Sequence             | None                 | Generated("RootElementContent2")
 - Element           | None                 | created_date        
________________________________________________________________________________

Sequence             | None                 | Generated("RootElementContent3")
 - Element           | None                 | created_date        
________________________________________________________________________________

Element              | None                 | RootElementMyElement
________________________________________________________________________________

ComplexType          | None                 | RootElementMyElement          
________________________________________________________________________________

Element              | None                 | RootElementMyOtherElement
________________________________________________________________________________

ComplexType          | None                 | RootElementMyOtherElement     
________________________________________________________________________________

I would like to have a way to get information about the type that contains Sequence.
BTW I use latest master

[Bergmann89]

How exactly do you want to distinguish the created_date elements?

• Do you want to rename the created_date element inside myElement and myOtherElement and stick with the RecordDateType type? Then you can simple walk through the MetaType structure and change the name of the element inside the sequence.
• Or, do you want to use a different type for the two created_date elements? This is a bit more complex, because the two fields references the same type. So if you want to have different types, you have to create a new date type and reference this type in your created_date element.

I have created example code for both suggestions here. But honestly, I guess it's much more simpler to just change the schema instead of dealing with the changes in code. However if you need to change the schema programmatically you can use the suggested code.

Some additional information about the generation of the names:

<xs:element name="rootElement">
  <!-- 
      Is currently used directly to identify the top level element. 
      Internally uses `Name::Named("rootElement")` 
  -->
  <xs:complexType>
    <xs:sequence>
      <xs:element name="myElement">
        <!-- 
          Inlined elements will get a name prefixed with its parent element.
          Internally uses `Name::Generated("RootElementMyElement")` 
        -->
      </xs:element>
    </xs:sequence>
  </xs:complexType>
</xs:element>

[Bergmann89]

Addendum: Another - not yet mentioned - approach would be to manipulate the Schema instead of MetaTypes. The Schema type represents the structure of the XSD and is maybe easier to understand for someone that is already familiar with XSD. I've added suitable methods to get mutable references to the Schema object to the Schemas type.

let mut schemas = exec_parser(config.parser).unwrap();
let namespace_id = schemas.resolve_namespace(&None).unwrap(); // or `&Some(Namespace::new("http://my-host.de/my-schema.xsd"))`
let namespace_info = schemas.get_namespace_info(&namespace_id).unwrap();
let schema_id = namespace_info.schemas.first().unwrap();
let schema = schemas.get_schema_mut(&schema_id).unwrap();

/* OR if you just have one schema */

let mut schemas = exec_parser(config.parser).unwrap();
let schema = schemas.schemas_mut().next().unwrap();

[imamatory]

to rename the created_date element inside myElement and myOtherElement and stick with the RecordDateType type

This is exactly what I was looking for, thank you.

However, is it possible to use runtime values to create an Ident? I am loading a large list of type and name substitutions from a CSV file, which prevents me from creating Name::named and Name::generated from a String due to the 'static lifetime constraint.

[Bergmann89]

Sure. Name also has a new_named and new_generated method you can pass anything to, that implements Into<Cow<'static, str>>. So just passing a String should work (this should create a Cow::Owned(String) internally).