# 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.

- typedef unsigned int XMLCh

3. XMLSize_t is an implementation-dependent unsigned integral type

- typedef size_t XMLSize_t

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 © 2001 The Apache Software Foundation. All Rights Reserved.