Xerces-C++  3.2.3
DOMDocument.hpp
Go to the documentation of this file.
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 /*
19  * $Id$
20 */
21 
22 #if !defined(XERCESC_INCLUDE_GUARD_DOMDOCUMENT_HPP)
23 #define XERCESC_INCLUDE_GUARD_DOMDOCUMENT_HPP
24 
26 #include <xercesc/dom/DOMNode.hpp>
30 
32 
33 class DOMConfiguration;
34 class DOMDocumentType;
35 class DOMElement;
37 class DOMComment;
38 class DOMCDATASection;
40 class DOMAttr;
41 class DOMEntity;
42 class DOMEntityReference;
43 class DOMImplementation;
44 class DOMNodeFilter;
45 class DOMNodeList;
46 class DOMNotation;
47 class DOMText;
48 class DOMNode;
49 
50 
65  public DOMXPathEvaluator,
66  public DOMDocumentTraversal,
67  public DOMNode {
68 
69 
70 protected:
71  // -----------------------------------------------------------------------
72  // Hidden constructors
73  // -----------------------------------------------------------------------
78 
79 private:
80  // -----------------------------------------------------------------------
81  // Unimplemented constructors and operators
82  // -----------------------------------------------------------------------
85  DOMDocument(const DOMDocument &);
86  DOMDocument & operator = (const DOMDocument &);
88 
89 public:
90  // -----------------------------------------------------------------------
91  // All constructors are hidden, just the destructor is available
92  // -----------------------------------------------------------------------
99  virtual ~DOMDocument() {};
101 
102  // -----------------------------------------------------------------------
103  // Virtual DOMDocument interface
104  // -----------------------------------------------------------------------
127  virtual DOMElement *createElement(const XMLCh *tagName) = 0;
128 
135 
142  virtual DOMText *createTextNode(const XMLCh *data) = 0;
143 
150  virtual DOMComment *createComment(const XMLCh *data) = 0;
151 
159  virtual DOMCDATASection *createCDATASection(const XMLCh *data) = 0;
160 
173  const XMLCh *data) = 0;
174 
175 
192  virtual DOMAttr *createAttribute(const XMLCh *name) = 0;
193 
194 
212  virtual DOMEntityReference *createEntityReference(const XMLCh *name) = 0;
213 
225  virtual DOMDocumentType *getDoctype() const = 0;
226 
232  virtual DOMImplementation *getImplementation() const = 0;
233 
239  virtual DOMElement *getDocumentElement() const = 0;
240 
255  virtual DOMNodeList *getElementsByTagName(const XMLCh *tagname) const = 0;
256 
258 
261 
360  virtual DOMNode *importNode(const DOMNode *importedNode, bool deep) = 0;
361 
417  virtual DOMElement *createElementNS(const XMLCh *namespaceURI,
418  const XMLCh *qualifiedName) = 0;
419 
482  virtual DOMAttr *createAttributeNS(const XMLCh *namespaceURI,
483  const XMLCh *qualifiedName) = 0;
484 
497  virtual DOMNodeList *getElementsByTagNameNS(const XMLCh *namespaceURI,
498  const XMLCh *localName) const = 0;
499 
513  virtual DOMElement * getElementById(const XMLCh *elementId) const = 0;
515 
518 
525  virtual const XMLCh* getInputEncoding() const = 0;
526 
534  virtual const XMLCh* getXmlEncoding() const = 0;
535 
542  virtual bool getXmlStandalone() const = 0;
543 
551  virtual void setXmlStandalone(bool standalone) = 0;
552 
560  virtual const XMLCh* getXmlVersion() const = 0;
561 
569  virtual void setXmlVersion(const XMLCh* version) = 0;
570 
579  virtual const XMLCh* getDocumentURI() const = 0;
588  virtual void setDocumentURI(const XMLCh* documentURI) = 0;
589 
600  virtual bool getStrictErrorChecking() const = 0;
611  virtual void setStrictErrorChecking(bool strictErrorChecking) = 0;
612 
657  virtual DOMNode* renameNode(DOMNode* n, const XMLCh* namespaceURI, const XMLCh* qualifiedName) = 0;
658 
659 
719  virtual DOMNode* adoptNode(DOMNode* source) = 0;
720 
741  virtual void normalizeDocument() = 0;
742 
743 
751  virtual DOMConfiguration* getDOMConfig() const = 0;
752 
754 
755  // -----------------------------------------------------------------------
756  // Non-standard extension
757  // -----------------------------------------------------------------------
767  virtual DOMEntity *createEntity(const XMLCh *name) = 0;
768 
777  virtual DOMDocumentType *createDocumentType(const XMLCh *name) = 0;
778 
779  /***
780  * Provide default implementation to maintain source code compatibility
781  ***/
782  virtual DOMDocumentType* createDocumentType(const XMLCh *qName,
783  const XMLCh*, //publicId,
784  const XMLCh* //systemId
785  )
786  {
787  return createDocumentType(qName);
788  }
789 
798  virtual DOMNotation *createNotation(const XMLCh *name) = 0;
799 
809  virtual DOMElement *createElementNS(const XMLCh *namespaceURI,
810  const XMLCh *qualifiedName,
811  const XMLFileLoc lineNum,
812  const XMLFileLoc columnNum) = 0;
814 
815 };
816 
818 
819 #endif
DOMDocument::getInputEncoding
virtual const XMLCh * getInputEncoding() const =0
An attribute specifying the encoding used for this document at the time of the parsing.
DOMDocument::createEntityReference
virtual DOMEntityReference * createEntityReference(const XMLCh *name)=0
Creates an DOMEntityReference object.
DOMConfiguration
The DOMConfiguration interface represents the configuration of a document and maintains a table of re...
Definition: DOMConfiguration.hpp:351
DOMDocument::createAttribute
virtual DOMAttr * createAttribute(const XMLCh *name)=0
Creates an DOMAttr of the given name.
DOMDocument::getDocumentURI
virtual const XMLCh * getDocumentURI() const =0
The location of the document or null if undefined.
XERCES_CPP_NAMESPACE_BEGIN
#define XERCES_CPP_NAMESPACE_BEGIN
Definition: XercesDefs.hpp:112
CDOM_EXPORT
#define CDOM_EXPORT
Definition: XercesDefs.hpp:166
XMLCh
char16_t XMLCh
Definition: Xerces_autoconf_config.hpp:120
DOMXPathEvaluator
The evaluation of XPath expressions is provided by DOMXPathEvaluator.
Definition: DOMXPathEvaluator.hpp:48
DOMDocumentType
Each DOMDocument has a doctype attribute whose value is either null or a DOMDocumentType object.
Definition: DOMDocumentType.hpp:45
DOMDocument::getElementsByTagName
virtual DOMNodeList * getElementsByTagName(const XMLCh *tagname) const =0
Returns a DOMNodeList of all the DOMElement(s) with a given tag name in the order in which they are e...
DOMDocument::createNotation
virtual DOMNotation * createNotation(const XMLCh *name)=0
Non-standard extension.
DOMDocument::getStrictErrorChecking
virtual bool getStrictErrorChecking() const =0
An attribute specifying whether errors checking is enforced or not.
DOMDocument::setStrictErrorChecking
virtual void setStrictErrorChecking(bool strictErrorChecking)=0
An attribute specifying whether errors checking is enforced or not.
DOMDocument::getDOMConfig
virtual DOMConfiguration * getDOMConfig() const =0
The configuration used when DOMDocument::normalizeDocument is invoked.
XERCES_CPP_NAMESPACE_END
#define XERCES_CPP_NAMESPACE_END
Definition: XercesDefs.hpp:113
DOMProcessingInstruction
The DOMProcessingInstruction interface represents a "processing instruction", used in XML as a way to...
Definition: DOMProcessingInstruction.hpp:38
DOMEntity
This interface represents an entity, either parsed or unparsed, in an XML document.
Definition: DOMEntity.hpp:66
DOMDocumentTraversal
DOMDocumentTraversal contains methods that create DOMNodeIterators and DOMTreeWalkers to traverse a n...
Definition: DOMDocumentTraversal.hpp:47
DOMComment
This interface inherits from CharacterData and represents the content of a comment,...
Definition: DOMComment.hpp:39
DOMNode.hpp
DOMDocument::~DOMDocument
virtual ~DOMDocument()
Destructor.
Definition: DOMDocument.hpp:99
DOMDocument
The DOMDocument interface represents the entire XML document.
Definition: DOMDocument.hpp:67
DOMDocument::DOMDocument
DOMDocument()
Definition: DOMDocument.hpp:76
DOMDocument::createDocumentType
virtual DOMDocumentType * createDocumentType(const XMLCh *qName, const XMLCh *, const XMLCh *)
Definition: DOMDocument.hpp:782
XMLFileLoc
XMLUInt64 XMLFileLoc
Definition: Xerces_autoconf_config.hpp:144
DOMDocumentRange.hpp
DOMDocumentTraversal.hpp
DOMDocument::createProcessingInstruction
virtual DOMProcessingInstruction * createProcessingInstruction(const XMLCh *target, const XMLCh *data)=0
Creates a DOMProcessingInstruction node given the specified name and data strings.
DOMDocument::createTextNode
virtual DOMText * createTextNode(const XMLCh *data)=0
Creates a DOMText node given the specified string.
DOMDocumentRange
Definition: DOMDocumentRange.hpp:37
DOMDocument::getElementById
virtual DOMElement * getElementById(const XMLCh *elementId) const =0
Returns the DOMElement whose ID is given by elementId.
DOMXPathEvaluator.hpp
DOMDocument::createEntity
virtual DOMEntity * createEntity(const XMLCh *name)=0
Non-standard extension.
DOMEntityReference
DOMEntityReference objects may be inserted into the structure model when an entity reference is in th...
Definition: DOMEntityReference.hpp:57
DOMDocument::createElementNS
virtual DOMElement * createElementNS(const XMLCh *namespaceURI, const XMLCh *qualifiedName)=0
Creates an element of the given qualified name and namespace URI.
DOMDocument::getDocumentElement
virtual DOMElement * getDocumentElement() const =0
This is a convenience attribute that allows direct access to the child node that is the root element ...
DOMDocument::getDoctype
virtual DOMDocumentType * getDoctype() const =0
The Document Type Declaration (see DOMDocumentType) associated with this document.
DOMDocument::getXmlStandalone
virtual bool getXmlStandalone() const =0
An attribute specifying, as part of the XML declaration, whether this document is standalone.
DOMDocumentFragment
DOMDocumentFragment is a "lightweight" or "minimal" DOMDocument object.
Definition: DOMDocumentFragment.hpp:71
DOMText
The DOMText interface inherits from DOMCharacterData and represents the textual content (termed chara...
Definition: DOMText.hpp:51
DOMDocument::importNode
virtual DOMNode * importNode(const DOMNode *importedNode, bool deep)=0
Imports a node from another document to this document.
DOMDocument::createElement
virtual DOMElement * createElement(const XMLCh *tagName)=0
Creates an element of the type specified.
DOMNodeList
The DOMNodeList interface provides the abstraction of an ordered collection of nodes.
Definition: DOMNodeList.hpp:45
DOMDocument::normalizeDocument
virtual void normalizeDocument()=0
This method acts as if the document was going through a save and load cycle, putting the document in ...
DOMDocument::getElementsByTagNameNS
virtual DOMNodeList * getElementsByTagNameNS(const XMLCh *namespaceURI, const XMLCh *localName) const =0
Returns a DOMNodeList of all the DOMElement(s) with a given local name and namespace URI in the order...
DOMAttr
The DOMAttr class refers to an attribute of an XML element.
Definition: DOMAttr.hpp:57
DOMDocument::renameNode
virtual DOMNode * renameNode(DOMNode *n, const XMLCh *namespaceURI, const XMLCh *qualifiedName)=0
Rename an existing node.
DOMDocument::createAttributeNS
virtual DOMAttr * createAttributeNS(const XMLCh *namespaceURI, const XMLCh *qualifiedName)=0
Creates an attribute of the given qualified name and namespace URI.
DOMDocument::createComment
virtual DOMComment * createComment(const XMLCh *data)=0
Creates a DOMComment node given the specified string.
XercesDefs.hpp
DOMDocument::getImplementation
virtual DOMImplementation * getImplementation() const =0
The DOMImplementation object that handles this document.
DOMDocument::setXmlStandalone
virtual void setXmlStandalone(bool standalone)=0
An attribute specifying, as part of the XML declaration, whether this document is standalone.
DOMElement
By far the vast majority of objects (apart from text) that authors encounter when traversing a docume...
Definition: DOMElement.hpp:66
DOMDocument::adoptNode
virtual DOMNode * adoptNode(DOMNode *source)=0
Changes the ownerDocument of a node, its children, as well as the attached attribute nodes if there a...
DOMDocument::createDocumentType
virtual DOMDocumentType * createDocumentType(const XMLCh *name)=0
Non-standard extension.
DOMDocument::createCDATASection
virtual DOMCDATASection * createCDATASection(const XMLCh *data)=0
Creates a DOMCDATASection node whose value is the specified string.
DOMDocument::setXmlVersion
virtual void setXmlVersion(const XMLCh *version)=0
An attribute specifying, as part of the XML declaration, the version number of this document.
DOMDocument::createElementNS
virtual DOMElement * createElementNS(const XMLCh *namespaceURI, const XMLCh *qualifiedName, const XMLFileLoc lineNum, const XMLFileLoc columnNum)=0
Non-standard extension.
DOMNotation
This interface represents a notation declared in the DTD.
Definition: DOMNotation.hpp:44
DOMImplementation
The DOMImplementation interface provides a number of methods for performing operations that are indep...
Definition: DOMImplementation.hpp:44
DOMDocument::getXmlVersion
virtual const XMLCh * getXmlVersion() const =0
An attribute specifying, as part of the XML declaration, the version number of this document.
DOMCDATASection
CDATA sections are used to escape blocks of text containing characters that would otherwise be regard...
Definition: DOMCDATASection.hpp:65
DOMDocument::createDocumentFragment
virtual DOMDocumentFragment * createDocumentFragment()=0
Creates an empty DOMDocumentFragment object.
DOMDocument::getXmlEncoding
virtual const XMLCh * getXmlEncoding() const =0
An attribute specifying, as part of the XML declaration, the encoding of this document.
DOMNodeFilter
Filters are objects that know how to "filter out" nodes.
Definition: DOMNodeFilter.hpp:50
DOMNode
The DOMNode interface is the primary datatype for the entire Document Object Model.
Definition: DOMNode.hpp:139
DOMDocument::setDocumentURI
virtual void setDocumentURI(const XMLCh *documentURI)=0
The location of the document or null if undefined.