Experimental C++ Language Binding for DOM Level 3

[Back to Readme] [Go to C++ Language Binding for DOM Level 2]


This document contains the Experimental Apache Recommended C++ Language binding for the Document Object Model Level 3.0 Core, and for the subset of  Document Object Model Level 3.0 Abstract Schemas and Load and Save , as well as the Document Object Model Level 3.0 XPath. 

The definitions are divided into Core, and Load and Save and XPath. The headers are also available in Xerces-C++ distribution.

Note:

  1. Constructor and Destructors are implementation specific
  2. String is represented by "XMLCh*" which is a pointer to unsigned 16 bit type holding utf-16 values, null terminated.
  3. XMLSize_t is an implementation-dependent unsigned integral type
  4. DOMObject is represented as void*
  5. C++ Memory Management:
    1. A member method "release()" is added for releasing any "orphaned" resources that were created through createXXXX factory method.
    2. Memory for any returned object e.g.
      • DOMImplementation* getDOMImplementation(const XMLCh* features)
      • ... etc.
      • are owned by implementation

Change History

Date Description
Xerces-C++ 2.0: July 23, 2002 Created
Xerces-C++ 2.1: August 26, 2002 Modified
- add const modifier to DOMNode::lookupNamespacePrefix
- add const modifier to DOMNode::lookupNamespaceURI
- add const modifier to DOMNode::isDefaultNamespace
Xerces-C++ 2.2: February 7, 2003 Modified
- add DOMElement::getTypeInfo and DOMAttr::getTypeInfo and DOMTypeInfo.hpp
- add const modifier to DOMNode::compareTreePosition, and add DOMTreePosition
- add const modifier to DOMNode::isSameNode
- add const modifier to DOMNode::isEqualNode
- add const modifier to DOMImplementation::hasFeature
- fix typo: "Mode:" -> "Model"
- added DOMAttr::isID
- added DOMElement::setIdAttribute, DOMElement::setIdAttributeNS, DOMElement::setIdAttributeNode
Xerces-C++ 2.3 Modified
- added DOMError::getRelatedData, DOMError::setRelatedData, DOMError::SetType, DOMError::getType
- removed DOMDocument::setFeature, DOMDocument::getFeature, DOMDocument::canSetFeature
- added DOMDocument::getDOMConfiguration
Xerces-C++ 2.4 Modified
- added DOM Level 3 XPath interfaces

A: Document Object Model: Core

DOMImplementationRegistry.hpp:

class DOMImplementationRegistry
{
public:
static DOMImplementation*  getDOMImplementation(const XMLCh* features);
static void addSource(DOMImplementationSource* source);
};

DOMException.hpp:

class DOMException
{
public:
enum ExceptionCode {
INDEX_SIZE_ERR = 1,
DOMSTRING_SIZE_ERR = 2,
HIERARCHY_REQUEST_ERR = 3,
WRONG_DOCUMENT_ERR = 4,
INVALID_CHARACTER_ERR = 5,
NO_DATA_ALLOWED_ERR = 6,
NO_MODIFICATION_ALLOWED_ERR = 7,
NOT_FOUND_ERR = 8,
NOT_SUPPORTED_ERR = 9,
INUSE_ATTRIBUTE_ERR = 10,
INVALID_STATE_ERR = 11,
SYNTAX_ERR = 12,
INVALID_MODIFICATION_ERR = 13,
NAMESPACE_ERR = 14,
INVALID_ACCESS_ERR = 15
VALIDATION_ERR = 16
};
ExceptionCode code;
const XMLCh* msg;
};

DOMImplementationSource.hpp:

class DOMImplementationSource
{
public:
virtual DOMImplementation*  getDOMImplementation(const XMLCh* features) const = 0;
};

DOMImplementation.hpp:

class DOMImplementation
{
public:
virtual bool hasFeature(const XMLCh* feature,
           const XMLCh* version) const = 0;
virtual DOMDocumentType* createDocumentType(const XMLCh* qualifiedName,
                   const XMLCh* publicId,
                   const XMLCh* systemId) = 0;
virtual DOMDocument* createDocument(const XMLCh* namespaceURI,
               const XMLCh* qualifiedName,
               DOMDocumentType* doctype) = 0;
virtual DOMImplementation*  getInterface(const XMLCh* feature) = 0;
};

DOMDocumentFragment.hpp:

class DOMDocumentFragment : public DOMNode
{
};

DOMDocument.hpp:

class DOMDocument : public DOMNode
{
public:
virtual DOMElement* createElement(const XMLCh* tagName) = 0;
virtual DOMDocumentFragment* createDocumentFragment() = 0;
virtual DOMText* createTextNode(const XMLCh* data) = 0;
virtual DOMComment* createComment(const XMLCh* data) = 0;
virtual DOMCDATASection* createCDATASection(const XMLCh* data) = 0;
virtual DOMProcessingInstruction* createProcessingInstruction(const XMLCh* target,
                            const XMLCh* data) = 0;
virtual DOMAttr* createAttribute(const XMLCh* name) = 0;
virtual DOMEntityReference* createEntityReference(const XMLCh* name) = 0;
virtual DOMDocumentType* getDoctype() const = 0;
virtual DOMImplementation* getImplementation() const = 0;
virtual DOMElement* getDocumentElement() const = 0;
virtual DOMNodeList* getElementsByTagName(const XMLCh* tagname) const = 0;
virtual DOMNode* importNode(DOMNode* importedNode, bool deep) = 0;
virtual DOMElement* createElementNS(const XMLCh* namespaceURI,
                const XMLCh* qualifiedName) = 0;
virtual DOMAttr* createAttributeNS(const XMLCh* namespaceURI,
                  const XMLCh* qualifiedName) = 0;
virtual DOMNodeList* getElementsByTagNameNS(const XMLCh* namespaceURI,
                       const XMLCh* localName) const = 0;
virtual DOMElement* getElementById(const XMLCh* elementId) const = 0;
virtual const XMLCh* getActualEncoding() const = 0;
virtual void setActualEncoding(const XMLCh* actualEncoding) = 0;
virtual const XMLCh* getEncoding() const = 0;
virtual void setEncoding(const XMLCh* encoding) = 0;
virtual bool getStandalone() const = 0;
virtual void setStandalone(bool standalone) = 0;
virtual const XMLCh* getVersion() const = 0;
virtual void setVersion((const XMLCh* version) = 0;
virtual const XMLCh* getDocumentURI() const = 0;
virtual void setDocumentURI(const XMLCh* documentURI) = 0;
virtual bool getStrictErrorChecking() const = 0;
virtual void setStrictErrorChecking(bool strictErrorChecking) = 0;
virtual DOMNode* renameNode(DOMNode* n, const XMLCh* namespaceURI, const XMLCh* name) = 0;
virtual DOMNode* adoptNode(DOMNode* source) = 0;
virtual void normalizeDocument() = 0;
virtual DOMConfiguration* getDOMConfiguration(const XMLCh* const name, bool state) const = 0;
};

DOMNode.hpp:

class DOMNode
{
public:
enum NodeType {
ELEMENT_NODE = 1,
ATTRIBUTE_NODE = 2,
TEXT_NODE = 3,
CDATA_SECTION_NODE = 4,
ENTITY_REFERENCE_NODE = 5,
ENTITY_NODE = 6,
PROCESSING_INSTRUCTION_NODE = 7,
COMMENT_NODE = 8,
DOCUMENT_NODE = 9,
DOCUMENT_TYPE_NODE = 10,
DOCUMENT_FRAGMENT_NODE = 11,
NOTATION_NODE = 12,
};
enum DOMTreePosition {
TREE_POSITION_PRECEDING = 0x01,
TREE_POSITION_FOLLOWING = 0x02,
TREE_POSITION_ANCESTOR = 0x04,
TREE_POSITION_DESCENDANT = 0x08,
TREE_POSITION_EQUIVALENT = 0x10,
TREE_POSITION_SAME_NODE = 0x20,
TREE_POSITION_DISCONNECTED = 0x00,
};
virtual const XMLCh* getNodeName() const = 0;
virtual const XMLCh* getNodeValue() const = 0;
virtual short getNodeType() const = 0;
virtual DOMNode* getParentNode() const = 0;
virtual DOMNodeList* getChildNodes() const = 0;
virtual DOMNode* getFirstChild() const = 0;
virtual DOMNode* getLastChild() const = 0;
virtual DOMNode* getPreviousSibling() const = 0;
virtual DOMNode* getNextSibling() const = 0;
virtual DOMNamedNodeMap* getAttributes() const = 0;
virtual DOMDocument* getOwnerDocument() const = 0;
virtual DOMNode* cloneNode(bool deep) const = 0;
virtual DOMNode* insertBefore(DOMNode* newChild, DOMNode* refChild) = 0;
virtual DOMNode* replaceChild(DOMNode* newChild, DOMNode* oldChild) = 0;
virtual DOMNode* removeChild(DOMNode* oldChild) = 0;
virtual DOMNode* appendChild(DOMNode* newChild) = 0;
virtual bool hasChildNodes() const = 0;
virtual void setNodeValue(const XMLCh *nodeValue) = 0;
virtual void normalize() = 0;
virtual bool isSupported(const XMLCh* feature, const XMLCh* version) const = 0;
virtual const XMLCh* getNamespaceURI() const = 0;
virtual const XMLCh* getPrefix() const = 0;
virtual const XMLCh* getLocalName() const = 0;
virtual void setPrefix(const XMLCh* prefix) = 0;
virtual bool hasAttributes() const = 0;
virtual bool isSameNode(const DOMNode* other) const = 0;
virtual bool isEqualNode(const DOMNode* arg) const = 0;
virtual void* setUserData(const XMLCh* key, void* data, 
            DOMUserDataHandler* handler) = 0;
virtual void* getUserData(const XMLCh* key) const = 0;
virtual const XMLCh* getBaseURI() const = 0;
virtual short compareTreePosition(const DOMNode* other) const = 0;
virtual const XMLCh* getTextContent() const = 0;
virtual void setTextContent(const XMLCh* textContent) = 0;
virtual const XMLCh* lookupNamespacePrefix(const XMLCh* namespaceURI, bool useDefault) const = 0;
virtual bool isDefaultNamespace(const XMLCh* namespaceURI) const = 0;
virtual const XMLCh* lookupNamespaceURI(const XMLCh* prefix) const = 0;
virtual DOMNode* getInterface(const XMLCh* feature) = 0;
};

  //
  // Called to indicate that this Node (and its associated children) is no longer in use
  //  and that the implementation may relinquish any resources associated with it and
  //  its associated children.
  //
  // If this is a document, any nodes it owns (created by DOMDocument::createXXXX())
  //  are also released.
  //
  // Access to a released object will lead to unexpected result.
  //
  // @exception DOMException
  //   INVALID_ACCESS_ERR: Raised if this Node has a parent and thus should not be released yet.
  //
  virtual void                         release() = 0;
};

DOMNodeList.hpp:

class DOMNodeList
{
public:
virtual DOMNode* item(XMLSize_t index) const = 0;
virtual XMLSize_t getLength() const = 0;
};

DOMNamedNodeMap.hpp:

class DOMNamedNodeMap
{
public:
virtual DOMNode* setNamedItem(DOMNode* arg) = 0;
virtual DOMNode* item(XMLSize_t index) const = 0;
virtual DOMNode* getNamedItem(const XMLCh* name) const = 0;
virtual XMLSize_t getLength() const = 0;
virtual DOMNode* removeNamedItem(const XMLCh* name) = 0;
virtual DOMNode* getNamedItemNS(const XMLCh* namespaceURI, const XMLCh* localName) const = 0;
virtual DOMNode* setNamedItemNS(DOMNode* arg) = 0;
virtual DOMNode* removeNamedItemNS(const XMLCh* namespaceURI, const XMLCh* localName) = 0;
};

DOMCharacterData.hpp:

class DOMCharacterData : public DOMNode
{
public:
virtual const XMLCh* getData() const = 0;
virtual XMLSize_t getLength() const = 0;
virtual const XMLCh* substringData(XMLSize_t offset, XMLSize_t count) const = 0;
virtual void appendData(const XMLCh* arg) = 0;
virtual void insertData(XMLSize_t offset, const XMLCh* arg) = 0;
virtual void deleteData(XMLSize_t offset, XMLSize_t count) = 0;
virtual void replaceData(XMLSize_t offset, XMLSize_t count, const XMLCh* arg) = 0;
virtual void setData(const XMLCh* data) = 0;
};

DOMAttr.hpp:

class DOMAttr : public DOMNode
{
public:
virtual const XMLCh* getName() const = 0;
virtual bool getSpecified() const = 0;
virtual const XMLCh* getValue() const = 0;
virtual void setValue(const XMLCh* value) = 0;
virtual DOMElement* getOwnerElement() const = 0;
virtual bool isId() const = 0;
virtual const DOMTypeInfo* getTypeInfo() = 0;
};

DOMElement.hpp:

class DOMElement : public DOMNode
{
public:
virtual const XMLCh* getTagName() const = 0;
virtual const XMLCh* getAttribute(const XMLCh* name) const = 0;
virtual DOMAttr* getAttributeNode(const XMLCh* name) const = 0;
virtual DOMNodeList* getElementsByTagName(const XMLCh* name) const = 0;
virtual void setAttribute(const XMLCh* name, const XMLCh* value) = 0;
virtual DOMAttr* setAttributeNode(DOMAttr *newAttr) = 0;
virtual DOMAttr* removeAttributeNode(DOMAttr* oldAttr) = 0;
virtual void removeAttribute(const XMLCh* name) = 0;
virtual const XMLCh* getAttributeNS(const XMLCh* namespaceURI,
               const XMLCh* localName) const = 0;
virtual void setAttributeNS(const XMLCh* namespaceURI,
               const XMLCh* qualifiedName,
               const XMLCh* value) = 0;
virtual void removeAttributeNS(const XMLCh* namespaceURI,
                  const XMLCh* localName) = 0;
virtual DOMAttr* getAttributeNodeNS(const XMLCh* namespaceURI,
                   const XMLCh* localName) const = 0;
virtual DOMAttr* setAttributeNodeNS(DOMAttr* newAttr) = 0;
virtual DOMNodeList* getElementsByTagNameNS(const XMLCh* namespaceURI,
                       const XMLCh* localName) const = 0;
virtual bool hasAttribute(const XMLCh* name) const = 0;
virtual bool hasAttributeNS(const XMLCh* namespaceURI,
               const XMLCh* localName) const = 0;
virtual void setIdAttribute(const XMLCh* name) = 0;
virtual void setIdAttributeNS(const XMLCh* namespaceURI, const XMLCh* localName) = 0;
virtual void setIdAttributeNode(DOMAttr *newAttr) = 0;
virtual const DOMTypeInfo* getTypeInfo() = 0;
};

DOMText.hpp:

class DOMText : DOMCharacterData
{
public:
virtual DOMText* splitText(XMLSize_t offset) = 0;
virtual bool getIsWhitespaceInElementContent() const = 0;
virtual const XMLCh*  getWholeText() = 0;
virtual DOMText*  replaceWholeText(const XMLCh* content) = 0;
};

DOMComment.hpp:

class DOMComment : DOMCharacterData
{
};

DOMUserDataHandler.hpp:

class DOMUserDataHandler
{
public:
enum DOMOperationType {
NODE_CLONED = 1,
NODE_IMPORTED = 2,
NODE_DELETED = 3,
NODE_RENAMED = 4
};
virtual void handle(DOMOperationType operation,
           const XMLCh* const key,
           void* data,
           const DOMNode* src,
           const DOMNode* dst) = 0;
};

DOMError.hpp:

class DOMError
{
public:
enum ErrorSeverity {
DOM_SEVERITY_WARNING = 0,
DOM_SEVERITY_ERROR = 1,
DOM_SEVERITY_FATAL_ERROR = 2
};
virtual short getSeverity() const = 0;
virtual const XMLCh* getMessage() const = 0;
virtual DOMLocator* getLocation() const = 0;
virtual void* getRelatedException() const = 0;
virtual const XMLCh* getType() const = 0;
virtual void* getRelatedData() const = 0;
virtual void setSeverity(const short severity) = 0;
virtual void setMessage(const XMLCh* const message) = 0;
virtual void setLocation(DOMLocator* const location) = 0
virtual void setRelatedException(void* exception) const = 0;
virtual void setRelatedData(void* relatedData) const = 0;
virtual void setType(const XMLCh* type) const = 0;
};

DOMErrorHandler.hpp:

class DOMErrorHandler
{
public:
virtual bool handleError(const DOMError& domError) = 0;
};

DOMLocator.hpp:

class DOMLocator
{
public:
virtual XMLSSize_t getLineNumber() const = 0;
virtual XMLSSize_t getColumnNumber() const = 0;
virtual XMLSSize_t getOffset() const = 0;
virtual DOMNode* getErrorNode() const = 0;
virtual const XMLCh* getURI() const = 0;
virtual void setLineNumber(const XMLSSize_t lineNumber) = 0;
virtual void setColumnNumber(const XMLSSize_t columnNumber) = 0;
virtual void setOffset(const XMLSSize_t offset) = 0;
virtual void setErrorNode(DOMNode* const errorNode) = 0;
virtual void setURI(const XMLCh* const uri) = 0
};

DOMCDATASection.hpp:

class DOMCDATASection : DOMText
{
};

DOMDocumentType.hpp:

class DOMDocumentType : DOMNode
{
public:
virtual const XMLCh* getName() const = 0;
virtual DOMNamedNodeMap* getEntities() const = 0;
virtual DOMNamedNodeMap* getNotations() const = 0;
virtual const XMLCh* getPublicId() const = 0;
virtual const XMLCh* getSystemId() const = 0;
virtual const XMLCh* getInternalSubset() const = 0;
};

DOMNotation.hpp:

class DOMNotation : DOMNode
{
public:
virtual const XMLCh* getPublicId() const = 0;
virtual const XMLCh* getSystemId() const = 0;
};

DOMEntity.hpp:

class DOMEntity : DOMNode
{
public:
virtual const XMLCh* getPublicId() const = 0;
virtual const XMLCh* getSystemId() const = 0;
virtual const XMLCh* getNotationName() const = 0;
virtual const XMLCh* getActualEncoding() const = 0;
virtual void setActualEncoding(const XMLCh* actualEncoding) = 0;
virtual const XMLCh* getEncoding() const = 0;
virtual void setEncoding(const XMLCh* encoding) = 0;
virtual const XMLCh* getVersion() const = 0;
virtual void setVersion((const XMLCh* version) = 0;
};

DOMEntityReference.hpp:

class DOMEntityReference : DOMNode
{
};

DOMProcessingInstruction.hpp:

class DOMProcessingInstruction : DOMNode
{
public:
virtual const XMLCh* getTarget() const = 0;
virtual const XMLCh* getData() const = 0;
virtual void* setData(const XMLCh* data) = 0;
};

DOMTypeInfo.hpp:

class DOMTypeInfo
{
virtual const XMLCh* getName() = 0;
virtual const XMLCh* getNamespace() = 0;
};

DOMConfiguration.hpp:

class DOMConfiguration
{
virtual void setParameter(const XMLCh* name, const void* value) = 0;
virtual const void* getParameter(const XMLCh* name) const = 0;
virtual bool canSetParameter(const XMLCh* name, const void* value) const = 0;
};

B: Document Object Model: Load and Save

DOMImplementationLS.hpp:

class DOMImplementationLS
{
public:
enum {
MODE_SYNCHRONOUS =1,
MODE_SYNCHRONOUS =2
};
virtual DOMBuilder* createDOMBuilder(const short mode, const XMLCh* const schemaType) = 0;
virtual DOMWriter* createDOMWriter() = 0;
virtual  DOMInputSource*  createDOMInputSource() = 0;
};

DOMInputSource.hpp:

// the byteStream, characterStream and stringData in this class are implementation specific
class DOMInputSource
{
public:
virtual  const XMLCh*  getEncoding() const = 0;
virtual  const XMLCh*  getPublicId() const = 0;
virtual  const XMLCh*  getSystemId() const = 0;
virtual  const XMLCh*  getBaseURI() const = 0;
virtual  const XMLCh*  setEncoding() const = 0;
virtual  const XMLCh*  setPublicId() const = 0;
virtual  const XMLCh*  setSystemId() const = 0;
virtual  const XMLCh*  setBaseURI() const = 0;
  //
  // Called to indicate that this DOMInputSource is no longer in use
  //   and that the implementation may relinquish any resources associated with it.
  //
  // Access to a released object will lead to unexpected result.
  //
  virtual void            release() = 0;
};

DOMEntityResolver.hpp:

class DOMEntityResolver
{
public:
virtual DOMInputSource*  resolverEntity(const XMLCh* const publicId,
               const XMLCh* const systemId
               const XMLCh* const baseURI) = 0;
};

DOMBuilder.hpp:

class DOMBuilder
{
public:
enum ActionType {
ACTION_REPLACE  = 1,
ACTION_APPEND_AS_CHILDREN  = 2,
ACTION_INSERT_AFTER  = 3,
ACTION_INSERT_BEFORE  =4
};
virtual DOMErrorHandler*  getErrorHandler() = 0;
virtual const DOMErrorHandler*  getErrorHandler() const = 0;
virtual DOMEntityResolver* getEntityResolver() = 0;
virtual const DOMEntityResolver* getEntityResolver() const = 0;
virtual DOMBuilderFilter* getFilter() = 0;
virtual const DOMBuilderFilter* getFilter() const = 0;
virtual void  setErrorHandler(DOMErrorHandler* const handler) = 0;
virtual void setEntityResolver(DOMEntityResolver* const handler) = 0;
virtual void setFilter(DOMBuilderFilter* const filter) = 0;
virtual void setFeature(const XMLCh* const name, const bool state) = 0;
virtual bool getFeature(const XMLCh* const name) const = 0;
virtual bool canSetFeature(const XMLCh* const name, const bool state) const = 0;
virtual DOMDocument* parse(const DOMInputSource& source) = 0;
virtual DOMDocument* parseURI(const XMLCh* const systemId) = 0;
virtual void parseWithContext(const DOMInputSource& source,
                 DOMNode* const contextNode,
                 const short action) = 0;
  //
  // Called to indicate that this DOMBuilder is no longer in use
  //   and that the implementation may relinquish any resources associated with it.
  //
  // Access to a released object will lead to unexpected result.
  //
  virtual void            release() = 0;
};

DOMWriter.hpp:

// The XMLFormatTarget is implementation specific
class DOMWriter
{
public:
virtual bool canSetFeature(const XMLCh* const featName, bool state) const = 0;
virtual void setFeature(const XMLCh* const featName, bool state) = 0;
virtual bool getFeature(const XMLCh* const featName) const = 0;
virtual void setEncoding(const XMLCh* const encoding) = 0;
virtual void setNewLine(const XMLCh* const newLine) = 0;
virtual void setErrorHandler(DOMErrorHandler* errorHandler) = 0;
virtual void setFilter(DOMWriterFilter* filter) = 0;
virtual const XMLCh* getEncoding() const = 0;
virtual const XMLCh* getNewLine() const = 0;
virtual DOMErrorHandler* getErrorHandler() const = 0;
virtual DOMWriterFilter*  getFilter() const = 0;
virtual bool writeToNode(XMLFormatTarget* const destination, const DOMNode& nodeToWrite) = 0;
virtual XMLCh* writeToString(const DOMNode& nodeToWrite) = 0;
  //
  // Called to indicate that this DOMWriter is no longer in use
  //   and that the implementation may relinquish any resources associated with it.
  //
  // Access to a released object will lead to unexpected result.
  //
  virtual void            release() = 0;
};

DOMWriterFilter.hpp:

class DOMWriterFilter : DOMNodeFilter
{
public:
virtual unsigned long  getWhatToShow() const = 0;
virtual void setWhatToShow(unsigned long toShow) = 0;
};

C: Document Object Model: XPath

DOMXPathEvaluator.hpp:

classDOMXPathEvaluator
{
public:
virtual const DOMXPathExpression* createExpression(const XMLCh *expression, const DOMXPathNSResolver *resolver) = 0;
virtual const DOMXPathNSResolver* createNSResolver(DOMNode *nodeResolver) = 0;
virtual void* evaluate(const XMLCh *expression, DOMNode *contextNode, const DOMXPathNSResolver *resolver, unsigned short type, void* result) = 0;
};

DOMXPathException.hpp:

classDOMXPathException
{
public:
enum ExceptionCode {
INVALID_EXPRESSION_ERR = 51,
TYPE_ERR = 52,
};
};

DOMXPathExpression.hpp:

class DOMXPathExpression
{
public:
virtual void* evaluate(DOMNode *contextNode, unsigned short type, void* result) const = 0;
};

DOMXPathNamespace.hpp:

classDOMXPathNamespace
{
public:
enum XPathNodeType {
XPATH_NAMESPACE_NODE = 13,
};
virtual DOMElement *getOwnerElement() const = 0;
};

DOMXPathNSResolver.hpp:

class DOMXPathNSResolver
{
public:
virtual const XMLCh* lookupNamespaceURI(const XMLCh* prefix) const = 0;
virtual const XMLCh* lookupPrefix(const XMLCh* URI) const = 0;
};

DOMXPathResult.hpp:

class DOMXPathResult
{
public:
enum resultType {
ANY_TYPE = 0,
NUMBER_TYPE = 1,
STRING_TYPE = 2,
BOOLEAN_TYPE = 3,
UNORDERED_NODE_ITERATOR_TYPE = 4,
ORDERED_NODE_ITERATOR_TYPE = 5,
UNORDERED_NODE_SNAPSHOT_TYPE = 6,
ORDERED_NODE_SNAPSHOT_TYPE = 7,
ANY_UNORDERED_NODE_TYPE = 8,
FIRST_ORDERED_NODE_TYPE = 9,
};
virtual bool getBooleanValue() const = 0;
virtual bool getInvalidIteratorState() const = 0;
virtual double getNumberValue() const = 0;
virtual short getResultType() const = 0;
virtual DOMNode *getSingleNodeValue() const = 0;
virtual unsigned long getSnapshotLength() const = 0;
virtual const XMLCh* getStringValue() const = 0;
virtual DOMNode* iterateNext() const = 0;
virtual DOMNode* snapshotItem(unsigned long index) const = 0;
};
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.