Xerces-C++ 3.2.0

SAXParser.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: SAXParser.hpp 932889 2010-04-11 13:10:10Z borisk $
20 */
21
22 #if !defined(XERCESC_INCLUDE_GUARD_SAXPARSER_HPP)
23 #define XERCESC_INCLUDE_GUARD_SAXPARSER_HPP
24
25 #include <xercesc/sax/Parser.hpp>
26 #include <xercesc/internal/VecAttrListImpl.hpp>
27 #include <xercesc/framework/XMLDocumentHandler.hpp>
28 #include <xercesc/framework/XMLElementDecl.hpp>
29 #include <xercesc/framework/XMLEntityHandler.hpp>
30 #include <xercesc/framework/XMLErrorReporter.hpp>
31 #include <xercesc/framework/XMLBuffer.hpp>
32 #include <xercesc/util/SecurityManager.hpp>
33 #include <xercesc/validators/common/Grammar.hpp>
34 #include <xercesc/validators/DTD/DocTypeHandler.hpp>
35
36
37 XERCES_CPP_NAMESPACE_BEGIN
38
39
40 class DocumentHandler;
41 class EntityResolver;
42 class XMLPScanToken;
43 class XMLScanner;
44 class XMLValidator;
45 class GrammarResolver;
46 class XMLGrammarPool;
47 class XMLEntityResolver;
48 class XMLResourceIdentifier;
49 class PSVIHandler;
50
69 class PARSERS_EXPORT SAXParser :
70
71 public XMemory
72 , public Parser
73 , public XMLDocumentHandler
74 , public XMLErrorReporter
75 , public XMLEntityHandler
76 , public DocTypeHandler
77 {
78 public :
79 // -----------------------------------------------------------------------
80 // Class types
81 // -----------------------------------------------------------------------
90 enum ValSchemes
91 {
92 Val_Never
93 , Val_Always
94 , Val_Auto
95 };
96
97
98 // -----------------------------------------------------------------------
99 // Constructors and Destructor
100 // -----------------------------------------------------------------------
111 SAXParser
112 (
113 XMLValidator* const valToAdopt = 0
114 , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
115 , XMLGrammarPool* const gramPool = 0
116 );
117
121 ~SAXParser();
123
124
125 // -----------------------------------------------------------------------
126 // Getter Methods
127 // -----------------------------------------------------------------------
136 DocumentHandler* getDocumentHandler();
137
144 const DocumentHandler* getDocumentHandler() const;
145
152 EntityResolver* getEntityResolver();
153
160 const EntityResolver* getEntityResolver() const;
161
168 XMLEntityResolver* getXMLEntityResolver();
169
176 const XMLEntityResolver* getXMLEntityResolver() const;
177
184 ErrorHandler* getErrorHandler();
185
192 const ErrorHandler* getErrorHandler() const;
193
200 PSVIHandler* getPSVIHandler();
201
208 const PSVIHandler* getPSVIHandler() const;
209
216 const XMLValidator& getValidator() const;
217
225 ValSchemes getValidationScheme() const;
226
237 bool getDoSchema() const;
238
249 bool getValidationSchemaFullChecking() const;
250
261 bool getIdentityConstraintChecking() const;
262
273 int getErrorCount() const;
274
284 bool getDoNamespaces() const;
285
295 bool getExitOnFirstFatalError() const;
296
307 bool getValidationConstraintFatal() const;
308
328 XMLCh* getExternalSchemaLocation() const;
329
349 XMLCh* getExternalNoNamespaceSchemaLocation() const;
350
366 SecurityManager* getSecurityManager() const;
367
381 XMLSize_t getLowWaterMark() const;
382
394 bool getLoadExternalDTD() const;
395
407 bool getLoadSchema() const;
408
419 bool isCachingGrammarFromParse() const;
420
431 bool isUsingCachedGrammarInParse() const;
432
444 bool getCalculateSrcOfs() const;
445
456 bool getStandardUriConformant() const;
457
464 Grammar* getGrammar(const XMLCh* const nameSpaceKey);
465
471 Grammar* getRootGrammar();
472
479 const XMLCh* getURIText(unsigned int uriId) const;
480
487 XMLFilePos getSrcOffset() const;
488
500 bool getGenerateSyntheticAnnotations() const;
501
509 bool getValidateAnnotations() const;
510
518 bool getIgnoreCachedDTD() const;
519
527 bool getIgnoreAnnotations() const;
528
536 bool getDisableDefaultEntityResolution() const;
537
545 bool getSkipDTDValidation() const;
546
554 bool getHandleMultipleImports() const;
556
557
558 // -----------------------------------------------------------------------
559 // Setter methods
560 // -----------------------------------------------------------------------
561
574 void setGenerateSyntheticAnnotations(const bool newValue);
575
583 void setValidateAnnotations(const bool newValue);
584
598 void setDoNamespaces(const bool newState);
599
616 void setValidationScheme(const ValSchemes newScheme);
617
633 void setDoSchema(const bool newState);
634
651 void setValidationSchemaFullChecking(const bool schemaFullChecking);
652
664 void setIdentityConstraintChecking(const bool identityConstraintChecking);
665
681 void setExitOnFirstFatalError(const bool newState);
682
702 void setValidationConstraintFatal(const bool newState);
703
724 void setExternalSchemaLocation(const XMLCh* const schemaLocation);
725
734 void setExternalSchemaLocation(const char* const schemaLocation);
735
750 void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
751
760 void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
761
777 void setSecurityManager(SecurityManager* const securityManager);
778
792 void setLowWaterMark(XMLSize_t lwm);
793
810 void setLoadExternalDTD(const bool newState);
811
827 void setLoadSchema(const bool newState);
828
846 void cacheGrammarFromParse(const bool newState);
847
866 void useCachedGrammarInParse(const bool newState);
867
880 void setCalculateSrcOfs(const bool newState);
881
892 void setStandardUriConformant(const bool newState);
893
901 void useScanner(const XMLCh* const scannerName);
902
913 void setInputBufferSize(const XMLSize_t bufferSize);
914
929 void setIgnoreCachedDTD(const bool newValue);
930
940 void setIgnoreAnnotations(const bool newValue);
941
956 void setDisableDefaultEntityResolution(const bool newValue);
957
970 void setSkipDTDValidation(const bool newValue);
971
983 void setHandleMultipleImports(const bool newValue);
985
986
987 // -----------------------------------------------------------------------
988 // Advanced document handler list maintenance methods
989 // -----------------------------------------------------------------------
990
1008 void installAdvDocHandler(XMLDocumentHandler* const toInstall);
1009
1021 bool removeAdvDocHandler(XMLDocumentHandler* const toRemove);
1023
1024
1025 // -----------------------------------------------------------------------
1026 // Progressive scan methods
1027 // -----------------------------------------------------------------------
1028
1031
1059 bool parseFirst
1060 (
1061 const XMLCh* const systemId
1062 , XMLPScanToken& toFill
1063 );
1064
1092 bool parseFirst
1093 (
1094 const char* const systemId
1095 , XMLPScanToken& toFill
1096 );
1097
1125 bool parseFirst
1126 (
1127 const InputSource& source
1128 , XMLPScanToken& toFill
1129 );
1130
1155 bool parseNext(XMLPScanToken& token);
1156
1178 void parseReset(XMLPScanToken& token);
1179
1181
1182 // -----------------------------------------------------------------------
1183 // Grammar preparsing interface
1184 // -----------------------------------------------------------------------
1185
1214 Grammar* loadGrammar(const InputSource& source,
1215 const Grammar::GrammarType grammarType,
1216 const bool toCache = false);
1217
1242 Grammar* loadGrammar(const XMLCh* const systemId,
1243 const Grammar::GrammarType grammarType,
1244 const bool toCache = false);
1245
1269 Grammar* loadGrammar(const char* const systemId,
1270 const Grammar::GrammarType grammarType,
1271 const bool toCache = false);
1272
1276 void resetCachedGrammarPool();
1277
1279
1280
1281 // -----------------------------------------------------------------------
1282 // Implementation of the SAX Parser interface
1283 // -----------------------------------------------------------------------
1284
1296 virtual void parse(const InputSource& source);
1297
1307 virtual void parse(const XMLCh* const systemId);
1308
1316 virtual void parse(const char* const systemId);
1317
1328 virtual void setDocumentHandler(DocumentHandler* const handler);
1329
1339 virtual void setDTDHandler(DTDHandler* const handler);
1340
1351 virtual void setErrorHandler(ErrorHandler* const handler);
1352
1363 virtual void setPSVIHandler(PSVIHandler* const handler);
1364
1380 virtual void setEntityResolver(EntityResolver* const resolver);
1381
1397 virtual void setXMLEntityResolver(XMLEntityResolver* const resolver);
1398
1400
1401
1402 // -----------------------------------------------------------------------
1403 // Implementation of the XMLDocumentHandler interface
1404 // -----------------------------------------------------------------------
1405
1423 virtual void docCharacters
1424 (
1425 const XMLCh* const chars
1426 , const XMLSize_t length
1427 , const bool cdataSection
1428 );
1429
1439 virtual void docComment
1440 (
1441 const XMLCh* const comment
1442 );
1443
1463 virtual void docPI
1464 (
1465 const XMLCh* const target
1466 , const XMLCh* const data
1467 );
1468
1480 virtual void endDocument();
1481
1501 virtual void endElement
1502 (
1503 const XMLElementDecl& elemDecl
1504 , const unsigned int urlId
1505 , const bool isRoot
1506 , const XMLCh* const elemPrefix
1507 );
1508
1519 virtual void endEntityReference
1520 (
1521 const XMLEntityDecl& entDecl
1522 );
1523
1543 virtual void ignorableWhitespace
1544 (
1545 const XMLCh* const chars
1546 , const XMLSize_t length
1547 , const bool cdataSection
1548 );
1549
1554 virtual void resetDocument();
1555
1566 virtual void startDocument();
1567
1594 virtual void startElement
1595 (
1596 const XMLElementDecl& elemDecl
1597 , const unsigned int urlId
1598 , const XMLCh* const elemPrefix
1599 , const RefVectorOf<XMLAttr>& attrList
1600 , const XMLSize_t attrCount
1601 , const bool isEmpty
1602 , const bool isRoot
1603 );
1604
1614 virtual void startEntityReference
1615 (
1616 const XMLEntityDecl& entDecl
1617 );
1618
1636 virtual void XMLDecl
1637 (
1638 const XMLCh* const versionStr
1639 , const XMLCh* const encodingStr
1640 , const XMLCh* const standaloneStr
1641 , const XMLCh* const actualEncodingStr
1642 );
1644
1645
1646 // -----------------------------------------------------------------------
1647 // Implementation of the XMLErrorReporter interface
1648 // -----------------------------------------------------------------------
1649
1675 virtual void error
1676 (
1677 const unsigned int errCode
1678 , const XMLCh* const msgDomain
1679 , const XMLErrorReporter::ErrTypes errType
1680 , const XMLCh* const errorText
1681 , const XMLCh* const systemId
1682 , const XMLCh* const publicId
1683 , const XMLFileLoc lineNum
1684 , const XMLFileLoc colNum
1685 );
1686
1695 virtual void resetErrors();
1697
1698
1699 // -----------------------------------------------------------------------
1700 // Implementation of the XMLEntityHandler interface
1701 // -----------------------------------------------------------------------
1702
1716 virtual void endInputSource(const InputSource& inputSource);
1717
1732 virtual bool expandSystemId
1733 (
1734 const XMLCh* const systemId
1735 , XMLBuffer& toFill
1736 );
1737
1745 virtual void resetEntities();
1746
1763 virtual InputSource* resolveEntity
1764 (
1765 XMLResourceIdentifier* resourceIdentifier
1766 );
1767
1779 virtual void startInputSource(const InputSource& inputSource);
1781
1782
1783 // -----------------------------------------------------------------------
1784 // Implementation of the Deprecated DocTypeHandler Interface
1785 // -----------------------------------------------------------------------
1802 virtual void attDef
1803 (
1804 const DTDElementDecl& elemDecl
1805 , const DTDAttDef& attDef
1806 , const bool ignore
1807 );
1808
1818 virtual void doctypeComment
1819 (
1820 const XMLCh* const comment
1821 );
1822
1841 virtual void doctypeDecl
1842 (
1843 const DTDElementDecl& elemDecl
1844 , const XMLCh* const publicId
1845 , const XMLCh* const systemId
1846 , const bool hasIntSubset
1847 , const bool hasExtSubset = false
1848 );
1849
1863 virtual void doctypePI
1864 (
1865 const XMLCh* const target
1866 , const XMLCh* const data
1867 );
1868
1880 virtual void doctypeWhitespace
1881 (
1882 const XMLCh* const chars
1883 , const XMLSize_t length
1884 );
1885
1898 virtual void elementDecl
1899 (
1900 const DTDElementDecl& decl
1901 , const bool isIgnored
1902 );
1903
1914 virtual void endAttList
1915 (
1916 const DTDElementDecl& elemDecl
1917 );
1918
1925 virtual void endIntSubset();
1926
1933 virtual void endExtSubset();
1934
1949 virtual void entityDecl
1950 (
1951 const DTDEntityDecl& entityDecl
1952 , const bool isPEDecl
1953 , const bool isIgnored
1954 );
1955
1960 virtual void resetDocType();
1961
1974 virtual void notationDecl
1975 (
1976 const XMLNotationDecl& notDecl
1977 , const bool isIgnored
1978 );
1979
1990 virtual void startAttList
1991 (
1992 const DTDElementDecl& elemDecl
1993 );
1994
2001 virtual void startIntSubset();
2002
2009 virtual void startExtSubset();
2010
2023 virtual void TextDecl
2024 (
2025 const XMLCh* const versionStr
2026 , const XMLCh* const encodingStr
2027 );
2029
2030 protected :
2031 // -----------------------------------------------------------------------
2032 // Protected Methods
2033 // -----------------------------------------------------------------------
2040 const XMLScanner& getScanner() const;
2041
2046 GrammarResolver* getGrammarResolver() const;
2047
2048
2049 private:
2050 // -----------------------------------------------------------------------
2051 // Unimplemented constructors and operators
2052 // -----------------------------------------------------------------------
2053 SAXParser(const SAXParser&);
2054 SAXParser& operator=(const SAXParser&);
2055
2056 // -----------------------------------------------------------------------
2057 // Initialize/Cleanup methods
2058 // -----------------------------------------------------------------------
2059 void initialize();
2060 void cleanUp();
2061 void resetInProgress();
2062
2063 // -----------------------------------------------------------------------
2064 // Private data members
2065 //
2066 // fAttrList
2067 // A temporary implementation of the basic SAX attribute list
2068 // interface. We use this one over and over on each startElement
2069 // event to allow SAX-like access to the element attributes.
2070 //
2071 // fDocHandler
2072 // The installed SAX doc handler, if any. Null if none.
2073 //
2074 // fDTDHandler
2075 // The installed SAX DTD handler, if any. Null if none.
2076 //
2077 // fElemDepth
2078 // This is used to track the element nesting depth, so that we can
2079 // know when we are inside content. This is so we can ignore char
2080 // data outside of content.
2081 //
2082 // fEntityResolver
2083 // The installed SAX entity handler, if any. Null if none.
2084 //
2085 // fErrorHandler
2086 // The installed SAX error handler, if any. Null if none.
2087 //
2088 // fPSVIHandler
2089 // The installed PSVI handler, if any. Null if none.
2090 //
2091 // fAdvDHCount
2092 // fAdvDHList
2093 // fAdvDHListSize
2094 // This is an array of pointers to XMLDocumentHandlers, which is
2095 // how we see installed advanced document handlers. There will
2096 // usually not be very many at all, so a simple array is used
2097 // instead of a collection, for performance. It will grow if needed,
2098 // but that is unlikely.
2099 //
2100 // The count is how many handlers are currently installed. The size
2101 // is how big the array itself is (for expansion purposes.) When
2102 // count == size, is time to expand.
2103 //
2104 // fParseInProgress
2105 // This flag is set once a parse starts. It is used to prevent
2106 // multiple entrance or reentrance of the parser.
2107 //
2108 // fScanner
2109 // The scanner being used by this parser. It is created internally
2110 // during construction.
2111 //
2112 // fGrammarPool
2113 // The grammar pool passed from external application (through derivatives).
2114 // which could be 0, not owned.
2115 //
2116 // -----------------------------------------------------------------------
2117 bool fParseInProgress;
2118 XMLSize_t fElemDepth;
2119 XMLSize_t fAdvDHCount;
2120 XMLSize_t fAdvDHListSize;
2121 VecAttrListImpl fAttrList;
2122 DocumentHandler* fDocHandler;
2123 DTDHandler* fDTDHandler;
2124 EntityResolver* fEntityResolver;
2125 XMLEntityResolver* fXMLEntityResolver;
2126 ErrorHandler* fErrorHandler;
2127 PSVIHandler* fPSVIHandler;
2128 XMLDocumentHandler** fAdvDHList;
2129 XMLScanner* fScanner;
2130 GrammarResolver* fGrammarResolver;
2131 XMLStringPool* fURIStringPool;
2132 XMLValidator* fValidator;
2133 MemoryManager* fMemoryManager;
2134 XMLGrammarPool* fGrammarPool;
2135 XMLBuffer fElemQNameBuf;
2136 };
2137
2138
2139 // ---------------------------------------------------------------------------
2140 // SAXParser: Getter methods
2141 // ---------------------------------------------------------------------------
2142 inline DocumentHandler* SAXParser::getDocumentHandler()
2143 {
2144 return fDocHandler;
2145 }
2146
2147 inline const DocumentHandler* SAXParser::getDocumentHandler() const
2148 {
2149 return fDocHandler;
2150 }
2151
2152 inline EntityResolver* SAXParser::getEntityResolver()
2153 {
2154 return fEntityResolver;
2155 }
2156
2157 inline XMLEntityResolver* SAXParser::getXMLEntityResolver()
2158 {
2159 return fXMLEntityResolver;
2160 }
2161
2162 inline const XMLEntityResolver* SAXParser::getXMLEntityResolver() const
2163 {
2164 return fXMLEntityResolver;
2165 }
2166
2167 inline const EntityResolver* SAXParser::getEntityResolver() const
2168 {
2169 return fEntityResolver;
2170 }
2171
2172 inline ErrorHandler* SAXParser::getErrorHandler()
2173 {
2174 return fErrorHandler;
2175 }
2176
2177 inline const ErrorHandler* SAXParser::getErrorHandler() const
2178 {
2179 return fErrorHandler;
2180 }
2181
2182 inline PSVIHandler* SAXParser::getPSVIHandler()
2183 {
2184 return fPSVIHandler;
2185 }
2186
2187 inline const PSVIHandler* SAXParser::getPSVIHandler() const
2188 {
2189 return fPSVIHandler;
2190 }
2191
2192 inline const XMLScanner& SAXParser::getScanner() const
2193 {
2194 return *fScanner;
2195 }
2196
2197 inline GrammarResolver* SAXParser::getGrammarResolver() const
2198 {
2199 return fGrammarResolver;
2200 }
2201
2202 XERCES_CPP_NAMESPACE_END
2203
2204 #endif
Parser::setEntityResolver
virtual void setEntityResolver(EntityResolver *const resolver)=0
Allow an application to register a custom entity resolver.
XMLDocumentHandler.hpp
XMLDocumentHandler::startEntityReference
virtual void startEntityReference(const XMLEntityDecl &entDecl)=0
Receive notification when the scanner hits an entity reference.
DocumentHandler
Receive notification of general document events.
Definition: DocumentHandler.hpp:60
XMemory
This class makes it possible to override the C++ memory management by adding new/delete operators to ...
Definition: XMemory.hpp:40
XMLErrorReporter::error
virtual void error(const unsigned int errCode, const XMLCh *const errDomain, const ErrTypes type, const XMLCh *const errorText, const XMLCh *const systemId, const XMLCh *const publicId, const XMLFileLoc lineNum, const XMLFileLoc colNum)=0
Called to report errors from the scanner or validator.
XMLDocumentHandler::endEntityReference
virtual void endEntityReference(const XMLEntityDecl &entDecl)=0
Receive notification when a referenced entity&#39;s content ends.
XMLEntityHandler::resetEntities
virtual void resetEntities()=0
This method allows the entity handler to reset itself, so that it can be used again.
XMLPlatformUtils::fgMemoryManager
static MemoryManager * fgMemoryManager
The configurable memory manager.
Definition: PlatformUtils.hpp:121
SAXParser::getDocumentHandler
DocumentHandler * getDocumentHandler()
This method returns the installed document handler.
Definition: SAXParser.hpp:2142
Parser::parse
virtual void parse(const InputSource &source)=0
Parse an XML document.
XMLEntityHandler::endInputSource
virtual void endInputSource(const InputSource &inputSource)=0
This method get called after the scanner has finished reading from the given input source while proce...
XMLFileLoc
XMLUInt64 XMLFileLoc
Definition: Xerces_autoconf_config.hpp:142
XMLErrorReporter
This abstract class defines a callback mechanism for the scanner.
Definition: XMLErrorReporter.hpp:42
DTDHandler
Receive notification of basic DTD-related events.
Definition: DTDHandler.hpp:59
XMLDocumentHandler::docComment
virtual void docComment(const XMLCh *const comment)=0
Receive notification of comments in the XML content being parsed.
Parser::setDTDHandler
virtual void setDTDHandler(DTDHandler *const handler)=0
Allow an application to register a DTD event handler.
PARSERS_EXPORT
#define PARSERS_EXPORT
Definition: XercesDefs.hpp:168
XMLGrammarPool
Definition: XMLGrammarPool.hpp:43
XMLDocumentHandler::startElement
virtual void startElement(const XMLElementDecl &elemDecl, const unsigned int uriId, const XMLCh *const prefixName, const RefVectorOf< XMLAttr > &attrList, const XMLSize_t attrCount, const bool isEmpty, const bool isRoot)=0
Receive notification of a new start tag.
XMLDocumentHandler::resetDocument
virtual void resetDocument()=0
Reset the document handler&#39;s state, if required.
XMLErrorReporter::resetErrors
virtual void resetErrors()=0
Called before a new parse event to allow the handler to reset.
EntityResolver
Basic interface for resolving entities.
Definition: EntityResolver.hpp:86
XMLNotationDecl
This class represents the core information about a notation declaration that all validators must at l...
Definition: XMLNotationDecl.hpp:41
SAXParser::getXMLEntityResolver
XMLEntityResolver * getXMLEntityResolver()
This method returns the installed entity resolver.
Definition: SAXParser.hpp:2157
XMLEntityHandler.hpp
XMLEntityHandler::expandSystemId
virtual bool expandSystemId(const XMLCh *const systemId, XMLBuffer &toFill)=0
This method allows the passes the scanned systemId to the entity handler, thereby giving it a chance ...
SecurityManager.hpp
ErrorHandler
Basic interface for SAX error handlers.
Definition: ErrorHandler.hpp:60
Parser::setErrorHandler
virtual void setErrorHandler(ErrorHandler *const handler)=0
Allow an application to register an error event handler.
XMLDocumentHandler::ignorableWhitespace
virtual void ignorableWhitespace(const XMLCh *const chars, const XMLSize_t length, const bool cdataSection)=0
Receive notification of ignorable whitespace in element content.
XMLErrorReporter::ErrTypes
ErrTypes
Definition: XMLErrorReporter.hpp:48
SAXParser::ValSchemes
ValSchemes
ValScheme enum used in setValidationScheme Val_Never: Do not report validation errors.
Definition: SAXParser.hpp:90
XMLFilePos
XMLUInt64 XMLFilePos
Definition: Xerces_autoconf_config.hpp:137
Parser::setDocumentHandler
virtual void setDocumentHandler(DocumentHandler *const handler)=0
Allow an application to register a document event handler.
PSVIHandler
This abstract class provides the interface for the scanner to return PSVI information to the applicat...
Definition: PSVIHandler.hpp:38
XMLDocumentHandler::startDocument
virtual void startDocument()=0
Receive notification of the start of a new document.
XMLDocumentHandler
This abstract class provides the interface for the scanner to return XML document information up to t...
Definition: XMLDocumentHandler.hpp:42
MemoryManager
Configurable memory manager.
Definition: MemoryManager.hpp:39
XMLElementDecl
This class defines the core information of an element declaration.
Definition: XMLElementDecl.hpp:51
XMLCh
uint16_t XMLCh
Definition: Xerces_autoconf_config.hpp:118
XMLDocumentHandler::docCharacters
virtual void docCharacters(const XMLCh *const chars, const XMLSize_t length, const bool cdataSection)=0
Receive notification of character data.
XERCES_CPP_NAMESPACE_BEGIN
#define XERCES_CPP_NAMESPACE_BEGIN
Definition: XercesDefs.hpp:112
XMLDocumentHandler::endElement
virtual void endElement(const XMLElementDecl &elemDecl, const unsigned int uriId, const bool isRoot, const XMLCh *const prefixName=0)=0
Receive notification of the end of an element.
XMLResourceIdentifier
Definition: XMLResourceIdentifier.hpp:95
XMLEntityHandler::startInputSource
virtual void startInputSource(const InputSource &inputSource)=0
This method will be called before the scanner starts reading from an input source while processing ex...
Parser.hpp
XMLValidator
This abstract class provides the interface for all validators.
Definition: XMLValidator.hpp:52
SAXParser::getPSVIHandler
PSVIHandler * getPSVIHandler()
This method returns the installed PSVI handler.
Definition: SAXParser.hpp:2182
XMLSize_t
size_t XMLSize_t
Definition: Xerces_autoconf_config.hpp:110
XMLEntityHandler
This abstract class is a callback mechanism for the scanner.
Definition: XMLEntityHandler.hpp:43
XMLErrorReporter.hpp
XERCES_CPP_NAMESPACE_END
#define XERCES_CPP_NAMESPACE_END
Definition: XercesDefs.hpp:113
SecurityManager
Allow application to force the parser to behave in a security-conscious way.
Definition: SecurityManager.hpp:51
SAXParser
This class implements the SAX &#39;Parser&#39; interface and should be used by applications wishing to parse ...
Definition: SAXParser.hpp:69
XMLDocumentHandler::endDocument
virtual void endDocument()=0
Receive notification after the scanner has parsed the end of the document.
XMLDocumentHandler::XMLDecl
virtual void XMLDecl(const XMLCh *const versionStr, const XMLCh *const encodingStr, const XMLCh *const standaloneStr, const XMLCh *const autoEncodingStr)=0
Receive notification of an XML declaration.
XMLElementDecl.hpp
XMLEntityDecl
This class defines that core information that defines an XML entity, no matter what validator is used...
Definition: XMLEntityDecl.hpp:50
XMLDocumentHandler::docPI
virtual void docPI(const XMLCh *const target, const XMLCh *const data)=0
Receive notification of PI&#39;s parsed in the XML content.
SAXParser::getErrorHandler
ErrorHandler * getErrorHandler()
This method returns the installed error handler.
Definition: SAXParser.hpp:2172
XMLEntityHandler::resolveEntity
virtual InputSource * resolveEntity(XMLResourceIdentifier *resourceIdentifier)=0
This method allows the entity handler to provide customized application specific entity resolution...
SAXParser::getEntityResolver
EntityResolver * getEntityResolver()
This method returns the installed entity resolver.
Definition: SAXParser.hpp:2152
Parser
Basic interface for SAX (Simple API for XML) parsers.
Definition: Parser.hpp:60
InputSource
A single input source for an XML entity.
Definition: InputSource.hpp:62
SAXParser::getScanner
const XMLScanner & getScanner() const
This method returns a reference to the underlying scanner object.
Definition: SAXParser.hpp:2192
SAXParser::getGrammarResolver
GrammarResolver * getGrammarResolver() const
Get the Grammar resolver.
Definition: SAXParser.hpp:2197
XMLEntityResolver
Revised interface for resolving entities.
Definition: XMLEntityResolver.hpp:99