Convert AnyElement to known type.

[m4siri]

Hi there, is there a better way to do this ? Converting a AnyElement to a known Type ? Thank you.

fn parse_get_parameter_values_response(
    element: AnyElement,
) -> Result<GetParameterValuesResponse, Box<dyn std::error::Error>> {
    let mut buffer = Vec::new();
    let mut writer = Writer::new(&mut buffer);
    element.serialize("GetParameterValuesResponse", &mut writer)?;

    let xml = String::from_utf8(buffer)?;
    let mut reader = SliceReader::new(xml.as_str());
    let schema_response = GetParameterValuesResponse::deserialize(&mut reader)?;
    Ok(schema_response)
}

[Bergmann89]

Hey @sirimhrzn,

you can replace the element in the containing type from AnyElement to GetParameterValuesResponse.

For a rough setup have a look to the custom_names example. But instead of changing the display_name of your type, you can loop through it's elements and change the type to what you need.

Here is a rough untested (!) code snippet:

    // Get the identifier for the target type
    let target_ident = IdentTriple::from((IdentType::Type, "GetParameterValuesResponse"));

    // Get the identifier for the containing type
    let ident = IdentTriple::from((IdentType::Type, "ContainingType"));
    let ident = ident.resolve(schemas)?;
    
    // Get the containing type
    let ty = types.items.get_mut(&ident).unwrap();
    let MetaTypeVariant::Complex(ty) = &ty.variant else { panic!(); }; // I assume your type is a complex type
    let content = ty.content.clone().unwrap();
    
    // Get the content type
    let ty = types.items.get_mut(&ident).unwrap();
    let MetaTypeVariant::Sequence(ty) = &ty.variant else { panic!(); }; // I assume the content of your type is a sequence
    
    // Loop through the elements
    for el in &mut *ty.elements {
        if el.ident.name.as_str() == "my-element" {
            el.variant = ElementMetaVariant::Type { // For simplicity I assign a new `ElementMetaVariant` here
                type_: target_ident,                // A better approach would be to check if it is a `::Type`
                mode: ElementMode::Element,         // and then only assign `type_`.
            }
        }
    }

Now the generator should generate a GetParameterValuesResponse instead of a AnyElement.

Let me know if you need more help 😊

[m4siri]

Hi @Bergmann89,
I looked around the xsd-schema api's and it does make sense. I'm working with SOAP and I think you can help me out a bit.
For reference, this is the definition of Body of an http://schemas.xmlsoap.org/soap/envelope/.

  <xs:complexType name="Body" >
    <xs:sequence>
      <xs:any namespace="##any" minOccurs="0" maxOccurs="unbounded" processContents="lax" />
    </xs:sequence>
    <xs:anyAttribute namespace="##any" processContents="lax" >
	  <xs:annotation>
	    <xs:documentation>
		  Prose in the spec does not specify that attributes are allowed on the Body element
		</xs:documentation>
	  </xs:annotation>
	</xs:anyAttribute>
  </xs:complexType>

And this is the generated rust type.

 #[derive(Debug)]
pub struct BodyType {
        pub any_attribute: AnyAttributes,
        pub any: ::std::vec::Vec<AnyElement>,
}

I have the schema definitions for the RPC request. There are many that looks something like this.

  <xs:element name="HoldRequests">
    <xs:complexType>
      <xs:simpleContent>
        <xs:extension base="xs:boolean">
          <xs:attribute ref="soapenv:mustUnderstand" use="required" fixed="1"/>
        </xs:extension>
      </xs:simpleContent>
    </xs:complexType>
  </xs:element>

With that being said, I was wondering if it is possible to change the type of the Body or well have one of its field hold a Enum that represents the RpcRequest, which then holds the structure of the request. For example:

struct HoldRequestStruct (());
enum RpcRequest {
   HoldRequest(HoldRequestStruct)
}
pub struct Body {
  request: RpcRequest
}

I hope I said that clearly, please let me know if something like this is possible. Thank you.

[Bergmann89]

Hey @sirimhrzn,

yes, thats possible. As pointed out above you can use the API inside the meta module (especially the MetaTypes), to change the parsed schema as you need.

You can also create a choice, to represent all elements you expect like this:

// Make a list of all types that should be represented in the choice
let mut elements = Vec::new();
elements.push(IdentTriple::from((IdentType::Element, "HoldRequests")))  // be sure to use the correct namespace here
                                                                        // for details about the `IdentTriple` see the 
                                                                        // `custom_names` example.
elements.push(/* more */);

// Convert the identifiers to a list of elements
let elements = ElementsMeta(elements.into_iter().map(|ident| ElementMeta {
    ident: ident.clone(),
    variant: ElementMetaVariant::Type {
        type_: ident,
        mode: ElementMode::Element,
    },
    form: FormChoiceType::Unqualified, // May be also `Qualified`, depends on your needs
    nillable: false,
    min_occurs: 1,
    max_occurs: MaxOccurs::Bounded(1),
    display_name: None,
    documentation: Vec::new(),
}).collect());

// Get the identifier for `Body`
let body = IdentTriple::from((IdentType::Type, "tns:Body"));
let body = body.resolve(schemas)?

// Get the body type
let body = types.items.get_mut(&body).unwrap();
let MetaTypeVariant::Complex(body) = &body.variant else { panic!(); };
let content = body.content.clone().unwrap();

// Redefine the content to what you need
let content = types.items.get_mut(&content).unwrap();
content.variant = MetaTypeVariant::Choice(GroupMeta {
    elements,
    ..GroupMeta::default()
});

[m4siri]

Hi @Bergmann89,
Thank you, I will do that and let you know, i'll spend some more time with the modules.

[m4siri]

Hi @Bergmann89,
I was able to generate the enums as I wanted to by following the things you said earlier.

fn typed_envelope_header(schemas: &Schemas, mut types: MetaTypes) -> Result<MetaTypes, Error> {
    let container = IdentTriple::from((
        IdentType::Type,
        Some(NamespaceIdent::namespace(
            b"http://schemas.xmlsoap.org/soap/envelope/",
        )),
        "Header",
    ))
    .resolve(schemas)
    .unwrap();

    let headers = [
        ("ID", "urn:dslforum-org:cwmp-1-0"),
        ("HoldRequests", "urn:dslforum-org:cwmp-1-0"),
        ("SessionTimeout", "urn:dslforum-org:cwmp-1-2"),
        ("SupportedCWMPVersions", "urn:dslforum-org:cwmp-1-2"),
        ("UseCWMPVersion", "urn:dslforum-org:cwmp-1-2"),
    ]
    .into_iter()
    .map(|(name, ns)| {
        IdentTriple::from((
            IdentType::ElementType,
            Some(NamespaceIdent::namespace(ns.as_bytes())),
            name,
        ))
        .resolve(schemas)
        .unwrap()
    })
    .map(|ident| {
        ElementMeta::new(
            ident.clone(),
            ident.clone(),
            ElementMode::Element,
            FormChoiceType::Qualified,
        )
    })
    .collect::<Vec<_>>();

    let ty = types.items.get_mut(&container).unwrap();

    ty.variant = MetaTypeVariant::Choice(GroupMeta {
        is_mixed: false,
        elements: ElementsMeta(headers),
    });

    Ok(types)
}

With this, I was able to generate enums as I needed to.

// generated type
    pub enum HeaderType {
        Id(super::tns::IdElementType),
        HoldRequests(super::tns::HoldRequestsElementType),
        SessionTimeout(super::cwmp_13::SessionTimeoutElementType),
        SupportedCwmpVersions(super::cwmp_14::SupportedCwmpVersionsElementType),
        UseCwmpVersion(super::cwmp_14::UseCwmpVersionElementType),
    }

Honestly, thank you so much for helping out and for this library as well.

[Bergmann89]

Nice. Looks good 😊