Xerces-C++ 3.2.4
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
39class XMLPScanToken;
40class XMLScanner;
41class XMLValidator;
42class DOMDocumentImpl;
43class DOMDocumentTypeImpl;
44class DOMEntityImpl;
45class DOMElement;
46class GrammarResolver;
47class XMLGrammarPool;
48class PSVIHandler;
49
55
56 public XMemory
57 , public XMLDocumentHandler
58 , public XMLErrorReporter
59 , public XMLEntityHandler
60 , public DocTypeHandler
61 , public PSVIHandler
62{
63public :
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
97
99
100 // -----------------------------------------------------------------------
101 // Utility methods
102 // -----------------------------------------------------------------------
103
111 void reset();
112
127
129
130
131 // -----------------------------------------------------------------------
132 // Getter methods
133 // -----------------------------------------------------------------------
134
137
150
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
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
482
491
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
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
1330 (
1331 const XMLEntityDecl& entDecl
1332 );
1333
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
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
1539protected:
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
1561protected :
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
1651
1658 void setParseInProgress(const bool toSet);
1660
1661 // -----------------------------------------------------------------------
1662 // Protected Helper methods
1663 // -----------------------------------------------------------------------
1667
1671 bool isDocumentAdopted() const;
1672
1674
1675
1676private :
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
1690protected:
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;
1787};
1788
1789
1790
1791// ---------------------------------------------------------------------------
1792// AbstractDOMParser: Getter methods
1793// ---------------------------------------------------------------------------
1795{
1797}
1798
1800{
1802}
1803
1805{
1806 return fParseInProgress;
1807}
1808
1809inline XMLScanner* AbstractDOMParser::getScanner() const
1810{
1811 return fScanner;
1812}
1813
1814inline 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{
1849}
1850
1852{
1854}
1855
1856inline void AbstractDOMParser::setCreateCommentNodes(const bool create)
1857{
1858 fCreateCommentNodes = create;
1859}
1860
1861inline void AbstractDOMParser::useImplementation(const XMLCh* const implementationFeatures)
1862{
1865}
1866
1867inline 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
1893inline 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
uint16_t XMLCh
Definition: Xerces_autoconf_config.hpp:120
size_t XMLSize_t
Definition: Xerces_autoconf_config.hpp:112
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.
virtual DOMElement * createElementNS(const XMLCh *namespaceURI, const XMLCh *elemPrefix, const XMLCh *localName, const XMLCh *qName)
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
const XMLValidator & getValidator() const
Get a const reference to the validator.
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.
XMLCh * getExternalNoNamespaceSchemaLocation() const
Get the noNamespace SchemaLocation that is specified externally.
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
const XMLSize_t & getLowWaterMark() const
Get the raw buffer low water mark for this parser.
void setDoSchema(const bool newState)
Set the 'do schema' flag.
DOMDocument * adoptDocument()
Adopt the DOM document.
void setParseInProgress(const bool toSet)
Set the parse in progress flag.
Definition: AbstractDOMParser.hpp:1893
virtual DOMCDATASection * createCDATASection(const XMLCh *, XMLSize_t)
virtual DOMAttr * createAttrNS(const XMLCh *namespaceURI, const XMLCh *elemPrefix, const XMLCh *localName, const XMLCh *qName)
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()
XMLSize_t getErrorCount() const
Get error count from the last parse operation.
GrammarResolver * getGrammarResolver() const
Get the Grammar resolver.
Definition: AbstractDOMParser.hpp:1814
DOMDocument * getDocument()
Get the DOM document.
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.
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
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.
void setValidationScheme(const ValSchemes newScheme)
This method allows users to set the validation scheme to be used by 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...
void setDoXInclude(const bool newState)
Set the 'do XInclude' flag.
Definition: AbstractDOMParser.hpp:1867
XMLCh * getExternalSchemaLocation() const
Get the set of Namespace/SchemaLocation that is specified externally.
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.
SecurityManager * getSecurityManager() const
Get the SecurityManager instance attached to this parser.
virtual DOMText * createText(const XMLCh *, XMLSize_t)
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
virtual DOMElement * createElement(const XMLCh *name)
bool getExitOnFirstFatalError() const
Get the 'exit on first error' flag.
void parse(const XMLCh *const systemId)
Parse via a file path or URL.
virtual DOMAttr * createAttr(const XMLCh *name)
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.
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'.
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