DOMDocument interface represents the entire XML
* document. Conceptually, it is the root of the document tree, and provides
* the primary access to the document's data.
* Since elements, text nodes, comments, processing instructions, etc.
* cannot exist outside the context of a DOMDocument, the
* DOMDocument interface also contains the factory methods needed
* to create these objects. The DOMNode objects created have a
* ownerDocument attribute which associates them with the
* DOMDocument within whose context they were created.
*
See also the Document Object Model (DOM) Level 2 Core Specification.
*/
class CDOM_EXPORT DOMDocument: public DOMDocumentRange,
public DOMXPathEvaluator,
public DOMDocumentTraversal,
public DOMNode {
protected:
// -----------------------------------------------------------------------
// Hidden constructors
// -----------------------------------------------------------------------
/** @name Hidden constructors */
//@{
DOMDocument() {};
//@}
private:
// -----------------------------------------------------------------------
// Unimplemented constructors and operators
// -----------------------------------------------------------------------
/** @name Unimplemented constructors and operators */
//@{
DOMDocument(const DOMDocument &);
DOMDocument & operator = (const DOMDocument &);
//@}
public:
// -----------------------------------------------------------------------
// All constructors are hidden, just the destructor is available
// -----------------------------------------------------------------------
/** @name Destructor */
//@{
/**
* Destructor
*
*/
virtual ~DOMDocument() {};
//@}
// -----------------------------------------------------------------------
// Virtual DOMDocument interface
// -----------------------------------------------------------------------
/** @name Functions introduced in DOM Level 1 */
//@{
/**
* Creates an element of the type specified. Note that the instance
* returned implements the DOMElement interface, so attributes
* can be specified directly on the returned object.
*
In addition, if there are known attributes with default values,
* DOMAttr nodes representing them are automatically created
* and attached to the element.
*
To create an element with a qualified name and namespace URI, use
* the createElementNS method.
* @param tagName The name of the element type to instantiate. For XML,
* this is case-sensitive.
* @return A new DOMElement object with the
* nodeName attribute set to tagName, and
* localName, prefix, and
* namespaceURI set to null.
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
* @since DOM Level 1
*/
virtual DOMElement *createElement(const XMLCh *tagName) = 0;
/**
* Creates an empty DOMDocumentFragment object.
* @return A new DOMDocumentFragment.
* @since DOM Level 1
*/
virtual DOMDocumentFragment *createDocumentFragment() = 0;
/**
* Creates a DOMText node given the specified string.
* @param data The data for the node.
* @return The new DOMText object.
* @since DOM Level 1
*/
virtual DOMText *createTextNode(const XMLCh *data) = 0;
/**
* Creates a DOMComment node given the specified string.
* @param data The data for the node.
* @return The new DOMComment object.
* @since DOM Level 1
*/
virtual DOMComment *createComment(const XMLCh *data) = 0;
/**
* Creates a DOMCDATASection node whose value is the specified
* string.
* @param data The data for the DOMCDATASection contents.
* @return The new DOMCDATASection object.
* @since DOM Level 1
*/
virtual DOMCDATASection *createCDATASection(const XMLCh *data) = 0;
/**
* Creates a DOMProcessingInstruction node given the specified
* name and data strings.
* @param target The target part of the processing instruction.
* @param data The data for the node.
* @return The new DOMProcessingInstruction object.
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified target contains an
* illegal character.
* @since DOM Level 1
*/
virtual DOMProcessingInstruction *createProcessingInstruction(const XMLCh *target,
const XMLCh *data) = 0;
/**
* Creates an DOMAttr of the given name. Note that the
* DOMAttr instance can then be set on an DOMElement
* using the setAttributeNode method.
*
To create an attribute with a qualified name and namespace URI, use
* the createAttributeNS method.
* @param name The name of the attribute.
* @return A new DOMAttr object with the nodeName
* attribute set to name, and localName,
* prefix, and namespaceURI set to
* null. The value of the attribute is the empty string.
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
* @since DOM Level 1
*/
virtual DOMAttr *createAttribute(const XMLCh *name) = 0;
/**
* Creates an DOMEntityReference object. In addition, if the
* referenced entity is known, the child list of the
* DOMEntityReference node is made the same as that of the
* corresponding DOMEntity node.If any descendant of the
* DOMEntity node has an unbound namespace prefix, the
* corresponding descendant of the created DOMEntityReference
* node is also unbound; (its namespaceURI is
* null). The DOM Level 2 does not support any mechanism to
* resolve namespace prefixes.
* @param name The name of the entity to reference.
* @return The new DOMEntityReference object.
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
* @since DOM Level 1
*/
virtual DOMEntityReference *createEntityReference(const XMLCh *name) = 0;
/**
* The Document Type Declaration (see DOMDocumentType)
* associated with this document. For XML
* documents without a document type declaration this returns
* null. The DOM Level 2 does not support editing the
* Document Type Declaration. docType cannot be altered in
* any way, including through the use of methods inherited from the
* DOMNode interface, such as insertNode or
* removeNode.
* @since DOM Level 1
*/
virtual DOMDocumentType *getDoctype() const = 0;
/**
* The DOMImplementation object that handles this document. A
* DOM application may use objects from multiple implementations.
* @since DOM Level 1
*/
virtual DOMImplementation *getImplementation() const = 0;
/**
* This is a convenience attribute that allows direct access to the child
* node that is the root element of the document.
* @since DOM Level 1
*/
virtual DOMElement *getDocumentElement() const = 0;
/**
* Returns a DOMNodeList of all the DOMElement(s) with a
* given tag name in the order in which they are encountered in a
* preorder traversal of the DOMDocument tree.
*
* The returned node list is "live", in that changes
* to the document tree made after a nodelist was initially
* returned will be immediately reflected in the node list.
* @param tagname The name of the tag to match on. The special value "*"
* matches all tags.
* @return A new DOMNodeList object containing all the matched
* DOMElement(s).
* @since DOM Level 1
*/
virtual DOMNodeList *getElementsByTagName(const XMLCh *tagname) const = 0;
//@}
/** @name Functions introduced in DOM Level 2. */
//@{
/**
* Imports a node from another document to this document. The returned
* node has no parent; (parentNode is null).
* The source node is not altered or removed from the original document;
* this method creates a new copy of the source node.
*
For all nodes, importing a node creates a node object owned by the
* importing document, with attribute values identical to the source
* node's nodeName and nodeType, plus the
* attributes related to namespaces (prefix,
* localName, and namespaceURI). As in the
* cloneNode operation on a DOMNode, the source
* node is not altered.
*
Additional information is copied as appropriate to the
* nodeType, attempting to mirror the behavior expected if
* a fragment of XML source was copied from one document to
* another, recognizing that the two documents may have different DTDs
* in the XML case. The following list describes the specifics for each
* type of node.
*
ownerElement attribute
* is set to null and the specified flag is
* set to true on the generated DOMAttr. The
* descendants of the source DOMAttr are recursively imported
* and the resulting nodes reassembled to form the corresponding subtree.
* Note that the deep parameter has no effect on
* DOMAttr nodes; they always carry their children with them
* when imported.deep option
* was set to true, the descendants of the source element
* are recursively imported and the resulting nodes reassembled to form
* the corresponding subtree. Otherwise, this simply generates an empty
* DOMDocumentFragment.DOMDocument
* nodes cannot be imported.DOMDocumentType
* nodes cannot be imported.DOMAttr
* nodes are attached to the generated DOMElement. Default
* attributes are not copied, though if the document being imported into
* defines default attributes for this element name, those are assigned.
* If the importNode deep parameter was set to
* true, the descendants of the source element are
* recursively imported and the resulting nodes reassembled to form the
* corresponding subtree.DOMEntity nodes can be
* imported, however in the current release of the DOM the
* DOMDocumentType is readonly. Ability to add these imported
* nodes to a DOMDocumentType will be considered for addition
* to a future release of the DOM.On import, the publicId,
* systemId, and notationName attributes are
* copied. If a deep import is requested, the descendants
* of the the source DOMEntity are recursively imported and
* the resulting nodes reassembled to form the corresponding subtree.DOMEntityReference itself is
* copied, even if a deep import is requested, since the
* source and destination documents might have defined the entity
* differently. If the document being imported into provides a
* definition for this entity name, its value is assigned.DOMNotation nodes can be imported, however in the current
* release of the DOM the DOMDocumentType is readonly. Ability
* to add these imported nodes to a DOMDocumentType will be
* considered for addition to a future release of the DOM.On import, the
* publicId and systemId attributes are copied.
* Note that the deep parameter has no effect on
* DOMNotation nodes since they never have any children.target and data values from those of the
* source node.DOMCharacterData copy their
* data and length attributes from those of
* the source node.true, recursively import the subtree under
* the specified node; if false, import only the node
* itself, as explained above. This has no effect on DOMAttr
* , DOMEntityReference, and DOMNotation nodes.
* @return The imported node that belongs to this DOMDocument.
* @exception DOMException
* NOT_SUPPORTED_ERR: Raised if the type of node being imported is not
* supported.
* @since DOM Level 2
*/
virtual DOMNode *importNode(DOMNode *importedNode, bool deep) = 0;
/**
* Creates an element of the given qualified name and namespace URI.
* @param namespaceURI The namespace URI of the element to create.
* @param qualifiedName The qualified name of the element type to
* instantiate.
* @return A new DOMElement object with the following
* attributes:
* Attribute |
*
* Value |
*
DOMNode.nodeName |
*
* qualifiedName |
*
DOMNode.namespaceURI |
*
* namespaceURI |
*
DOMNode.prefix |
* prefix, extracted
* from qualifiedName, or null if there is
* no prefix |
*
DOMNode.localName |
* local name, extracted from
* qualifiedName |
*
DOMElement.tagName |
*
* qualifiedName |
*
qualifiedName is
* malformed per the Namespaces in XML specification, if the
* qualifiedName has a prefix and the
* namespaceURI is null, or if the
* qualifiedName has a prefix that is "xml" and the
* namespaceURI is different from "
* http://www.w3.org/XML/1998/namespace" .
* "XML" feature, since namespaces were
* defined by XML.
* @since DOM Level 2
*/
virtual DOMElement *createElementNS(const XMLCh *namespaceURI,
const XMLCh *qualifiedName) = 0;
/**
* Creates an attribute of the given qualified name and namespace URI.
* @param namespaceURI The namespace URI of the attribute to create.
* @param qualifiedName The qualified name of the attribute to
* instantiate.
* @return A new DOMAttr object with the following attributes:
* Attribute |
*
* Value |
*
DOMNode.nodeName |
* qualifiedName | *
* DOMNode.namespaceURI |
* namespaceURI |
*
* DOMNode.prefix |
* prefix, extracted from
* qualifiedName, or null if there is no
* prefix |
*
DOMNode.localName |
* local name, extracted from
* qualifiedName |
*
DOMAttr.name |
*
* qualifiedName |
*
DOMNode.nodeValue |
* the empty * string | *
qualifiedName is
* malformed per the Namespaces in XML specification, if the
* qualifiedName has a prefix and the
* namespaceURI is null, if the
* qualifiedName has a prefix that is "xml" and the
* namespaceURI is different from "
* http://www.w3.org/XML/1998/namespace", or if the
* qualifiedName, or its prefix, is "xmlns" and the
* namespaceURI is different from "
* http://www.w3.org/2000/xmlns/".
* "XML" feature, since namespaces were
* defined by XML.
* @since DOM Level 2
*/
virtual DOMAttr *createAttributeNS(const XMLCh *namespaceURI,
const XMLCh *qualifiedName) = 0;
/**
* Returns a DOMNodeList of all the DOMElement(s) with a
* given local name and namespace URI in the order in which they are
* encountered in a preorder traversal of the DOMDocument tree.
* @param namespaceURI The namespace URI of the elements to match on. The
* special value "*" matches all namespaces.
* @param localName The local name of the elements to match on. The
* special value "*" matches all local names.
* @return A new DOMNodeList object containing all the matched
* DOMElement(s).
* @since DOM Level 2
*/
virtual DOMNodeList *getElementsByTagNameNS(const XMLCh *namespaceURI,
const XMLCh *localName) const = 0;
/**
* Returns the DOMElement whose ID is given by
* elementId. If no such element exists, returns
* null. Behavior is not defined if more than one element
* has this ID. The DOM implementation must have
* information that says which attributes are of type ID. Attributes
* with the name "ID" are not of type ID unless so defined.
* Implementations that do not know whether attributes are of type ID or
* not are expected to return null.
* @param elementId The unique id value for an element.
* @return The matching element.
* @since DOM Level 2
*/
virtual DOMElement * getElementById(const XMLCh *elementId) const = 0;
//@}
/** @name Functions introduced in DOM Level 3. */
//@{
/**
* An attribute specifying the actual encoding of this document. This is
* null otherwise.
* "Experimental - subject to change"
* * @since DOM Level 3 */ virtual const XMLCh* getActualEncoding() const = 0; /** * An attribute specifying the actual encoding of this document. This is *null otherwise.
* "Experimental - subject to change"
* * @since DOM Level 3 */ virtual void setActualEncoding(const XMLCh* actualEncoding) = 0; /** * An attribute specifying, as part of the XML declaration, the encoding * of this document. This isnull when unspecified.
*
* "Experimental - subject to change"
* * @since DOM Level 3 */ virtual const XMLCh* getEncoding() const = 0; /** * An attribute specifying, as part of the XML declaration, the encoding * of this document. This isnull when unspecified.
*
* "Experimental - subject to change"
* * @since DOM Level 3 */ virtual void setEncoding(const XMLCh* encoding) = 0; /** * An attribute specifying, as part of the XML declaration, whether this * document is standalone. *"Experimental - subject to change"
* * @since DOM Level 3 */ virtual bool getStandalone() const = 0; /** * An attribute specifying, as part of the XML declaration, whether this * document is standalone. *"Experimental - subject to change"
* * @since DOM Level 3 */ virtual void setStandalone(bool standalone) = 0; /** * An attribute specifying, as part of the XML declaration, the version * number of this document. This isnull when unspecified.
* "Experimental - subject to change"
* * @since DOM Level 3 */ virtual const XMLCh* getVersion() const = 0; /** * An attribute specifying, as part of the XML declaration, the version * number of this document. This isnull when unspecified.
* "Experimental - subject to change"
* * @since DOM Level 3 */ virtual void setVersion(const XMLCh* version) = 0; /** * The location of the document ornull if undefined.
* DOMDocument supports the feature
* "HTML" , the href attribute of the HTML BASE element takes precedence
* over this attribute.
*
* "Experimental - subject to change"
* * @since DOM Level 3 */ virtual const XMLCh* getDocumentURI() const = 0; /** * The location of the document ornull if undefined.
* DOMDocument supports the feature
* "HTML" , the href attribute of the HTML BASE element takes precedence
* over this attribute.
*
* "Experimental - subject to change"
* * @since DOM Level 3 */ virtual void setDocumentURI(const XMLCh* documentURI) = 0; /** * An attribute specifying whether errors checking is enforced or not. * When set tofalse, the implementation is free to not
* test every possible error case normally defined on DOM operations,
* and not raise any DOMException. In case of error, the
* behavior is undefined. This attribute is true by
* defaults.
*
* "Experimental - subject to change"
* * @since DOM Level 3 */ virtual bool getStrictErrorChecking() const = 0; /** * An attribute specifying whether errors checking is enforced or not. * When set tofalse, the implementation is free to not
* test every possible error case normally defined on DOM operations,
* and not raise any DOMException. In case of error, the
* behavior is undefined. This attribute is true by
* defaults.
*
* "Experimental - subject to change"
* * @since DOM Level 3 */ virtual void setStrictErrorChecking(bool strictErrorChecking) = 0; /** * Rename an existing node. When possible this simply changes the name of * the given node, otherwise this creates a new node with the specified * name and replaces the existing node with the new node as described * below. This only applies to nodes of typeELEMENT_NODE
* and ATTRIBUTE_NODE.
* DOMElement its attributes are moved to the new node, the
* new node is inserted at the position the old node used to have in its
* parent's child nodes list if it has one, the user data that was
* attached to the old node is attach to the new node, the user data
* event NODE_RENAMED is fired.
* DOMAttr that is
* attached to an DOMElement, the node is first removed from
* the DOMElement attributes map. Then, once renamed, either
* by modifying the existing node or creating a new one as described
* above, it is put back.
*
* "Experimental - subject to change"
* * @param n The node to rename. * @param namespaceURI The new namespaceURI. * @param name The new qualified name. * @return The renamed node. This is either the specified node or the new * node that was created to replace the specified node. * @exception DOMException * NOT_SUPPORTED_ERR: Raised when the type of the specified node is * neitherELEMENT_NODE nor ATTRIBUTE_NODE.
* qualifiedName is
* malformed per the Namespaces in XML specification, if the
* qualifiedName has a prefix and the
* namespaceURI is null, or if the
* qualifiedName has a prefix that is "xml" and the
* namespaceURI is different from "
* http://www.w3.org/XML/1998/namespace" . Also raised, when the node
* being renamed is an attribute, if the qualifiedName,
* or its prefix, is "xmlns" and the namespaceURI is
* different from "http://www.w3.org/2000/xmlns/".
* @since DOM Level 3
*/
virtual DOMNode* renameNode(DOMNode* n, const XMLCh* namespaceURI, const XMLCh* name) = 0;
/**
* Changes the ownerDocument of a node, its children, as well
* as the attached attribute nodes if there are any. If the node has a
* parent it is first removed from its parent child list. This
* effectively allows moving a subtree from one document to another. The
* following list describes the specifics for each type of node.
*
* "Experimental - subject to change"
* *ownerElement attribute is set to
* null and the specified flag is set to
* true on the adopted DOMAttr. The descendants
* of the source DOMAttr are recursively adopted.DOMDocument nodes cannot
* be adopted.DOMDocumentType nodes cannot
* be adopted.DOMAttr nodes.
* Default attributes are discarded, though if the document being
* adopted into defines default attributes for this element name, those
* are assigned. The descendants of the source element are recursively
* adopted.DOMEntity nodes cannot be adopted.DOMEntityReference node
* itself is adopted, the descendants are discarded, since the source
* and destination documents might have defined the entity differently.
* If the document being imported into provides a definition for this
* entity name, its value is assigned.DOMNotation
* nodes cannot be adopted.null if this operation
* fails, such as when the source node comes from a different
* implementation.
* @exception DOMException
* NOT_SUPPORTED_ERR: Raised if the source node is of type
* DOCUMENT, DOCUMENT_TYPE.
* DOMConfiguration for
* details.
*
* "Experimental - subject to change"
* *DOMText nodes, makes
* the document "namespace wellformed", according to the algorithm
* described below in pseudo code, by adding missing namespace
* declaration attributes and adding or changing namespace prefixes,
* updates the replacement tree of DOMEntityReference nodes,
* normalizes attribute values, etc.
* DOMAttr and DOMText nodes are normalized.
* Features to remove DOMComment and DOMCDATASection work.
* The feature to normalize namespaces is implemented. This feature is called
* "namespaces" and is incorectly documented in the current WD.
* @since DOM Level 3
*
*/
virtual void normalizeDocument() = 0;
/**
* The configuration used when Document.normalizeDocument is invoked.
*
* @return The DOMConfiguration from this DOMDocument
*
* Note that this is a partial implementation. Not all the required features are
* implemented and this is only used by normalizeDocument.
* Currently DOMAttr and DOMText nodes are normalized.
* Features to remove DOMComment and DOMCDATASection work.
* The feature to normalize namespaces is implemented. This feature is called
* "namespaces" and is incorectly documented in the current WD.
*
* "Experimental - subject to change"
* @since DOM Level 3 */ virtual DOMConfiguration* getDOMConfiguration() const = 0; // ----------------------------------------------------------------------- // Non-standard extension // ----------------------------------------------------------------------- /** @name Non-standard extension */ //@{ /** * Non-standard extension * * Create a new entity. * @param name The name of the entity to instantiate * */ virtual DOMEntity *createEntity(const XMLCh *name) = 0; /** * Non-standard extension * * Create a DOMDocumentType node. * @return ADOMDocumentType that references the newly
* created DOMDocumentType node.
*
*/
virtual DOMDocumentType *createDocumentType(const XMLCh *name) = 0;
/**
* Non-standard extension.
*
* Create a Notation.
* @param name The name of the notation to instantiate
* @return A DOMNotation that references the newly
* created DOMNotation node.
*/
virtual DOMNotation *createNotation(const XMLCh *name) = 0;
/**
* Non-standard extension.
*
* Creates an element of the given qualified name and
* namespace URI, and also stores line/column number info.
* Used by internally XSDXercesDOMParser during schema traversal.
*
* @see createElementNS(const XMLCh *namespaceURI, const XMLCh *qualifiedName)
*/
virtual DOMElement *createElementNS(const XMLCh *namespaceURI,
const XMLCh *qualifiedName,
const XMLSSize_t lineNum,
const XMLSSize_t columnNum) = 0;
//@}
};
XERCES_CPP_NAMESPACE_END
#endif