Xerces-C++  3.1.3
AbstractDOMParser.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: AbstractDOMParser.hpp 932887 2010-04-11 13:04:59Z borisk $
20  */
21 
22 #if !defined(XERCESC_INCLUDE_GUARD_ABSTRACTDOMPARSER_HPP)
23 #define XERCESC_INCLUDE_GUARD_ABSTRACTDOMPARSER_HPP
24 
30 #include <xercesc/util/ValueStackOf.hpp>
31 #include <xercesc/validators/DTD/DocTypeHandler.hpp>
33 #include <xercesc/validators/DTD/DTDElementDecl.hpp>
34 #include <xercesc/framework/XMLBufferMgr.hpp>
36 
38 
39 class XMLPScanToken;
40 class XMLScanner;
41 class XMLValidator;
42 class DOMDocumentImpl;
43 class DOMDocumentTypeImpl;
44 class DOMEntityImpl;
45 class DOMElement;
46 class GrammarResolver;
47 class XMLGrammarPool;
48 class PSVIHandler;
49 
55 
56  public XMemory
57  , public XMLDocumentHandler
58  , public XMLErrorReporter
59  , public XMLEntityHandler
60  , public DocTypeHandler
61  , public PSVIHandler
62 {
63 public :
64  // -----------------------------------------------------------------------
65  // Class types
66  // -----------------------------------------------------------------------
69 
78  {
79  Val_Never
80  , Val_Always
81  , Val_Auto
82  };
83 
85 
86 
87  // -----------------------------------------------------------------------
88  // Constructors and Destructor
89  // -----------------------------------------------------------------------
92 
96  virtual ~AbstractDOMParser();
97 
99 
100  // -----------------------------------------------------------------------
101  // Utility methods
102  // -----------------------------------------------------------------------
103 
111  void reset();
112 
126  DOMDocument* adoptDocument();
127 
129 
130 
131  // -----------------------------------------------------------------------
132  // Getter methods
133  // -----------------------------------------------------------------------
134 
137 
149  DOMDocument* getDocument();
150 
158  const XMLValidator& getValidator() const;
159 
167  ValSchemes getValidationScheme() const;
168 
179  bool getDoSchema() const;
180 
191  bool getValidationSchemaFullChecking() const;
192 
203  bool getIdentityConstraintChecking() const;
204 
216  XMLSize_t getErrorCount() const;
217 
228  bool getDoNamespaces() const;
229 
242  bool getExitOnFirstFatalError() const;
243 
254  bool getValidationConstraintFatal() const;
255 
265  bool getCreateEntityReferenceNodes()const;
266 
277  bool getIncludeIgnorableWhitespace() const;
278 
298  XMLCh* getExternalSchemaLocation() const;
299 
319  XMLCh* getExternalNoNamespaceSchemaLocation() const;
320 
336  SecurityManager* getSecurityManager() const;
337 
351  const XMLSize_t& getLowWaterMark() const;
352 
364  bool getLoadExternalDTD() const;
365 
377  bool getLoadSchema() const;
378 
387  bool getCreateCommentNodes()const;
388 
400  bool getCalculateSrcOfs() const;
401 
412  bool getStandardUriConformant() const;
413 
420  PSVIHandler* getPSVIHandler();
421 
428  const PSVIHandler* getPSVIHandler() const;
429 
439  bool getCreateSchemaInfo() const;
440 
450  bool getDoXInclude() const;
451 
463  bool getGenerateSyntheticAnnotations() const;
464 
472  bool getValidateAnnotations() const;
473 
481  bool getIgnoreAnnotations() const;
482 
490  bool getDisableDefaultEntityResolution() const;
491 
499  bool getSkipDTDValidation() const;
500 
508  bool getHandleMultipleImports() const;
510 
511 
512  // -----------------------------------------------------------------------
513  // Setter methods
514  // -----------------------------------------------------------------------
515 
529  void setGenerateSyntheticAnnotations(const bool newValue);
530 
538  void setValidateAnnotations(const bool newValue);
539 
554  void setDoNamespaces(const bool newState);
555 
572  void setExitOnFirstFatalError(const bool newState);
573 
593  void setValidationConstraintFatal(const bool newState);
594 
613  void setCreateEntityReferenceNodes(const bool create);
614 
636  void setIncludeIgnorableWhitespace(const bool include);
637 
654  void setValidationScheme(const ValSchemes newScheme);
655 
671  void setDoSchema(const bool newState);
672 
689  void setValidationSchemaFullChecking(const bool schemaFullChecking);
690 
704  void setIdentityConstraintChecking(const bool newState);
705 
726  void setExternalSchemaLocation(const XMLCh* const schemaLocation);
727 
736  void setExternalSchemaLocation(const char* const schemaLocation);
737 
752  void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
753 
762  void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
763 
779  void setSecurityManager(SecurityManager* const securityManager);
780 
794  void setLowWaterMark(XMLSize_t lwm);
795 
812  void setLoadExternalDTD(const bool newState);
813 
829  void setLoadSchema(const bool newState);
830 
841  void setCreateCommentNodes(const bool create);
842 
855  void setCalculateSrcOfs(const bool newState);
856 
867  void setStandardUriConformant(const bool newState);
868 
876  void useScanner(const XMLCh* const scannerName);
877 
885  void useImplementation(const XMLCh* const implementationFeatures);
886 
895  virtual void setPSVIHandler(PSVIHandler* const handler);
896 
906  void setCreateSchemaInfo(const bool newState);
907 
917  void setDoXInclude(const bool newState);
918 
928  void setIgnoreAnnotations(const bool newValue);
929 
944  void setDisableDefaultEntityResolution(const bool newValue);
945 
958  void setSkipDTDValidation(const bool newValue);
959 
971  void setHandleMultipleImports(const bool newValue);
973 
974 
975  // -----------------------------------------------------------------------
976  // Parsing methods
977  // -----------------------------------------------------------------------
978 
981 
997  void parse(const InputSource& source);
998 
1015  void parse(const XMLCh* const systemId);
1016 
1032  void parse(const char* const systemId);
1033 
1060  bool parseFirst
1061  (
1062  const XMLCh* const systemId
1063  , XMLPScanToken& toFill
1064  );
1065 
1093  bool parseFirst
1094  (
1095  const char* const systemId
1096  , XMLPScanToken& toFill
1097  );
1098 
1126  bool parseFirst
1127  (
1128  const InputSource& source
1129  , XMLPScanToken& toFill
1130  );
1131 
1154  bool parseNext(XMLPScanToken& token);
1155 
1181  void parseReset(XMLPScanToken& token);
1182 
1184 
1185  // -----------------------------------------------------------------------
1186  // Implementation of the PSVIHandler interface.
1187  // -----------------------------------------------------------------------
1188 
1191 
1202  virtual void handleElementPSVI
1203  (
1204  const XMLCh* const localName
1205  , const XMLCh* const uri
1206  , PSVIElement * elementInfo
1207  );
1208 
1209  virtual void handlePartialElementPSVI
1210  (
1211  const XMLCh* const localName
1212  , const XMLCh* const uri
1213  , PSVIElement * elementInfo
1214  );
1226  virtual void handleAttributesPSVI
1227  (
1228  const XMLCh* const localName
1229  , const XMLCh* const uri
1230  , PSVIAttributeList * psviAttributes
1231  );
1233 
1234  // -----------------------------------------------------------------------
1235  // Implementation of the XMLDocumentHandler interface.
1236  // -----------------------------------------------------------------------
1237 
1240 
1253  virtual void docCharacters
1254  (
1255  const XMLCh* const chars
1256  , const XMLSize_t length
1257  , const bool cdataSection
1258  );
1259 
1268  virtual void docComment
1269  (
1270  const XMLCh* const comment
1271  );
1272 
1285  virtual void docPI
1286  (
1287  const XMLCh* const target
1288  , const XMLCh* const data
1289  );
1290 
1295  virtual void endDocument();
1296 
1313  virtual void endElement
1314  (
1315  const XMLElementDecl& elemDecl
1316  , const unsigned int urlId
1317  , const bool isRoot
1318  , const XMLCh* const elemPrefix
1319  );
1320 
1329  virtual void endEntityReference
1330  (
1331  const XMLEntityDecl& entDecl
1332  );
1333 
1352  virtual void ignorableWhitespace
1353  (
1354  const XMLCh* const chars
1355  , const XMLSize_t length
1356  , const bool cdataSection
1357  );
1358 
1365  virtual void resetDocument();
1366 
1371  virtual void startDocument();
1372 
1400  virtual void startElement
1401  (
1402  const XMLElementDecl& elemDecl
1403  , const unsigned int urlId
1404  , const XMLCh* const elemPrefix
1405  , const RefVectorOf<XMLAttr>& attrList
1406  , const XMLSize_t attrCount
1407  , const bool isEmpty
1408  , const bool isRoot
1409  );
1410 
1420  virtual void startEntityReference
1421  (
1422  const XMLEntityDecl& entDecl
1423  );
1424 
1443  virtual void XMLDecl
1444  (
1445  const XMLCh* const versionStr
1446  , const XMLCh* const encodingStr
1447  , const XMLCh* const standaloneStr
1448  , const XMLCh* const actualEncStr
1449  );
1450 
1452 
1453 
1454  // -----------------------------------------------------------------------
1455  // Implementation of the deprecated DocTypeHandler interface.
1456  // -----------------------------------------------------------------------
1459  virtual void attDef
1460  (
1461  const DTDElementDecl& elemDecl
1462  , const DTDAttDef& attDef
1463  , const bool ignoring
1464  );
1465 
1466  virtual void doctypeComment
1467  (
1468  const XMLCh* const comment
1469  );
1470 
1471  virtual void doctypeDecl
1472  (
1473  const DTDElementDecl& elemDecl
1474  , const XMLCh* const publicId
1475  , const XMLCh* const systemId
1476  , const bool hasIntSubset
1477  , const bool hasExtSubset = false
1478  );
1479 
1480  virtual void doctypePI
1481  (
1482  const XMLCh* const target
1483  , const XMLCh* const data
1484  );
1485 
1486  virtual void doctypeWhitespace
1487  (
1488  const XMLCh* const chars
1489  , const XMLSize_t length
1490  );
1491 
1492  virtual void elementDecl
1493  (
1494  const DTDElementDecl& decl
1495  , const bool isIgnored
1496  );
1497 
1498  virtual void endAttList
1499  (
1500  const DTDElementDecl& elemDecl
1501  );
1502 
1503  virtual void endIntSubset();
1504 
1505  virtual void endExtSubset();
1506 
1507  virtual void entityDecl
1508  (
1509  const DTDEntityDecl& entityDecl
1510  , const bool isPEDecl
1511  , const bool isIgnored
1512  );
1513 
1514  virtual void resetDocType();
1515 
1516  virtual void notationDecl
1517  (
1518  const XMLNotationDecl& notDecl
1519  , const bool isIgnored
1520  );
1521 
1522  virtual void startAttList
1523  (
1524  const DTDElementDecl& elemDecl
1525  );
1526 
1527  virtual void startIntSubset();
1528 
1529  virtual void startExtSubset();
1530 
1531  virtual void TextDecl
1532  (
1533  const XMLCh* const versionStr
1534  , const XMLCh* const encodingStr
1535  );
1536 
1538 
1539 protected:
1540  // DOM node creation hooks. Override them if you are using your own
1541  // DOM node types.
1542  //
1543  virtual DOMCDATASection* createCDATASection (const XMLCh*, XMLSize_t);
1544  virtual DOMText* createText (const XMLCh*, XMLSize_t);
1545 
1546  virtual DOMElement* createElement (const XMLCh* name);
1547  virtual DOMElement* createElementNS (const XMLCh* namespaceURI,
1548  const XMLCh* elemPrefix,
1549  const XMLCh* localName,
1550  const XMLCh* qName);
1551 
1552  virtual DOMAttr* createAttr (const XMLCh* name);
1553  virtual DOMAttr* createAttrNS (const XMLCh* namespaceURI,
1554  const XMLCh* elemPrefix,
1555  const XMLCh* localName,
1556  const XMLCh* qName);
1557 
1558 
1559 
1560 
1561 protected :
1562  // -----------------------------------------------------------------------
1563  // Protected Constructor Methods
1564  // -----------------------------------------------------------------------
1584  (
1585  XMLValidator* const valToAdopt = 0
1587  , XMLGrammarPool* const gramPool = 0
1588  );
1589 
1591 
1592  // -----------------------------------------------------------------------
1593  // Protected getter methods
1594  // -----------------------------------------------------------------------
1602  DOMNode* getCurrentNode();
1603 
1608  XMLScanner* getScanner() const;
1609 
1614  GrammarResolver* getGrammarResolver() const;
1615 
1621  bool getParseInProgress() const;
1622 
1623  MemoryManager* getMemoryManager() const;
1624 
1626 
1627 
1628  // -----------------------------------------------------------------------
1629  // Protected setter methods
1630  // -----------------------------------------------------------------------
1631 
1634 
1642  void setCurrentNode(DOMNode* toSet);
1643 
1650  void setDocument(DOMDocument* toSet);
1651 
1658  void setParseInProgress(const bool toSet);
1660 
1661  // -----------------------------------------------------------------------
1662  // Protected Helper methods
1663  // -----------------------------------------------------------------------
1666  void resetPool();
1667 
1671  bool isDocumentAdopted() const;
1672 
1674 
1675 
1676 private :
1677  // -----------------------------------------------------------------------
1678  // Initialize/Cleanup methods
1679  // -----------------------------------------------------------------------
1680  void initialize();
1681  void cleanUp();
1682  void resetInProgress();
1683 
1684  // -----------------------------------------------------------------------
1685  // Unimplemented constructors and operators
1686  // -----------------------------------------------------------------------
1688  AbstractDOMParser& operator=(const AbstractDOMParser&);
1689 
1690 protected:
1691  // -----------------------------------------------------------------------
1692  // Protected data members
1693  //
1694  // fCurrentNode
1695  // fCurrentParent
1696  // Used to track the current node during nested element events. Since
1697  // the tree must be built from a set of disjoint callbacks, we need
1698  // these to keep up with where we currently are.
1699  //
1700  // fCurrentEntity
1701  // Used to track the current entity decl. If a text decl is seen later on,
1702  // it is used to update the encoding and version information.
1703  //
1704  // fDocument
1705  // The root document object, filled with the document contents.
1706  //
1707  // fCreateEntityReferenceNodes
1708  // Indicates whether entity reference nodes should be created.
1709  //
1710  // fIncludeIgnorableWhitespace
1711  // Indicates whether ignorable whitespace should be added to
1712  // the DOM tree for validating parsers.
1713  //
1714  // fScanner
1715  // The scanner used for this parser. This is created during the
1716  // constructor.
1717  //
1718  // fImplementationFeatures
1719  // The implementation features that we use to get an implementation
1720  // for use in creating the DOMDocument used during parse. If this is
1721  // null then the default DOMImplementation is used
1722  //
1723  // fParseInProgress
1724  // Used to prevent multiple entrance to the parser while its doing
1725  // a parse.
1726  //
1727  // fWithinElement
1728  // A flag to indicate that the parser is within at least one level
1729  // of element processing.
1730  //
1731  // fDocumentType
1732  // Used to store and update the documentType variable information
1733  // in fDocument
1734  //
1735  // fDocumentVector
1736  // Store all the previous fDocument(s) (thus not the current fDocument)
1737  // created in this parser. It is destroyed when the parser is destructed.
1738  //
1739  // fCreateCommentNodes
1740  // Indicates whether comment nodes should be created.
1741  //
1742  // fDocumentAdoptedByUser
1743  // The DOMDocument ownership has been transferred to application
1744  // If set to true, the parser does not own the document anymore
1745  // and thus will not release its memory.
1746  //
1747  // fInternalSubset
1748  // Buffer for storing the internal subset information.
1749  // Once complete (after DOCTYPE is finished scanning), send
1750  // it to DocumentType Node
1751  //
1752  // fGrammarPool
1753  // The grammar pool passed from external application (through derivatives).
1754  // which could be 0, not owned.
1755  //
1756  // fCreateSchemaInfo
1757  // Indicates whether element and attributes will have schema info associated
1758  //
1759  // fDoXinclude
1760  // A bool used to request that XInlcude processing occur on the
1761  // Document the parser parses.
1762  // -----------------------------------------------------------------------
1771  XMLScanner* fScanner;
1775  DOMEntityImpl* fCurrentEntity;
1776  DOMDocumentImpl* fDocument;
1777  DOMDocumentTypeImpl* fDocumentType;
1778  RefVectorOf<DOMDocumentImpl>* fDocumentVector;
1779  GrammarResolver* fGrammarResolver;
1780  XMLStringPool* fURIStringPool;
1784  XMLBufferMgr fBufMgr;
1785  XMLBuffer& fInternalSubset;
1787 };
1788 
1789 
1790 
1791 // ---------------------------------------------------------------------------
1792 // AbstractDOMParser: Getter methods
1793 // ---------------------------------------------------------------------------
1795 {
1797 }
1798 
1800 {
1802 }
1803 
1805 {
1806  return fParseInProgress;
1807 }
1808 
1809 inline XMLScanner* AbstractDOMParser::getScanner() const
1810 {
1811  return fScanner;
1812 }
1813 
1814 inline GrammarResolver* AbstractDOMParser::getGrammarResolver() const
1815 {
1816  return fGrammarResolver;
1817 }
1818 
1820 {
1821  return fCreateCommentNodes;
1822 }
1823 
1825 {
1826  return fPSVIHandler;
1827 }
1828 
1830 {
1831  return fPSVIHandler;
1832 }
1833 
1835 {
1836  return fCreateSchemaInfo;
1837 }
1838 
1840 {
1841  return fDoXInclude;
1842 }
1843 // ---------------------------------------------------------------------------
1844 // AbstractDOMParser: Setter methods
1845 // ---------------------------------------------------------------------------
1847 {
1848  fCreateEntityReferenceNodes = create;
1849 }
1850 
1852 {
1853  fIncludeIgnorableWhitespace = include;
1854 }
1855 
1856 inline void AbstractDOMParser::setCreateCommentNodes(const bool create)
1857 {
1858  fCreateCommentNodes = create;
1859 }
1860 
1861 inline void AbstractDOMParser::useImplementation(const XMLCh* const implementationFeatures)
1862 {
1864  fImplementationFeatures = XMLString::replicate(implementationFeatures, fMemoryManager);
1865 }
1866 
1867 inline void AbstractDOMParser::setDoXInclude(const bool newState)
1868 {
1869  fDoXInclude = newState;
1870 }
1871 
1872 // ---------------------------------------------------------------------------
1873 // AbstractDOMParser: Protected getter methods
1874 // ---------------------------------------------------------------------------
1876 {
1877  return fCurrentNode;
1878 }
1879 
1881 {
1882  return fMemoryManager;
1883 }
1884 
1885 // ---------------------------------------------------------------------------
1886 // AbstractDOMParser: Protected setter methods
1887 // ---------------------------------------------------------------------------
1889 {
1890  fCurrentNode = toSet;
1891 }
1892 
1893 inline void AbstractDOMParser::setParseInProgress(const bool toSet)
1894 {
1895  fParseInProgress = toSet;
1896 }
1897 
1899 
1900 #endif