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