A Template-Based Approach to XML Parsing in C++

XML is a markup-based data description language designed to allow developers to create structured documents using descriptive custom tags. The intent of XML is to separate the description of the data from its intended use and allow the transfer of the data between different applications in a nonplatform- or architecture-specific way. Another useful application of XML is to describe a process in a logical and meaningful manner that can be carried out by the application at runtime.

In order for an XML file to be parsed successfully, the developer must first create a file that can be processed by a parser. A parser is a set of shared objects or a library that reads and processes an XML file.

The parser may be one of two types: validating or nonvalidating. A validating parser scans the XML file and determines if the document is well formed, as specified, by either an XML schema or the document type definition (DTD). A nonvalidating parser simply reads the file and ignores the format and layout as specified by either the XML schema or the DTD.

The most widely used parsers represent two different approaches: event-driven and tree-based. The event-driven parser is called SAX (simple API for XML processing). A tree-based parser creates a DOM (document object model) tree in memory at the time the XML file is read and parsed.

The DOM implementation is difficult to navigate and does not allow for clean mapping between XML elements and domain-specific objects. SAX provides the events to allow developers to create their domain-specific objects at the time the XML file is read and parsed. This article delivers a framework design using the SAX API for XML parsing.

The two most commonly used parsers for C++ are the open-source Xerces of the Apache Project and XML4C created by IBM's alphaWorks Project. XML4C is based on Xerces.

Both parsers essentially provide the same layout of source and libraries and therefore can be used interchangeably. They also support both DOM- and SAX-based XML parsing.

This document describes an implementation using the SAX parser with the Xerces parser. The Xerces source or binaries related to XML parsing can be downloaded from the Xerces web site (see Resources).

In order to begin parsing an XML file using the SAX API, the layout of the SAX C++ object interactions must be understood. SAX is designed with two basic interfaces:

SAXParser

setDoValidationsetDoNamespacesetDoSchemasetValidationFullSchemaCheckingsetDocumentHandlersetErrorHandlerparse

and

HandlerBase

warningerrorfatalErrorstartElementcharactersignorableWhitespaceendElement

Close examination of the methods in the HandlerBase object reveals two different categories of methods: error handling and document processing. The error-handling methods include warning, error and fatalError, whereas the parsing methods consist of startElement, characters, ignorableWhitespace and endElement. These behaviors can be separated into individual objects, as shown later.

The SAXParser class takes care of setting basic properties and the desired behavior to be enforced at runtime.

The following sample code illustrates the basic steps for parsing an XML file using the SAX parser in C++:

// Create a new instance of the SAX parser
SAXParser parser;
// Initialize the behavior you desire
parser.setDoValidation(true);
parser.setDoNamespaces(true);
parser.setDoSchema(true);
parser.setValidationSchemaFullChecking(true);
// Add handlers for document and error processing
parser.setDocumentHandler(&docHandler);
parser.setErrorHandler(&errorHandler);
// Parse file
parser.parse("MyXMLFile.xml");

At the time the parsing occurs, the classes you've instantiated, docHandler and errorHandler, are forwarded the events that get triggered from the parsing. These classes are derived from the Xerces base class HandlerBase and have overridden the appropriate methods for handling the events based on their categorized function.

Now that we've been exposed to parsing XML using SAX, let's explore how our XML framework has been implemented to take advantage of the facilities provided within the API.

A policy class, as described and made popular by Andrei Alexandrescu's Modern C++ Design (see Resources), “defines a class interface or a class template interface. The interface consists of one or all of the following: inner type definitions, member functions and member variables.”

The usefulness of policy classes, in this XML framework, are realized when created using a template-based C++ design. A policy allows you to parameterize and configure functionality at a fine granularity. In this design, policies are created to accommodate the following behaviors: document handling, error handling, domain mapping and parsing.

Configuring these elements as policies allows the creation of more concise code that is easier to maintain by any developer experienced in C++ and the use of templates.

The principal class of the XML-parsing framework is the XMLSAXParser. It's a custom-designed class template that implements the XMLParserInterface and includes a SAXParser object as a member variable. The template parameters include policy classes for both the document and error handlers. All parsing is eventually delegated to the SAXParser member variable after the various handlers and other properties have been set.

Implementing custom handlers, as policy classes, is a relatively trivial task using the framework. The advantage of this type of design is that the same framework can be used with different parsing APIs and different domain-mapping objects by altering one or more of the policies—an exercise that is not implemented in this article.

In order to create custom handlers, derive newly created custom classes from HandlerBase and override the virtual methods of interest. The following two types of custom handlers have been created in the XMLFactory framework:

XMLSAXHandler

startElementcharacterignorableWhitespaceendElement

and

XMLSAXErrorHandler

warningerrorfatalError

XMLSAXHandler handles document event processing, and XMLSAXErrorHandler handles the various error callbacks.

The next aspect of our XML-parsing framework is converting XML tags into domain-related objects that can be used within the application by using templates and a loose definition of policy classes.

The XMLDomainMap template accepts a single template parameter, called an XMLNode. The interface for the domain-mapping object is as follows:

XMLDomainMap

createaddupdateAttribute

The XMLNode acts as both a leaf and a root in a tree structure that aggregates its children as a subtree. The XMLNode's interface is:

XMLNode

operator==operator!=operator=addChildhasChildrennumChildrenvaluenamegetChildCountgetChildgetParent

The key here is the design of the public interface of the object. There are several operator overloads, specifically operator equals (operator==), operator not equals (operator!=) and the assignment operator (operator=). The benefit to this is the object now can be used with many standard template library (STL) containers and algorithms, which allows for the use of advanced features with the C++ language.

Thus far, the focus has been on individual classes and describing the templates that have been created for our XML-processing framework. The next step is to link the disparate interfaces together and make them appear to function as a single cohesive unit by using the façade design pattern.

The façade design provides a simple and elegant way to delegate parsing functionality from an outside client to the internal policy class that will be used for performing the parsing.

In Design Patterns, the authors define the intent as to “Provide a unified interface to a set of interfaces in a subsystem. Façade defines a higher-level interface that makes the subsystem easier to use.”

The XMLProcessor is the façade that has been created. It is defined with the following interface:

XMLProcessor

parsegetParseEngine

Once all the source has been written, an XML file and a test client will be needed to run our sample.

The following simple XML file, showing the basic layout of a customer record with a name and account number, has been created to illustrate the simplicity of using the framework:

<?xml version="1.0"
encoding="iso-8859-1"?>
<customer>
    <name>John Doe</name>
    <account-number>555123</account-number>
</customer>

For now, create this file with a text editor and save it as MyXMLFile.xml.

The framework's functionality will be used as a mechanism to provide a succinct interface to the client application.

The primary methods that a client of the framework would make use of can be described with an actual, albeit small, sample of C++ source code:

// ---------------------------------------
//  Sample source for parsing an XML doc
// ---------------------------------------
#include "XMLProcessor.hpp"
#include "XMLDomainMap.hpp"
#include "XMLSAXParser.hpp"
#include "XMLNode.hpp"
#include "XMLCommand.h"
#include "XMLSAXHandler.hpp"
#include "XMLSAXErrorHandler.hpp"
#include <iostream>
using namespace std;
using namespace XML;
// Let's get the ugly stuff out of the way first
typedef XMLSAXHandler<XMLDomainMap<XMLNode> >
  DOCHANDLER;
typedef XMLSAXErrorHandler ERRORHANDLER;
typedef XMLSAXParser<DOCHANDLER, ERRORHANDLER>
  PARSER;
typedef XMLProcessor<PARSER> XMLEngine;
// Create a basic test client
int main(void)
{
    // Define a string object with our filename
    std::string xmlFile = "MyXMLFile.xml";
    // Create an instance of our XMLFactory
    XMLEngine parser(xmlFile);
    // Turn off validation
    parser.doValidation(false);

    // Parse our XML file
    parser.parse();
    // Get the tree root
    XMLNode root = parser.getXMLRoot();
    // Print the name of our object
    cout << "Root = " << root.name() <<
endl;
    return 0;
}

Now that an instance of an XMLNode object representing the root of the tree has been parsed, the child elements of the root XMLNode can be accessed.

The last step is to compile the client. Simply perform the compile at the command line:

g++ -o testClient -I. -I/path/to/xerces/include \
-I/path/to/xerces/include/xerces testClient.cpp \
-L/path/to/xerces/lib -lxerces-c

This compiles the client application. The next step is to run a test. Be sure to set your LD_LIBRARY_PATH environment variable to point to the location of your Xerces installation's lib directory. Because the shared libraries are from this directory, the application loader needs a way to import the required symbols at runtime in order for everything to function correctly.

When testClient is run, the following output is expected:

$>testClient
Adding child name
Adding child account-number
Root = customer

You now have a fully functional XML-parsing framework using C++ templates that will allow you to incorporate XML into your new or existing applications. Sample code is available at ftp.linuxjournal.com/pub/lj/listings/issue110/6655l1.tgz.

Resources