Naming collisions may still occur due to the way that HydraExpress maps XML names to C++. The code generator attempts to work around some of these naming collisions, but does not always find a satisfactory resolution.

8.2.1 Static Data Members

The classes generated for complex types have these static data members:

• the DefaultElementName data member

• contained element name and attribute data members

8.2.1.1 The DefaultElementName Data Member

The marshal() and unmarshal() methods for a class use the DefaultElementName by default. This allows you to simply call marshal() or unmarshal() on a class, usually with good results. For example, if the schema defines a top-level element named purchaseOrder, the following code usually works as expected:

PurchaseOrder po; po.marshal();

This code should produce, as expected, an XML document with a top-level element <purchaseOrder>.

There is one case, however, where the default use of the DefaultElementName does not work as you might expect:

<element name="foo" type="bar"/> <complexType name="bar"> ... </complexType>

In this case, if the following code were used:

Bar b; b.marshal();

the result would be an XML document containing a top-level element called <bar>, when it would make better sense for the name of the element to be <foo>. To obtain this better result, the second line above would need to be:

b.marshal("foo","schema_target_namespace");

8.2.1.2 Contained Element Name and Attribute Data Members

For each of the elements contained in a complex type, the class for the complex type has data members for the element names, and for any attributes of the complex type. The following code is taken from the XML Binding basic example:

<xsd:complexType name="PurchaseOrderType"> <xsd:sequence> <xsd:element name="shipTo" type="USAddress"/> <xsd:element name="billTo" type="USAddress"/> <xsd:element ref="comment" minOccurs="0"/> <xsd:element name="items" type="Items"/> </xsd:sequence> <xsd:attribute name="orderDate" type="xsd:date"/> </xsd:complexType>

The class PurchaseOrderType contains the following static data members:

static const rwsf::XmlName OrderDateAttributeName; static const rwsf::XmlName ShipToElementName; static const rwsf::XmlName BillToElementName; static const rwsf::XmlName CommentElementName; static const rwsf::XmlName ItemsElementName;

8.2.2 Namespaces

There are two aspects to namespace support:

• First, the generated marshaler and unmarshaler read and write namespace-qualified XML according to the schema definitions.

• Second, HydraExpress uses namespaces to generate classes in a scope that is unique to the defined namespace.

8.2.2.1 Accessing the Fully Qualified XML Name of a Complex Type

HydraExpress allows you to access the fully-qualified XML name of complex types. If a target namespace is present in the schema, the value is programmatically accessible using the DefaultElementName constant, as shown here:

aComplexType::DefaultElementName.getNamespace().getURI();

8.2.2.2 Mapping XML Namespaces to C++ Namespaces

If the schema contains a namespace declaration that associates a prefix to the target namespace URI, by default this prefix is used as the C++ namespace for the generated classes. In the example schema element declaration below, the po prefix is associated with the URI that matches the value of the targetNamespace attribute, so the classes would be generated within the po namespace.

<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:po="http://www.example.com/PO1" targetNamespace="http://www.example.com/PO1" ...

To use the generated classes you must prefix the type with the po namespace or make the name accessible with a using directive or using declaration. The following code snippets show both options.

Prefixing the type with a the po namespace:

// Code Example with C++ namespace qualified type name int main() { ... po::PurchaseOrderType order; ... }

Importing all names in po with a using directive:

// Code Example with using directive using namespace po; int main() { ... PurchaseOrderType order; ... }

Importing po::PurchaseOrderType with a using declaration:

// Code Example with using declaration using po::PurchaseOrderType; int main() { ... PurchaseOrderType order; ... }

Instead of using the XML namespace prefix as the C++ namespace, you can choose your own C++ namespace through the use of the mappings element in a HydraExpress project file. The mapping element shown below instructs the code generator to generate the classes that are defined within the target namespace http://www.example.com/PO1, using the C++ namespace named POTypes.

<mappings> <namespace uri="http://www.example.com/PO1" name="POTypes"/> </mappings>

8.2.2.3 Differentiating Same-Named Items

It is entirely possible in an XML Schema to have two or more elements, types, or groups with the same name, so long as they are defined in separate namespaces. In this case, HydraExpress creates a separate class for each namespace-qualified item, placing the code for each class in a single pair of header and source files, named as usual with the unqualified name of the element, type or group.

8.2.2.4 Adding a Namespace to a Root Element

8.2.3 File Naming

As described in the remainder of this chapter, HydraExpress creates classes corresponding to top-level elements and complex types defined in the XML Schema. Generally, HydraExpress creates a header and a source file for each class, with the file name based on the unqualified name of the element or type. The exception is when multiple items have the same name but in different namespaces, as described above.

It is also possible for there to be name conflicts between elements, types, and groups in the same namespace. These are handled as follows:

• If an element name conflicts with a type name, the generated class name remains the same; that is, it follows the standard naming conventions.

• If a type name conflicts with an element name, the generated class for the type has the string Type appended to its name.

So, for example, if a schema defined an element named Address and a type named Address, HydraExpress would generate a class Address for the element and a class AddressType for the type.