The interfaces of CORBA objects and the types of data they can manipulate are defined using IDL. Thus the integration of XML with CORBA must be expressed using IDL types. However, it's possible to perform this transformation dynamically when IIOP-compatible structures can be created directly from XML documents.

IDL provides standard primitive data types along with structured and aggregate data types and variable types in the form of the CORBA Any (and DynAny). IDL distinguishes between object types and value types as noted in the sidebar below.

It's not desirable to produce an XML IDL API using CORBA object types. This would imply that the XML document is encapsulated within a CORBA interface, which would be inefficient since the document is accessed in a remote fashion.

It's more desirable to use either value types or existing IDL data types as a means of passing documents by value, since this would allow efficient operations on the XML document. However, the value-types specification has only recently been ratified by the OMG, and few implementations of the specification are available. Thus the choice remains about whether the integration of XML and CORBA should use value types or map directly to existing CORBA data types.

Approach 1: Simple Approach
This initial approach is the simplest one possible for passing an XML document to a CORBA object and involves "stringifying" the XML document.

struct XMLDocument
{
String dtd;
String document;
};

typedef sequence<XMLDocument> XMLDocuments;

interface MyObject
{
void invoke(XMLDocuments documents);
};

One advantage of this approach is that it's easy to extend existing object interfaces to support XML data. The disadvantages are significant and are as follows:

Approach 2: Mapping XML to IDL Using Value Types
This approach uses CORBA value types and is under review by the OMG. It represents as much of the DOM API as possible using CORBA value types. The value type, a new IDL construct, is a cross between the existing struct and interface. It's always passed by reference, but can contain method declarations such as an interface.

Listing 1, taken from OMG Document 99-12-05, demonstrates the value-type definition for a DOM Node. The Node type is central to the DOM API, since the document, element and text sections of an XML document implement the Node interface. As you can see, this API uses a standard naming convention for accessing all parts of an XML document.

Other Key DOM types are DOMString, NodeList, Document, Element, Attr and Text. This approach is consistent with the standard DOM API; however, the semantics of the XML document aren't clear when using a standard API. It's also likely to be some time before such an approach is practical, as the CORBA implementation of the value-type specification hasn't become common yet.

Approach 3: Mapping XML to CORBA IDL
This approach takes advantage of the IDL types currently supported by existing CORBA implementations. It maps an XML document into CORBA types before an operation is invoked, and converts the CORBA types back to XML when they're received by the receiving object. This approach is network efficient and type-safe. Another advantage - the semantics of the document are preserved when translated directly into the CORBA structures used to encapsulate the document.

The examples that follow demonstrate the mapping between an XML document and its associated CORBA IDL definition. This mapping could be performed automatically given a DTD (or XML schema) for the XML document in question.

XML documents are implemented as a hierarchical CORBA type using a two-way mapping between XML and IDL and the CORBA Any. In this case, the CORBA Any will always hold a CORBA structure, and the contents of this structure depend on the XML document. The mapping is detailed as follows:

Mapping XML ---> IDL

<element>
1.23
</element>

struct element
{
float _Value;
};

<element color=green' font=fixed'/>
struct element
{

string color,
string font
};

<element color=green'>
1.23
</element>
struct element
{
string color,
float _Value;
};

<element>
<child id=abc'/>
</element>

struct element
{
struct child
{
string id;
};
};

<elements>
<element color=green'/>
<element color=blue'/>
</elements>

struct elements
{
struct element
{
string color;
};
sequence<element> _element;
};

<elements>
<element color=green'/>
<element color=blue'/>
</elements>
struct element
{
string color;
};
struct elements
{
element _element[2];
};

interface MyObject
{
void invoke(Any document);
};

Mapping IDL ---> XML

This type-safe and efficient approach takes advantage of the available CORBA implementations. An example of mapping XML to CORBA taken from the finance domain demonstrates the mapping of a stock portfolio XML document to a CORBA IDL (see Listing 2).

Summary
In this article we discussed the benefits of using CORBA and XML for building a distributed application and three approaches to integrating XML documents with CORBA. While it's possible to achieve integration using a primitive approach - converting the XML document to a string and passing this string to the object - little efficiency is achieved this way and the power of CORBA isn't leveraged.

The second approach, which attempts to leverage from the standard DOM API to XML, presents a solution using the newly defined CORBA value-type specification. While this solution is efficient and type-safe, it doesn't attempt to map the semantics of the document into the CORBA value type.

The final approach achieves efficiency and type safety, and succeeds in preserving the semantics of the XML document in the CORBA structure. It's also possible to implement this approach with the currently available CORBA implementations.

References
1. W3C Web site: www.w3c.org
2. OMG Web site: www.omg.org
3. Hemming, M., and Vinoski, S. (1999). Advanced CORBA
Programming with C++. Addison Wesley.
4. Slama, D., Garbis, J., and Russell, P. (1999). Enterprise
CORBA. Prentice Hall.