Xerces-C++  3.2.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$
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 
127 
129 
130 
131  // -----------------------------------------------------------------------
132  // Getter methods
133  // -----------------------------------------------------------------------
134 
137 
150 
158  const XMLValidator& getValidator() const;
159 
168 
179  bool getDoSchema() const;
180 
192 
204 
217 
228  bool getDoNamespaces() const;
229 
243 
255 
265  bool getCreateEntityReferenceNodes()const;
266 
277  bool getIncludeIgnorableWhitespace() const;
278 
299 
320 
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 
413 
420  PSVIHandler* getPSVIHandler();
421 
428  const PSVIHandler* getPSVIHandler() const;
429 
439  bool getCreateSchemaInfo() const;
440 
450  bool getDoXInclude() const;
451 
464 
473 
481  bool getIgnoreAnnotations() const;
482 
491 
499  bool getSkipDTDValidation() const;
500 
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 
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 
1061  (
1062  const XMLCh* const systemId
1063  , XMLPScanToken& toFill
1064  );
1065 
1094  (
1095  const char* const systemId
1096  , XMLPScanToken& toFill
1097  );
1098 
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 
1210  (
1211  const XMLCh* const localName
1212  , const XMLCh* const uri
1213  , PSVIElement * elementInfo
1214  );
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 
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  //
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
#define PARSERS_EXPORT
Definition: XercesDefs.hpp:168
#define XERCES_CPP_NAMESPACE_BEGIN
Definition: XercesDefs.hpp:112
#define XERCES_CPP_NAMESPACE_END
Definition: XercesDefs.hpp:113
size_t XMLSize_t
Definition: Xerces_autoconf_config.hpp:112
char16_t XMLCh
Definition: Xerces_autoconf_config.hpp:120
This class implements the Document Object Model (DOM) interface.
Definition: AbstractDOMParser.hpp:62
void setCreateEntityReferenceNodes(const bool create)
Set the 'include entity references' flag.
Definition: AbstractDOMParser.hpp:1846
bool isDocumentAdopted() const
Returns true if the user has adopted the document.
void setExternalSchemaLocation(const XMLCh *const schemaLocation)
This method allows the user to specify a list of schemas to use.
XMLValidator * fValidator
Definition: AbstractDOMParser.hpp:1781
DOMDocumentImpl * fDocument
Definition: AbstractDOMParser.hpp:1776
virtual void docComment(const XMLCh *const comment)
Handle a document comment event.
void setExitOnFirstFatalError(const bool newState)
Set the 'exit on first error' flag.
void useScanner(const XMLCh *const scannerName)
Set the scanner to use when scanning the XML document.
void parseReset(XMLPScanToken &token)
Reset the parser after a progressive parse.
virtual void doctypePI(const XMLCh *const target, const XMLCh *const data)
PSVIHandler * fPSVIHandler
Definition: AbstractDOMParser.hpp:1786
virtual void startEntityReference(const XMLEntityDecl &entDecl)
Handle a start entity reference event.
DOMDocument * getDocument()
Get the DOM document.
bool getHandleMultipleImports() const
Get the 'handle multiple schema imports' flag.
void setExternalNoNamespaceSchemaLocation(const XMLCh *const noNamespaceSchemaLocation)
This method allows the user to specify the no target namespace XML Schema Location externally.
void setCreateCommentNodes(const bool create)
Set the 'create comment nodes' flag.
Definition: AbstractDOMParser.hpp:1856
void setDoNamespaces(const bool newState)
Set the 'do namespaces' flag.
virtual void endEntityReference(const XMLEntityDecl &entDecl)
Handle and end of entity reference event.
bool fDoXInclude
Definition: AbstractDOMParser.hpp:1770
bool getDoSchema() const
Get the 'do schema' flag.
bool parseNext(XMLPScanToken &token)
Continue a progressive parse operation.
XMLScanner * getScanner() const
Get the XML scanner.
Definition: AbstractDOMParser.hpp:1809
virtual DOMText * createText(const XMLCh *, XMLSize_t)
virtual void handlePartialElementPSVI(const XMLCh *const localName, const XMLCh *const uri, PSVIElement *elementInfo)
Receive notification of partial PSVI properties of an element.
DOMEntityImpl * fCurrentEntity
Definition: AbstractDOMParser.hpp:1775
PSVIHandler * getPSVIHandler()
This method returns the installed PSVI handler.
Definition: AbstractDOMParser.hpp:1824
void setHandleMultipleImports(const bool newValue)
Set the 'handle multiple schema imports' flag.
virtual void docPI(const XMLCh *const target, const XMLCh *const data)
Handle a document PI event.
XMLGrammarPool * fGrammarPool
Definition: AbstractDOMParser.hpp:1783
virtual void endElement(const XMLElementDecl &elemDecl, const unsigned int urlId, const bool isRoot, const XMLCh *const elemPrefix)
Handle and end of element event.
virtual void startIntSubset()
void setIgnoreAnnotations(const bool newValue)
Set the 'ignore annotation' flag.
void setLoadSchema(const bool newState)
Set the 'Loading Schema' flag.
ValSchemes
ValScheme enum used in setValidationScheme Val_Never: Do not report validation errors.
Definition: AbstractDOMParser.hpp:78
bool parseFirst(const XMLCh *const systemId, XMLPScanToken &toFill)
Begin a progressive parse operation.
void reset()
Reset the parser.
virtual void endIntSubset()
bool fCreateCommentNodes
Definition: AbstractDOMParser.hpp:1767
virtual void resetDocument()
Handle a document reset event.
virtual ~AbstractDOMParser()
Destructor.
virtual void endAttList(const DTDElementDecl &elemDecl)
XMLBuffer & fInternalSubset
Definition: AbstractDOMParser.hpp:1785
virtual void startAttList(const DTDElementDecl &elemDecl)
bool fCreateEntityReferenceNodes
Definition: AbstractDOMParser.hpp:1763
void setDisableDefaultEntityResolution(const bool newValue)
Set the 'disable default entity resolution' flag.
void setExternalNoNamespaceSchemaLocation(const char *const noNamespaceSchemaLocation)
This method is same as setExternalNoNamespaceSchemaLocation(const XMLCh* const).
bool getStandardUriConformant() const
Get the 'force standard uri flag'.
virtual void XMLDecl(const XMLCh *const versionStr, const XMLCh *const encodingStr, const XMLCh *const standaloneStr, const XMLCh *const actualEncStr)
Handle an XMLDecl event.
DOMNode * getCurrentNode()
Get the current DOM node.
Definition: AbstractDOMParser.hpp:1875
bool getCreateSchemaInfo() const
Get the 'associate schema info' flag.
Definition: AbstractDOMParser.hpp:1834
virtual void entityDecl(const DTDEntityDecl &entityDecl, const bool isPEDecl, const bool isIgnored)
bool getGenerateSyntheticAnnotations() const
Get the 'generate synthetic annotations' flag.
DOMDocumentTypeImpl * fDocumentType
Definition: AbstractDOMParser.hpp:1777
bool getValidateAnnotations() const
Get the 'validate annotations' flag.
void setValidateAnnotations(const bool newValue)
set the 'validlate annotations' flag
void setDocument(DOMDocument *toSet)
Set the document node.
XMLScanner * fScanner
Definition: AbstractDOMParser.hpp:1771
virtual void handleElementPSVI(const XMLCh *const localName, const XMLCh *const uri, PSVIElement *elementInfo)
Receive notification of the PSVI properties of an element.
DOMNode * fCurrentNode
Definition: AbstractDOMParser.hpp:1774
void setLoadExternalDTD(const bool newState)
Set the 'Loading External DTD' flag.
void useImplementation(const XMLCh *const implementationFeatures)
Set the implementation to use when creating the document.
Definition: AbstractDOMParser.hpp:1861
void setDoSchema(const bool newState)
Set the 'do schema' flag.
void setParseInProgress(const bool toSet)
Set the parse in progress flag.
Definition: AbstractDOMParser.hpp:1893
bool getIgnoreAnnotations() const
Get the 'ignore annotations' flag.
void setExternalSchemaLocation(const char *const schemaLocation)
This method is same as setExternalSchemaLocation(const XMLCh* const).
virtual void startExtSubset()
virtual DOMCDATASection * createCDATASection(const XMLCh *, XMLSize_t)
XMLSize_t getErrorCount() const
Get error count from the last parse operation.
GrammarResolver * getGrammarResolver() const
Get the Grammar resolver.
Definition: AbstractDOMParser.hpp:1814
void setCalculateSrcOfs(const bool newState)
Enable/disable src offset calculation.
void setValidationSchemaFullChecking(const bool schemaFullChecking)
This method allows the user to turn full Schema constraint checking on/off.
const XMLValidator & getValidator() const
Get a const reference to the validator.
virtual void doctypeComment(const XMLCh *const comment)
ValSchemes getValidationScheme() const
This method returns an enumerated value that indicates the current validation scheme set on this pars...
XMLCh * fImplementationFeatures
Definition: AbstractDOMParser.hpp:1772
bool fParseInProgress
Definition: AbstractDOMParser.hpp:1766
bool getCreateEntityReferenceNodes() const
Get the 'include entity references' flag.
Definition: AbstractDOMParser.hpp:1794
virtual DOMElement * createElementNS(const XMLCh *namespaceURI, const XMLCh *elemPrefix, const XMLCh *localName, const XMLCh *qName)
virtual DOMAttr * createAttr(const XMLCh *name)
bool fIncludeIgnorableWhitespace
Definition: AbstractDOMParser.hpp:1764
bool getSkipDTDValidation() const
Get the 'skip DTD validation' flag.
virtual void doctypeDecl(const DTDElementDecl &elemDecl, const XMLCh *const publicId, const XMLCh *const systemId, const bool hasIntSubset, const bool hasExtSubset=false)
bool parseFirst(const char *const systemId, XMLPScanToken &toFill)
Begin a progressive parse operation.
MemoryManager * fMemoryManager
Definition: AbstractDOMParser.hpp:1782
AbstractDOMParser(XMLValidator *const valToAdopt=0, MemoryManager *const manager=XMLPlatformUtils::fgMemoryManager, XMLGrammarPool *const gramPool=0)
Construct a AbstractDOMParser, with an optional validator.
bool getIdentityConstraintChecking() const
Get the identity constraint checking' flag.
XMLCh * getExternalNoNamespaceSchemaLocation() const
Get the noNamespace SchemaLocation that is specified externally.
void setValidationScheme(const ValSchemes newScheme)
This method allows users to set the validation scheme to be used by this parser.
const XMLSize_t & getLowWaterMark() const
Get the raw buffer low water mark for this parser.
SecurityManager * getSecurityManager() const
Get the SecurityManager instance attached to this parser.
void setCurrentNode(DOMNode *toSet)
Set the current DOM node.
Definition: AbstractDOMParser.hpp:1888
void setSecurityManager(SecurityManager *const securityManager)
This allows an application to set a SecurityManager on the parser; this object stores information tha...
virtual DOMElement * createElement(const XMLCh *name)
void setDoXInclude(const bool newState)
Set the 'do XInclude' flag.
Definition: AbstractDOMParser.hpp:1867
bool fDocumentAdoptedByUser
Definition: AbstractDOMParser.hpp:1768
virtual void setPSVIHandler(PSVIHandler *const handler)
This method installs the user specified PSVI handler on the parser.
void setSkipDTDValidation(const bool newValue)
Set the 'skip DTD validation' flag.
void setGenerateSyntheticAnnotations(const bool newValue)
set the 'generate synthetic annotations' flag
void parse(const InputSource &source)
Parse via an input source object.
bool getValidationSchemaFullChecking() const
Get the 'full schema constraint checking' flag.
virtual void doctypeWhitespace(const XMLCh *const chars, const XMLSize_t length)
virtual void endDocument()
Handle the end of document event.
virtual void elementDecl(const DTDElementDecl &decl, const bool isIgnored)
bool getDoNamespaces() const
Get the 'do namespaces' flag.
virtual void resetDocType()
bool parseFirst(const InputSource &source, XMLPScanToken &toFill)
Begin a progressive parse operation.
void parse(const char *const systemId)
Parse via a file path or URL (in the local code page)
bool getCreateCommentNodes() const
Get the 'create comment node' flag.
Definition: AbstractDOMParser.hpp:1819
virtual void TextDecl(const XMLCh *const versionStr, const XMLCh *const encodingStr)
bool getParseInProgress() const
Get the parse in progress flag.
Definition: AbstractDOMParser.hpp:1804
void setStandardUriConformant(const bool newState)
Force standard uri.
bool fWithinElement
Definition: AbstractDOMParser.hpp:1765
virtual void ignorableWhitespace(const XMLCh *const chars, const XMLSize_t length, const bool cdataSection)
Handle an ignorable whitespace vent.
bool getValidationConstraintFatal() const
This method returns the state of the parser's validation-constraint-fatal flag.
bool getLoadSchema() const
Get the 'Loading Schema' flag.
bool getDoXInclude() const
Get the 'do XInclude' flag.
Definition: AbstractDOMParser.hpp:1839
virtual void handleAttributesPSVI(const XMLCh *const localName, const XMLCh *const uri, PSVIAttributeList *psviAttributes)
Enables PSVI information about attributes to be passed back to the application.
virtual void startElement(const XMLElementDecl &elemDecl, const unsigned int urlId, const XMLCh *const elemPrefix, const RefVectorOf< XMLAttr > &attrList, const XMLSize_t attrCount, const bool isEmpty, const bool isRoot)
Handle a start element event.
DOMNode * fCurrentParent
Definition: AbstractDOMParser.hpp:1773
virtual void notationDecl(const XMLNotationDecl &notDecl, const bool isIgnored)
XMLStringPool * fURIStringPool
Definition: AbstractDOMParser.hpp:1780
MemoryManager * getMemoryManager() const
Definition: AbstractDOMParser.hpp:1880
virtual void docCharacters(const XMLCh *const chars, const XMLSize_t length, const bool cdataSection)
Handle document character events.
void setIncludeIgnorableWhitespace(const bool include)
Set the 'include ignorable whitespace' flag.
Definition: AbstractDOMParser.hpp:1851
bool getDisableDefaultEntityResolution() const
Get the 'disable default entity resolution' flag.
void setLowWaterMark(XMLSize_t lwm)
Set the raw buffer low water mark for this parser.
virtual void attDef(const DTDElementDecl &elemDecl, const DTDAttDef &attDef, const bool ignoring)
XMLBufferMgr fBufMgr
Definition: AbstractDOMParser.hpp:1784
XMLCh * getExternalSchemaLocation() const
Get the set of Namespace/SchemaLocation that is specified externally.
bool getExitOnFirstFatalError() const
Get the 'exit on first error' flag.
void parse(const XMLCh *const systemId)
Parse via a file path or URL.
void setValidationConstraintFatal(const bool newState)
This method allows users to set the parser's behaviour when it encounters a validation constraint err...
bool getIncludeIgnorableWhitespace() const
Get the 'include ignorable whitespace' flag.
Definition: AbstractDOMParser.hpp:1799
bool fCreateSchemaInfo
Definition: AbstractDOMParser.hpp:1769
bool getLoadExternalDTD() const
Get the 'Loading External DTD' flag.
virtual DOMAttr * createAttrNS(const XMLCh *namespaceURI, const XMLCh *elemPrefix, const XMLCh *localName, const XMLCh *qName)
void setIdentityConstraintChecking(const bool newState)
This method allows users to enable or disable the parser's identity constraint checks.
virtual void startDocument()
Handle a start document event.
RefVectorOf< DOMDocumentImpl > * fDocumentVector
Definition: AbstractDOMParser.hpp:1778
GrammarResolver * fGrammarResolver
Definition: AbstractDOMParser.hpp:1779
bool getCalculateSrcOfs() const
Get the 'calculate src offset flag'.
DOMDocument * adoptDocument()
Adopt the DOM document.
virtual void endExtSubset()
void setCreateSchemaInfo(const bool newState)
Set the 'associate schema info' flag.
The DOMAttr class refers to an attribute of an XML element.
Definition: DOMAttr.hpp:57
CDATA sections are used to escape blocks of text containing characters that would otherwise be regard...
Definition: DOMCDATASection.hpp:65
The DOMDocument interface represents the entire XML document.
Definition: DOMDocument.hpp:67
By far the vast majority of objects (apart from text) that authors encounter when traversing a docume...
Definition: DOMElement.hpp:66
The DOMNode interface is the primary datatype for the entire Document Object Model.
Definition: DOMNode.hpp:139
The DOMText interface inherits from DOMCharacterData and represents the textual content (termed chara...
Definition: DOMText.hpp:51
A single input source for an XML entity.
Definition: InputSource.hpp:63
Configurable memory manager.
Definition: MemoryManager.hpp:40
virtual void deallocate(void *p)=0
This method deallocates memory.
Definition: PSVIAttributeList.hpp:60
Definition: PSVIElement.hpp:42
This abstract class provides the interface for the scanner to return PSVI information to the applicat...
Definition: PSVIHandler.hpp:39
Allow application to force the parser to behave in a security-conscious way.
Definition: SecurityManager.hpp:52
This abstract class provides the interface for the scanner to return XML document information up to t...
Definition: XMLDocumentHandler.hpp:43
This class defines the core information of an element declaration.
Definition: XMLElementDecl.hpp:52
This class defines that core information that defines an XML entity, no matter what validator is used...
Definition: XMLEntityDecl.hpp:51
This abstract class is a callback mechanism for the scanner.
Definition: XMLEntityHandler.hpp:44
This abstract class defines a callback mechanism for the scanner.
Definition: XMLErrorReporter.hpp:43
Definition: XMLGrammarPool.hpp:44
This class represents the core information about a notation declaration that all validators must at l...
Definition: XMLNotationDecl.hpp:42
static MemoryManager * fgMemoryManager
The configurable memory manager.
Definition: PlatformUtils.hpp:121
static char * replicate(const char *const toRep, MemoryManager *const manager=XMLPlatformUtils::fgMemoryManager)
Replicates a string NOTE: The returned buffer is allocated with the MemoryManager.
This abstract class provides the interface for all validators.
Definition: XMLValidator.hpp:53
This class makes it possible to override the C++ memory management by adding new/delete operators to ...
Definition: XMemory.hpp:41