AbstractDOMParser.hpp
Go to the documentation of this file.
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* $Id: AbstractDOMParser.hpp 932889 2010-04-11 13:10:10Z borisk $
*/
#if !defined(XERCESC_INCLUDE_GUARD_ABSTRACTDOMPARSER_HPP)
#define XERCESC_INCLUDE_GUARD_ABSTRACTDOMPARSER_HPP
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/framework/XMLDocumentHandler.hpp>
#include <xercesc/framework/XMLErrorReporter.hpp>
#include <xercesc/framework/XMLEntityHandler.hpp>
#include <xercesc/util/SecurityManager.hpp>
#include <xercesc/util/ValueStackOf.hpp>
#include <xercesc/validators/DTD/DocTypeHandler.hpp>
#include <xercesc/dom/DOMDocumentType.hpp>
#include <xercesc/validators/DTD/DTDElementDecl.hpp>
#include <xercesc/framework/XMLBufferMgr.hpp>
#include <xercesc/framework/psvi/PSVIHandler.hpp>
XERCES_CPP_NAMESPACE_BEGIN
class XMLPScanToken;
class XMLScanner;
class XMLValidator;
class DOMDocumentImpl;
class DOMDocumentTypeImpl;
class DOMEntityImpl;
class DOMElement;
class GrammarResolver;
class XMLGrammarPool;
class PSVIHandler;
class PARSERS_EXPORT AbstractDOMParser :
public XMemory
, public XMLDocumentHandler
, public XMLErrorReporter
, public XMLEntityHandler
, public DocTypeHandler
, public PSVIHandler
{
public :
// -----------------------------------------------------------------------
// Class types
// -----------------------------------------------------------------------
enum ValSchemes
{
Val_Never
, Val_Always
, Val_Auto
};
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
virtual ~AbstractDOMParser();
// -----------------------------------------------------------------------
// Utility methods
// -----------------------------------------------------------------------
void reset();
DOMDocument* adoptDocument();
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
DOMDocument* getDocument();
const XMLValidator& getValidator() const;
ValSchemes getValidationScheme() const;
bool getDoSchema() const;
bool getValidationSchemaFullChecking() const;
bool getIdentityConstraintChecking() const;
XMLSize_t getErrorCount() const;
bool getDoNamespaces() const;
bool getExitOnFirstFatalError() const;
bool getValidationConstraintFatal() const;
bool getCreateEntityReferenceNodes()const;
bool getIncludeIgnorableWhitespace() const;
XMLCh* getExternalSchemaLocation() const;
XMLCh* getExternalNoNamespaceSchemaLocation() const;
SecurityManager* getSecurityManager() const;
const XMLSize_t& getLowWaterMark() const;
bool getLoadExternalDTD() const;
bool getLoadSchema() const;
bool getCreateCommentNodes()const;
bool getCalculateSrcOfs() const;
bool getStandardUriConformant() const;
PSVIHandler* getPSVIHandler();
const PSVIHandler* getPSVIHandler() const;
bool getCreateSchemaInfo() const;
bool getDoXInclude() const;
bool getGenerateSyntheticAnnotations() const;
bool getValidateAnnotations() const;
bool getIgnoreAnnotations() const;
bool getDisableDefaultEntityResolution() const;
bool getSkipDTDValidation() const;
bool getHandleMultipleImports() const;
// -----------------------------------------------------------------------
// Setter methods
// -----------------------------------------------------------------------
void setGenerateSyntheticAnnotations(const bool newValue);
void setValidateAnnotations(const bool newValue);
void setDoNamespaces(const bool newState);
void setExitOnFirstFatalError(const bool newState);
void setValidationConstraintFatal(const bool newState);
void setCreateEntityReferenceNodes(const bool create);
void setIncludeIgnorableWhitespace(const bool include);
void setValidationScheme(const ValSchemes newScheme);
void setDoSchema(const bool newState);
void setValidationSchemaFullChecking(const bool schemaFullChecking);
void setIdentityConstraintChecking(const bool newState);
void setExternalSchemaLocation(const XMLCh* const schemaLocation);
void setExternalSchemaLocation(const char* const schemaLocation);
void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
void setSecurityManager(SecurityManager* const securityManager);
void setLowWaterMark(XMLSize_t lwm);
void setLoadExternalDTD(const bool newState);
void setLoadSchema(const bool newState);
void setCreateCommentNodes(const bool create);
void setCalculateSrcOfs(const bool newState);
void setStandardUriConformant(const bool newState);
void useScanner(const XMLCh* const scannerName);
void useImplementation(const XMLCh* const implementationFeatures);
virtual void setPSVIHandler(PSVIHandler* const handler);
void setCreateSchemaInfo(const bool newState);
void setDoXInclude(const bool newState);
void setIgnoreAnnotations(const bool newValue);
void setDisableDefaultEntityResolution(const bool newValue);
void setSkipDTDValidation(const bool newValue);
void setHandleMultipleImports(const bool newValue);
// -----------------------------------------------------------------------
// Parsing methods
// -----------------------------------------------------------------------
void parse(const InputSource& source);
void parse(const XMLCh* const systemId);
void parse(const char* const systemId);
bool parseFirst
(
const XMLCh* const systemId
, XMLPScanToken& toFill
);
bool parseFirst
(
const char* const systemId
, XMLPScanToken& toFill
);
bool parseFirst
(
const InputSource& source
, XMLPScanToken& toFill
);
bool parseNext(XMLPScanToken& token);
void parseReset(XMLPScanToken& token);
// -----------------------------------------------------------------------
// Implementation of the PSVIHandler interface.
// -----------------------------------------------------------------------
virtual void handleElementPSVI
(
const XMLCh* const localName
, const XMLCh* const uri
, PSVIElement * elementInfo
);
virtual void handlePartialElementPSVI
(
const XMLCh* const localName
, const XMLCh* const uri
, PSVIElement * elementInfo
);
virtual void handleAttributesPSVI
(
const XMLCh* const localName
, const XMLCh* const uri
, PSVIAttributeList * psviAttributes
);
// -----------------------------------------------------------------------
// Implementation of the XMLDocumentHandler interface.
// -----------------------------------------------------------------------
virtual void docCharacters
(
const XMLCh* const chars
, const XMLSize_t length
, const bool cdataSection
);
virtual void docComment
(
const XMLCh* const comment
);
virtual void docPI
(
const XMLCh* const target
, const XMLCh* const data
);
virtual void endDocument();
virtual void endElement
(
const XMLElementDecl& elemDecl
, const unsigned int urlId
, const bool isRoot
, const XMLCh* const elemPrefix
);
virtual void endEntityReference
(
const XMLEntityDecl& entDecl
);
virtual void ignorableWhitespace
(
const XMLCh* const chars
, const XMLSize_t length
, const bool cdataSection
);
virtual void resetDocument();
virtual void startDocument();
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
);
virtual void startEntityReference
(
const XMLEntityDecl& entDecl
);
virtual void XMLDecl
(
const XMLCh* const versionStr
, const XMLCh* const encodingStr
, const XMLCh* const standaloneStr
, const XMLCh* const actualEncStr
);
// -----------------------------------------------------------------------
// Implementation of the deprecated DocTypeHandler interface.
// -----------------------------------------------------------------------
virtual void attDef
(
const DTDElementDecl& elemDecl
, const DTDAttDef& attDef
, const bool ignoring
);
virtual void doctypeComment
(
const XMLCh* const comment
);
virtual void doctypeDecl
(
const DTDElementDecl& elemDecl
, const XMLCh* const publicId
, const XMLCh* const systemId
, const bool hasIntSubset
, const bool hasExtSubset = false
);
virtual void doctypePI
(
const XMLCh* const target
, const XMLCh* const data
);
virtual void doctypeWhitespace
(
const XMLCh* const chars
, const XMLSize_t length
);
virtual void elementDecl
(
const DTDElementDecl& decl
, const bool isIgnored
);
virtual void endAttList
(
const DTDElementDecl& elemDecl
);
virtual void endIntSubset();
virtual void endExtSubset();
virtual void entityDecl
(
const DTDEntityDecl& entityDecl
, const bool isPEDecl
, const bool isIgnored
);
virtual void resetDocType();
virtual void notationDecl
(
const XMLNotationDecl& notDecl
, const bool isIgnored
);
virtual void startAttList
(
const DTDElementDecl& elemDecl
);
virtual void startIntSubset();
virtual void startExtSubset();
virtual void TextDecl
(
const XMLCh* const versionStr
, const XMLCh* const encodingStr
);
protected:
// DOM node creation hooks. Override them if you are using your own
// DOM node types.
//
virtual DOMCDATASection* createCDATASection (const XMLCh*, XMLSize_t);
virtual DOMText* createText (const XMLCh*, XMLSize_t);
virtual DOMElement* createElement (const XMLCh* name);
virtual DOMElement* createElementNS (const XMLCh* namespaceURI,
const XMLCh* elemPrefix,
const XMLCh* localName,
const XMLCh* qName);
virtual DOMAttr* createAttr (const XMLCh* name);
virtual DOMAttr* createAttrNS (const XMLCh* namespaceURI,
const XMLCh* elemPrefix,
const XMLCh* localName,
const XMLCh* qName);
protected :
// -----------------------------------------------------------------------
// Protected Constructor Methods
// -----------------------------------------------------------------------
AbstractDOMParser
(
XMLValidator* const valToAdopt = 0
, MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
, XMLGrammarPool* const gramPool = 0
);
// -----------------------------------------------------------------------
// Protected getter methods
// -----------------------------------------------------------------------
DOMNode* getCurrentNode();
XMLScanner* getScanner() const;
GrammarResolver* getGrammarResolver() const;
bool getParseInProgress() const;
MemoryManager* getMemoryManager() const;
// -----------------------------------------------------------------------
// Protected setter methods
// -----------------------------------------------------------------------
void setCurrentNode(DOMNode* toSet);
void setDocument(DOMDocument* toSet);
void setParseInProgress(const bool toSet);
// -----------------------------------------------------------------------
// Protected Helper methods
// -----------------------------------------------------------------------
void resetPool();
bool isDocumentAdopted() const;
private :
// -----------------------------------------------------------------------
// Initialize/Cleanup methods
// -----------------------------------------------------------------------
void initialize();
void cleanUp();
void resetInProgress();
// -----------------------------------------------------------------------
// Unimplemented constructors and operators
// -----------------------------------------------------------------------
AbstractDOMParser(const AbstractDOMParser&);
AbstractDOMParser& operator=(const AbstractDOMParser&);
protected:
// -----------------------------------------------------------------------
// Protected data members
//
// fCurrentNode
// fCurrentParent
// Used to track the current node during nested element events. Since
// the tree must be built from a set of disjoint callbacks, we need
// these to keep up with where we currently are.
//
// fCurrentEntity
// Used to track the current entity decl. If a text decl is seen later on,
// it is used to update the encoding and version information.
//
// fDocument
// The root document object, filled with the document contents.
//
// fCreateEntityReferenceNodes
// Indicates whether entity reference nodes should be created.
//
// fIncludeIgnorableWhitespace
// Indicates whether ignorable whitespace should be added to
// the DOM tree for validating parsers.
//
// fScanner
// The scanner used for this parser. This is created during the
// constructor.
//
// fImplementationFeatures
// The implementation features that we use to get an implementation
// for use in creating the DOMDocument used during parse. If this is
// null then the default DOMImplementation is used
//
// fParseInProgress
// Used to prevent multiple entrance to the parser while its doing
// a parse.
//
// fWithinElement
// A flag to indicate that the parser is within at least one level
// of element processing.
//
// fDocumentType
// Used to store and update the documentType variable information
// in fDocument
//
// fDocumentVector
// Store all the previous fDocument(s) (thus not the current fDocument)
// created in this parser. It is destroyed when the parser is destructed.
//
// fCreateCommentNodes
// Indicates whether comment nodes should be created.
//
// fDocumentAdoptedByUser
// The DOMDocument ownership has been transferred to application
// If set to true, the parser does not own the document anymore
// and thus will not release its memory.
//
// fInternalSubset
// Buffer for storing the internal subset information.
// Once complete (after DOCTYPE is finished scanning), send
// it to DocumentType Node
//
// fGrammarPool
// The grammar pool passed from external application (through derivatives).
// which could be 0, not owned.
//
// fCreateSchemaInfo
// Indicates whether element and attributes will have schema info associated
//
// fDoXinclude
// A bool used to request that XInlcude processing occur on the
// Document the parser parses.
// -----------------------------------------------------------------------
bool fCreateEntityReferenceNodes;
bool fIncludeIgnorableWhitespace;
bool fWithinElement;
bool fParseInProgress;
bool fCreateCommentNodes;
bool fDocumentAdoptedByUser;
bool fCreateSchemaInfo;
bool fDoXInclude;
XMLScanner* fScanner;
XMLCh* fImplementationFeatures;
DOMNode* fCurrentParent;
DOMNode* fCurrentNode;
DOMEntityImpl* fCurrentEntity;
DOMDocumentImpl* fDocument;
DOMDocumentTypeImpl* fDocumentType;
RefVectorOf<DOMDocumentImpl>* fDocumentVector;
GrammarResolver* fGrammarResolver;
XMLStringPool* fURIStringPool;
XMLValidator* fValidator;
MemoryManager* fMemoryManager;
XMLGrammarPool* fGrammarPool;
XMLBufferMgr fBufMgr;
XMLBuffer& fInternalSubset;
PSVIHandler* fPSVIHandler;
};
// ---------------------------------------------------------------------------
// AbstractDOMParser: Getter methods
// ---------------------------------------------------------------------------
inline bool AbstractDOMParser::getCreateEntityReferenceNodes() const
{
return fCreateEntityReferenceNodes;
}
inline bool AbstractDOMParser::getIncludeIgnorableWhitespace() const
{
return fIncludeIgnorableWhitespace;
}
inline bool AbstractDOMParser::getParseInProgress() const
{
return fParseInProgress;
}
inline XMLScanner* AbstractDOMParser::getScanner() const
{
return fScanner;
}
inline GrammarResolver* AbstractDOMParser::getGrammarResolver() const
{
return fGrammarResolver;
}
inline bool AbstractDOMParser::getCreateCommentNodes() const
{
return fCreateCommentNodes;
}
inline PSVIHandler* AbstractDOMParser::getPSVIHandler()
{
return fPSVIHandler;
}
inline const PSVIHandler* AbstractDOMParser::getPSVIHandler() const
{
return fPSVIHandler;
}
inline bool AbstractDOMParser::getCreateSchemaInfo() const
{
return fCreateSchemaInfo;
}
inline bool AbstractDOMParser::getDoXInclude() const
{
return fDoXInclude;
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Setter methods
// ---------------------------------------------------------------------------
inline void AbstractDOMParser::setCreateEntityReferenceNodes(const bool create)
{
fCreateEntityReferenceNodes = create;
}
inline void AbstractDOMParser::setIncludeIgnorableWhitespace(const bool include)
{
fIncludeIgnorableWhitespace = include;
}
inline void AbstractDOMParser::setCreateCommentNodes(const bool create)
{
fCreateCommentNodes = create;
}
inline void AbstractDOMParser::useImplementation(const XMLCh* const implementationFeatures)
{
fMemoryManager->deallocate(fImplementationFeatures);
fImplementationFeatures = XMLString::replicate(implementationFeatures, fMemoryManager);
}
inline void AbstractDOMParser::setDoXInclude(const bool newState)
{
fDoXInclude = newState;
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Protected getter methods
// ---------------------------------------------------------------------------
inline DOMNode* AbstractDOMParser::getCurrentNode()
{
return fCurrentNode;
}
inline MemoryManager* AbstractDOMParser::getMemoryManager() const
{
return fMemoryManager;
}
// ---------------------------------------------------------------------------
// AbstractDOMParser: Protected setter methods
// ---------------------------------------------------------------------------
inline void AbstractDOMParser::setCurrentNode(DOMNode* toSet)
{
fCurrentNode = toSet;
}
inline void AbstractDOMParser::setParseInProgress(const bool toSet)
{
fParseInProgress = toSet;
}
XERCES_CPP_NAMESPACE_END
#endif
XMLDocumentHandler.hpp
PSVIHandler::handleElementPSVI
virtual void handleElementPSVI(const XMLCh *const localName, const XMLCh *const uri, PSVIElement *elementInfo)=0
Receive notification of the PSVI properties of an element.
AbstractDOMParser::fDocumentType
DOMDocumentTypeImpl * fDocumentType
Definition: AbstractDOMParser.hpp:1777
AbstractDOMParser::fCurrentEntity
DOMEntityImpl * fCurrentEntity
Definition: AbstractDOMParser.hpp:1775
AbstractDOMParser::fGrammarResolver
GrammarResolver * fGrammarResolver
Definition: AbstractDOMParser.hpp:1779
AbstractDOMParser::fGrammarPool
XMLGrammarPool * fGrammarPool
Definition: AbstractDOMParser.hpp:1783
XMLDocumentHandler::startEntityReference
virtual void startEntityReference(const XMLEntityDecl &entDecl)=0
Receive notification when the scanner hits an entity reference.
DOMAttr
The DOMAttr class refers to an attribute of an XML element.
Definition: DOMAttr.hpp:57
XMLString::replicate
static char * replicate(const char *const toRep, MemoryManager *const manager=XMLPlatformUtils::fgMemoryManager)
Replicates a string NOTE: The returned buffer is allocated with the MemoryManager.
AbstractDOMParser::getScanner
XMLScanner * getScanner() const
Get the XML scanner.
Definition: AbstractDOMParser.hpp:1809
AbstractDOMParser::getIncludeIgnorableWhitespace
bool getIncludeIgnorableWhitespace() const
Get the &#39;include ignorable whitespace&#39; flag.
Definition: AbstractDOMParser.hpp:1799
AbstractDOMParser::fValidator
XMLValidator * fValidator
Definition: AbstractDOMParser.hpp:1781
XMemory
This class makes it possible to override the C++ memory management by adding new/delete operators to ...
Definition: XMemory.hpp:40
AbstractDOMParser::setCurrentNode
void setCurrentNode(DOMNode *toSet)
Set the current DOM node.
Definition: AbstractDOMParser.hpp:1888
XMLDocumentHandler::endEntityReference
virtual void endEntityReference(const XMLEntityDecl &entDecl)=0
Receive notification when a referenced entity&#39;s content ends.
XMLPlatformUtils::fgMemoryManager
static MemoryManager * fgMemoryManager
The configurable memory manager.
Definition: PlatformUtils.hpp:121
XMLErrorReporter
This abstract class defines a callback mechanism for the scanner.
Definition: XMLErrorReporter.hpp:42
XMLDocumentHandler::docComment
virtual void docComment(const XMLCh *const comment)=0
Receive notification of comments in the XML content being parsed.
PSVIHandler::handlePartialElementPSVI
virtual void handlePartialElementPSVI(const XMLCh *const localName, const XMLCh *const uri, PSVIElement *elementInfo)
Receive notification of partial PSVI properties of an element.
Definition: PSVIHandler.hpp:139
PARSERS_EXPORT
#define PARSERS_EXPORT
Definition: XercesDefs.hpp:168
AbstractDOMParser::fDoXInclude
bool fDoXInclude
Definition: AbstractDOMParser.hpp:1770
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.
AbstractDOMParser
This class implements the Document Object Model (DOM) interface.
Definition: AbstractDOMParser.hpp:54
XMLDocumentHandler::resetDocument
virtual void resetDocument()=0
Reset the document handler&#39;s state, if required.
AbstractDOMParser::fCurrentNode
DOMNode * fCurrentNode
Definition: AbstractDOMParser.hpp:1774
AbstractDOMParser::setCreateEntityReferenceNodes
void setCreateEntityReferenceNodes(const bool create)
Set the &#39;include entity references&#39; flag.
Definition: AbstractDOMParser.hpp:1846
AbstractDOMParser::fCreateSchemaInfo
bool fCreateSchemaInfo
Definition: AbstractDOMParser.hpp:1769
PSVIHandler.hpp
XMLNotationDecl
This class represents the core information about a notation declaration that all validators must at l...
Definition: XMLNotationDecl.hpp:41
AbstractDOMParser::setIncludeIgnorableWhitespace
void setIncludeIgnorableWhitespace(const bool include)
Set the &#39;include ignorable whitespace&#39; flag.
Definition: AbstractDOMParser.hpp:1851
AbstractDOMParser::getCreateEntityReferenceNodes
bool getCreateEntityReferenceNodes() const
Get the &#39;include entity references&#39; flag.
Definition: AbstractDOMParser.hpp:1794
AbstractDOMParser::setParseInProgress
void setParseInProgress(const bool toSet)
Set the parse in progress flag.
Definition: AbstractDOMParser.hpp:1893
XMLEntityHandler.hpp
AbstractDOMParser::useImplementation
void useImplementation(const XMLCh *const implementationFeatures)
Set the implementation to use when creating the document.
Definition: AbstractDOMParser.hpp:1861
SecurityManager.hpp
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.
DOMDocument
The DOMDocument interface represents the entire XML document.
Definition: DOMDocument.hpp:64
AbstractDOMParser::getMemoryManager
MemoryManager * getMemoryManager() const
Definition: AbstractDOMParser.hpp:1880
DOMElement
By far the vast majority of objects (apart from text) that authors encounter when traversing a docume...
Definition: DOMElement.hpp:66
AbstractDOMParser::setCreateCommentNodes
void setCreateCommentNodes(const bool create)
Set the &#39;create comment nodes&#39; flag.
Definition: AbstractDOMParser.hpp:1856
PSVIElement
Definition: PSVIElement.hpp:41
PSVIHandler
This abstract class provides the interface for the scanner to return PSVI information to the applicat...
Definition: PSVIHandler.hpp:38
DOMDocumentType.hpp
AbstractDOMParser::getCurrentNode
DOMNode * getCurrentNode()
Get the current DOM node.
Definition: AbstractDOMParser.hpp:1875
XMLDocumentHandler::startDocument
virtual void startDocument()=0
Receive notification of the start of a new document.
AbstractDOMParser::fDocument
DOMDocumentImpl * fDocument
Definition: AbstractDOMParser.hpp:1776
AbstractDOMParser::fImplementationFeatures
XMLCh * fImplementationFeatures
Definition: AbstractDOMParser.hpp:1772
DOMText
The DOMText interface inherits from DOMCharacterData and represents the textual content (termed chara...
Definition: DOMText.hpp:51
AbstractDOMParser::getDoXInclude
bool getDoXInclude() const
Get the &#39;do XInclude&#39; flag.
Definition: AbstractDOMParser.hpp:1839
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
AbstractDOMParser::fCreateCommentNodes
bool fCreateCommentNodes
Definition: AbstractDOMParser.hpp:1767
XMLElementDecl
This class defines the core information of an element declaration.
Definition: XMLElementDecl.hpp:51
AbstractDOMParser::fDocumentAdoptedByUser
bool fDocumentAdoptedByUser
Definition: AbstractDOMParser.hpp:1768
XMLCh
uint16_t XMLCh
Definition: Xerces_autoconf_config.hpp:118
PSVIAttributeList
Definition: PSVIAttributeList.hpp:59
AbstractDOMParser::fPSVIHandler
PSVIHandler * fPSVIHandler
Definition: AbstractDOMParser.hpp:1786
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.
AbstractDOMParser::getParseInProgress
bool getParseInProgress() const
Get the parse in progress flag.
Definition: AbstractDOMParser.hpp:1804
AbstractDOMParser::getGrammarResolver
GrammarResolver * getGrammarResolver() const
Get the Grammar resolver.
Definition: AbstractDOMParser.hpp:1814
AbstractDOMParser::getCreateCommentNodes
bool getCreateCommentNodes() const
Get the &#39;create comment node&#39; flag.
Definition: AbstractDOMParser.hpp:1819
XMLValidator
This abstract class provides the interface for all validators.
Definition: XMLValidator.hpp:52
AbstractDOMParser::setDoXInclude
void setDoXInclude(const bool newState)
Set the &#39;do XInclude&#39; flag.
Definition: AbstractDOMParser.hpp:1867
PSVIHandler::handleAttributesPSVI
virtual void handleAttributesPSVI(const XMLCh *const localName, const XMLCh *const uri, PSVIAttributeList *psviAttributes)=0
Enables PSVI information about attributes to be passed back to the application.
AbstractDOMParser::fCreateEntityReferenceNodes
bool fCreateEntityReferenceNodes
Definition: AbstractDOMParser.hpp:1763
AbstractDOMParser::fMemoryManager
MemoryManager * fMemoryManager
Definition: AbstractDOMParser.hpp:1782
AbstractDOMParser::fWithinElement
bool fWithinElement
Definition: AbstractDOMParser.hpp:1765
AbstractDOMParser::fScanner
XMLScanner * fScanner
Definition: AbstractDOMParser.hpp:1771
AbstractDOMParser::fBufMgr
XMLBufferMgr fBufMgr
Definition: AbstractDOMParser.hpp:1784
XMLSize_t
size_t XMLSize_t
Definition: Xerces_autoconf_config.hpp:110
AbstractDOMParser::getPSVIHandler
PSVIHandler * getPSVIHandler()
This method returns the installed PSVI handler.
Definition: AbstractDOMParser.hpp:1824
AbstractDOMParser::getCreateSchemaInfo
bool getCreateSchemaInfo() const
Get the &#39;associate schema info&#39; flag.
Definition: AbstractDOMParser.hpp:1834
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
XMLDocumentHandler::endDocument
virtual void endDocument()=0
Receive notification after the scanner has parsed the end of the document.
DOMNode
The DOMNode interface is the primary datatype for the entire Document Object Model.
Definition: DOMNode.hpp:139
DOMCDATASection
CDATA sections are used to escape blocks of text containing characters that would otherwise be regard...
Definition: DOMCDATASection.hpp:65
AbstractDOMParser::ValSchemes
ValSchemes
ValScheme enum used in setValidationScheme Val_Never: Do not report validation errors.
Definition: AbstractDOMParser.hpp:77
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.
DOMDocument.hpp
AbstractDOMParser::fURIStringPool
XMLStringPool * fURIStringPool
Definition: AbstractDOMParser.hpp:1780
AbstractDOMParser::fIncludeIgnorableWhitespace
bool fIncludeIgnorableWhitespace
Definition: AbstractDOMParser.hpp:1764
AbstractDOMParser::fInternalSubset
XMLBuffer & fInternalSubset
Definition: AbstractDOMParser.hpp:1785
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.
AbstractDOMParser::fCurrentParent
DOMNode * fCurrentParent
Definition: AbstractDOMParser.hpp:1773
AbstractDOMParser::fParseInProgress
bool fParseInProgress
Definition: AbstractDOMParser.hpp:1766
InputSource
A single input source for an XML entity.
Definition: InputSource.hpp:62
AbstractDOMParser::fDocumentVector
RefVectorOf< DOMDocumentImpl > * fDocumentVector
Definition: AbstractDOMParser.hpp:1778