namespace XML


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


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


using XMLByteInputStream = std::istream;


using XMLByteOutputStream = std::ostream;


using XMLChar = char;


using XMLCharInputStream = std::istream;


using XMLCharOutputStream = std::ostream;


using XMLString = std::string;


fromXMLString inline

inline const std::string & fromXMLString(
    const XMLString & str

operator != inline

inline bool operator != (
    const QName & x,
    const QName & y

operator < inline

inline bool operator < (
    const QName & x,
    const QName & y

operator <<

std::ostream & operator << (
    std::ostream & param723,
    const QName & param724

operator == inline

inline bool operator == (
    const QName & x,
    const QName & y

swap inline

inline void swap(
    Name & n1,
    Name & n2

toXMLString inline

inline const XMLString & toXMLString(
    const std::string & str

Securely control IoT edge devices from anywhere   Connect a Device