Classes: AbstractContainerNode, AbstractNode, Attr, AttrMap, Attributes, AttributesImpl, CDATASection, CharacterData, ChildNodesList, Comment, ContentHandler, DOMBuilder, DOMException, DOMImplementation, DOMObject, DOMParser, DOMSerializer, DOMWriter, DTDHandler, DTDMap, DeclHandler, DefaultHandler, Document, DocumentEvent, DocumentFragment, DocumentType, Element, ElementsByTagNameList, ElementsByTagNameListNS, Entity, EntityReference, EntityResolver, EntityResolverImpl, ErrorHandler, Event, EventDispatcher, EventException, EventListener, EventTarget, InputSource, LexicalHandler, Locator, LocatorImpl, MutationEvent, Name, NamePool, NamedNodeMap, NamespacePrefixesStrategy, NamespaceStrategy, NamespaceSupport, NoNamespacePrefixesStrategy, NoNamespacesStrategy, Node, NodeAppender, NodeFilter, NodeIterator, NodeList, Notation, ParserEngine, ProcessingInstruction, SAXException, SAXNotRecognizedException, SAXNotSupportedException, SAXParseException, SAXParser, Text, TreeWalker, WhitespaceFilter, XMLException, XMLFilter, XMLFilterImpl, XMLReader, XMLWriter
Types: XMLByteInputStream, XMLByteOutputStream, XMLChar, XMLCharInputStream, XMLCharOutputStream, XMLString
Functions: fromXMLString, swap, toXMLString
 AbstractContainerNode is an implementation of Node
 that stores and manages child nodes.  
 
 AbstractNode provides a basic implementation
 of the Node interface for all types of nodes
 that do not contain other nodes.  
 
 The Attr interface represents an attribute in an Element object.  
 
 Interface for a list of XML attributes.  
 
 This class provides a default implementation of the SAX2 Attributes interface, 
 with the addition of manipulators so that the list can be modified or reused.  
 
 CDATA sections are used to escape blocks of text containing characters that
 would otherwise be regarded as markup.  
 
 The CharacterData interface extends Node with a set of attributes and methods
 for accessing character data in the DOM.  
 
 This interface inherits from CharacterData and represents the content of
 a comment, i.  
 
 Receive notification of the logical content of a document.  
 
 This class builds a tree representation of an
 XML document, according to the W3C Document Object Model, Level 1 and 2
 specifications.  
 
 DOM operations only raise exceptions in "exceptional" circumstances, i.  
 
 The DOMImplementation interface provides a number of methods for
 performing operations that are independent of any particular instance
 of the document object model.  
 
 The base class for all objects in the Document Object Model.  
 
 This is a convenience class that combines a
 DOMBuilder with a SAXParser, with the optional
 support of a WhitespaceFilter.  
 
 The DOMSerializer serializes a DOM document
 into a sequence of SAX events which are
 reported to the registered SAX event
 handlers.  
 
 The DOMWriter uses a DOMSerializer with an
 XMLWriter to serialize a DOM document into
 textual XML.  
 
 If a SAX application needs information about notations and unparsed entities, 
 then the application implements this interface and registers an instance with the 
 SAX parser using the parser's setDTDHandler method.  
 
 This implementation of NamedNodeMap
 is returned by DocumentType::entities()
 and DocumentType::notations().  
 
 This is an optional extension handler for SAX2 to provide information 
 about DTD declarations in an XML document.  
 
 Default base class for SAX2 event handlers.  
 
 The Document interface represents the entire HTML or XML document.  
 
 The DocumentEvent interface provides a mechanism by which the user can create
 an Event of a type supported by the implementation.  
 
 DocumentFragment is a "lightweight" or "minimal" Document object.  
 
 Each Document has a doctype attribute whose value is either null or a DocumentType
 object.  
 
 The Element interface represents an element in an XML document.  
 
 This interface represents an entity, either parsed or unparsed, in an XML
 document.  
 
 EntityReference objects may be inserted into the structure model when an
 entity reference is in the source document, or when the user wishes to insert
 an entity reference.  
 
 If a SAX application needs to implement customized handling for external entities, 
 it must implement this interface and register an instance with the SAX driver using 
 the setEntityResolver method.  
 
 A default implementation of the EntityResolver interface.  
 
 If a SAX application needs to implement customized error handling, it must 
 implement this interface and then register an instance with the XML reader 
 using the setErrorHandler method.  
 
 The Event interface is used to provide contextual information about an event
 to the handler processing the event.  
 
 This helper class manages event listener subscriptions
 and event dispatching for AbstractNode.  
 
 Event operations may throw an EventException as 
 specified in their method descriptions.  
 
 The EventListener interface is the primary method for handling events.  
 
 The EventTarget interface is implemented by all Nodes in an implementation
 which supports the DOM Event Model.  
 
 This class allows a SAX application to encapsulate information about an input 
 source in a single object, which may include a public identifier, a system 
 identifier, a byte stream (possibly with a specified encoding), and/or a character 
 stream.  
 
 This is an optional extension handler for SAX2 to provide lexical information 
 about an XML document, such as comments and CDATA section boundaries.  
 
 Interface for associating a SAX event with a document location.  
 
 Provide an optional convenience implementation of Locator.  
 
 The MutationEvent interface provides specific contextual 
 information associated with Mutation events.  
 
 An XML element or attribute name, consisting of a
 qualified name, a namespace URI and a local name.  
 
 A hashtable that stores XML names consisting of an URI, a
 local name and a qualified name.  
 
 Objects implementing the NamedNodeMap interface are used to represent collections
 of nodes that can be accessed by name.  
 
 The NamespaceStrategy implementation used if namespaces
 processing is requested and prefixes are reported.  
 
 This class is used by ParserEngine to handle the
 startElement, endElement, startPrefixMapping and
 endPrefixMapping events.  
 
 Encapsulate Namespace logic for use by SAX drivers.  
 
 The NamespaceStrategy implementation used if namespaces
 processing is requested, but prefixes are not reported.  
 
 The NamespaceStrategy implementation used if no namespaces
 processing is requested.  
 
 The Node interface is the primary datatype for the entire Document Object
 Model.  
 
 The NodeAppender class provides a very fast way to
 build larger DOM documents.  
 
 Filters are objects that know how to "filter out" nodes.  
 
 Iterators are used to step through a set of nodes, e.  
 
 The NodeList interface provides the abstraction of an ordered
 collection of nodes, without defining or constraining how this
 collection is implemented.  
 
 This interface represents a notation declared in the DTD.  
 
 This class provides an object-oriented, stream-based, 
 low-level interface to the XML Parser Toolkit (expat).  
 
 The ProcessingInstruction interface represents a "processing instruction",
 used in XML as a way to keep processor-specific information in the text
 of the document.  
 
 The base class for all SAX-related exceptions like SAXParseException,
 SAXNotRecognizedException or SAXNotSupportedException.  
 
 Exception class for an unrecognized identifier.  
 
 Exception class for an unsupported operation.  
 
 This class provides a SAX2 (Simple API for XML) interface to expat, 
 the XML parser toolkit.  
 
 The Text interface inherits from CharacterData and represents the textual
 content (termed character data in XML) of an Element or Attr.  
 
 TreeWalker objects are used to navigate a document tree or subtree using
 the view of the document defined by their whatToShow flags and filter (if
 any).  
 
 This implementation of the SAX2 XMLFilter interface
 filters all whitespace-only character data element
 content.  
 
 Interface for an XML filter.  
 
 Base class for deriving an XML filter.  
 
 Interface for reading an XML document using callbacks.  
 
 This class serializes SAX2 ContentHandler, LexicalHandler and
 DTDHandler events back into a stream.  
 
typedef std::istream XMLByteInputStream;
typedef std::ostream XMLByteOutputStream;
typedef char XMLChar;
typedef std::istream XMLCharInputStream;
typedef std::ostream XMLCharOutputStream;
typedef std::string XMLString;
 
 inline const std::string & fromXMLString(
    const XMLString & str
);
 
 inline void swap(
    Name & n1,
    Name & n2
);
 
 inline const XMLString & toXMLString(
    const std::string & str
);