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.