Xerces-C++: AbstractDOMParser.hpp Source File

- Main Page
- Related Pages
- Classes
- Files

# AbstractDOMParser.hpp

Go to the documentation of this file.

    00001 /*
    00002  * Licensed to the Apache Software Foundation (ASF) under one or more
    00003  * contributor license agreements.  See the NOTICE file distributed with
    00004  * this work for additional information regarding copyright ownership.
    00005  * The ASF licenses this file to You under the Apache License, Version 2.0
    00006  * (the "License"); you may not use this file except in compliance with
    00007  * the License.  You may obtain a copy of the License at
    00008  *
    00009  *      http://www.apache.org/licenses/LICENSE-2.0
    00010  *
    00011  * Unless required by applicable law or agreed to in writing, software
    00012  * distributed under the License is distributed on an "AS IS" BASIS,
    00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    00014  * See the License for the specific language governing permissions and
    00015  * limitations under the License.
    00016  */
    00017
    00018 /*
    00019  * $Id: AbstractDOMParser.hpp 932887 2010-04-11 13:04:59Z borisk $
    00020  */
    00021
    00022 #if !defined(XERCESC_INCLUDE_GUARD_ABSTRACTDOMPARSER_HPP)
    00023 #define XERCESC_INCLUDE_GUARD_ABSTRACTDOMPARSER_HPP
    00024
    00025 #include <xercesc/dom/DOMDocument.hpp>
    00026 #include <xercesc/framework/XMLDocumentHandler.hpp>
    00027 #include <xercesc/framework/XMLErrorReporter.hpp>
    00028 #include <xercesc/framework/XMLEntityHandler.hpp>
    00029 #include <xercesc/util/SecurityManager.hpp>
    00030 #include <xercesc/util/ValueStackOf.hpp>
    00031 #include <xercesc/validators/DTD/DocTypeHandler.hpp>
    00032 #include <xercesc/dom/DOMDocumentType.hpp>
    00033 #include <xercesc/validators/DTD/DTDElementDecl.hpp>
    00034 #include <xercesc/framework/XMLBufferMgr.hpp>
    00035 #include <xercesc/framework/psvi/PSVIHandler.hpp>
    00036
    00037 XERCES_CPP_NAMESPACE_BEGIN
    00038
    00039 class XMLPScanToken;
    00040 class XMLScanner;
    00041 class XMLValidator;
    00042 class DOMDocumentImpl;
    00043 class DOMDocumentTypeImpl;
    00044 class DOMEntityImpl;
    00045 class DOMElement;
    00046 class GrammarResolver;
    00047 class XMLGrammarPool;
    00048 class PSVIHandler;
    00049
    00054 class PARSERS_EXPORT AbstractDOMParser :
    00055
    00056     public XMemory
    00057     , public XMLDocumentHandler
    00058     , public XMLErrorReporter
    00059     , public XMLEntityHandler
    00060     , public DocTypeHandler
    00061     , public PSVIHandler
    00062 {
    00063 public :
    00064     // -----------------------------------------------------------------------
    00065     //  Class types
    00066     // -----------------------------------------------------------------------
    00069
    00077     enum ValSchemes
    00078     {
    00079         Val_Never
    00080         , Val_Always
    00081         , Val_Auto
    00082     };
    00083
    00085
    00086
    00087     // -----------------------------------------------------------------------
    00088     //  Constructors and Destructor
    00089     // -----------------------------------------------------------------------
    00092
    00096     virtual ~AbstractDOMParser();
    00097
    00099
    00100     // -----------------------------------------------------------------------
    00101     //  Utility methods
    00102     // -----------------------------------------------------------------------
    00103
    00111     void reset();
    00112
    00126     DOMDocument* adoptDocument();
    00127
    00129
    00130
    00131     // -----------------------------------------------------------------------
    00132     //  Getter methods
    00133     // -----------------------------------------------------------------------
    00134
    00137
    00149     DOMDocument* getDocument();
    00150
    00158     const XMLValidator& getValidator() const;
    00159
    00167     ValSchemes getValidationScheme() const;
    00168
    00179     bool getDoSchema() const;
    00180
    00191     bool getValidationSchemaFullChecking() const;
    00192
    00203     bool getIdentityConstraintChecking() const;
    00204
    00216     XMLSize_t getErrorCount() const;
    00217
    00228     bool getDoNamespaces() const;
    00229
    00242     bool getExitOnFirstFatalError() const;
    00243
    00254     bool getValidationConstraintFatal() const;
    00255
    00265     bool  getCreateEntityReferenceNodes()const;
    00266
    00277     bool getIncludeIgnorableWhitespace() const;
    00278
    00298     XMLCh* getExternalSchemaLocation() const;
    00299
    00319     XMLCh* getExternalNoNamespaceSchemaLocation() const;
    00320
    00336     SecurityManager* getSecurityManager() const;
    00337
    00351     const XMLSize_t& getLowWaterMark() const;
    00352
    00364     bool getLoadExternalDTD() const;
    00365
    00377     bool getLoadSchema() const;
    00378
    00387     bool  getCreateCommentNodes()const;
    00388
    00400     bool getCalculateSrcOfs() const;
    00401
    00412     bool getStandardUriConformant() const;
    00413
    00420     PSVIHandler* getPSVIHandler();
    00421
    00428     const PSVIHandler* getPSVIHandler() const;
    00429
    00439     bool getCreateSchemaInfo() const;
    00440
    00450     bool getDoXInclude() const;
    00451
    00463     bool getGenerateSyntheticAnnotations() const;
    00464
    00472     bool getValidateAnnotations() const;
    00473
    00481     bool getIgnoreAnnotations() const;
    00482
    00490     bool getDisableDefaultEntityResolution() const;
    00491
    00499     bool getSkipDTDValidation() const;
    00500
    00508     bool getHandleMultipleImports() const;
    00510
    00511
    00512     // -----------------------------------------------------------------------
    00513     //  Setter methods
    00514     // -----------------------------------------------------------------------
    00515
    00529     void setGenerateSyntheticAnnotations(const bool newValue);
    00530
    00538     void setValidateAnnotations(const bool newValue);
    00539
    00554     void setDoNamespaces(const bool newState);
    00555
    00572     void setExitOnFirstFatalError(const bool newState);
    00573
    00593     void setValidationConstraintFatal(const bool newState);
    00594
    00613     void setCreateEntityReferenceNodes(const bool create);
    00614
    00636     void setIncludeIgnorableWhitespace(const bool include);
    00637
    00654     void setValidationScheme(const ValSchemes newScheme);
    00655
    00671     void setDoSchema(const bool newState);
    00672
    00689     void setValidationSchemaFullChecking(const bool schemaFullChecking);
    00690
    00704     void setIdentityConstraintChecking(const bool newState);
    00705
    00726     void setExternalSchemaLocation(const XMLCh* const schemaLocation);
    00727
    00736     void setExternalSchemaLocation(const char* const schemaLocation);
    00737
    00752     void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
    00753
    00762     void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
    00763
    00779     void setSecurityManager(SecurityManager* const securityManager);
    00780
    00794     void setLowWaterMark(XMLSize_t lwm);
    00795
    00812     void setLoadExternalDTD(const bool newState);
    00813
    00829     void setLoadSchema(const bool newState);
    00830
    00841     void setCreateCommentNodes(const bool create);
    00842
    00855     void setCalculateSrcOfs(const bool newState);
    00856
    00867     void setStandardUriConformant(const bool newState);
    00868
    00876     void useScanner(const XMLCh* const scannerName);
    00877
    00885     void useImplementation(const XMLCh* const implementationFeatures);
    00886
    00895     virtual void setPSVIHandler(PSVIHandler* const handler);
    00896
    00906     void  setCreateSchemaInfo(const bool newState);
    00907
    00917     void  setDoXInclude(const bool newState);
    00918
    00928     void setIgnoreAnnotations(const bool newValue);
    00929
    00944     void setDisableDefaultEntityResolution(const bool newValue);
    00945
    00958     void setSkipDTDValidation(const bool newValue);
    00959
    00971     void setHandleMultipleImports(const bool newValue);
    00973
    00974
    00975     // -----------------------------------------------------------------------
    00976     //  Parsing methods
    00977     // -----------------------------------------------------------------------
    00978
    00981
    00997     void parse(const InputSource& source);
    00998
    01015     void parse(const XMLCh* const systemId);
    01016
    01032     void parse(const char* const systemId);
    01033
    01060     bool parseFirst
    01061     (
    01062         const   XMLCh* const    systemId
    01063         ,       XMLPScanToken&  toFill
    01064     );
    01065
    01093     bool parseFirst
    01094     (
    01095         const   char* const     systemId
    01096         ,       XMLPScanToken&  toFill
    01097     );
    01098
    01126     bool parseFirst
    01127     (
    01128         const   InputSource&    source
    01129         ,       XMLPScanToken&  toFill
    01130     );
    01131
    01154     bool parseNext(XMLPScanToken& token);
    01155
    01181     void parseReset(XMLPScanToken& token);
    01182
    01184
    01185     // -----------------------------------------------------------------------
    01186     //  Implementation of the PSVIHandler interface.
    01187     // -----------------------------------------------------------------------
    01188
    01191
    01202     virtual void handleElementPSVI
    01203     (
    01204         const   XMLCh* const            localName
    01205         , const XMLCh* const            uri
    01206         ,       PSVIElement *           elementInfo
    01207     );
    01208
    01209     virtual void handlePartialElementPSVI
    01210     (
    01211         const   XMLCh* const            localName
    01212         , const XMLCh* const            uri
    01213         ,       PSVIElement *           elementInfo
    01214     );
    01226     virtual void handleAttributesPSVI
    01227     (
    01228         const   XMLCh* const            localName
    01229         , const XMLCh* const            uri
    01230         ,       PSVIAttributeList *     psviAttributes
    01231     );
    01233
    01234     // -----------------------------------------------------------------------
    01235     //  Implementation of the XMLDocumentHandler interface.
    01236     // -----------------------------------------------------------------------
    01237
    01240
    01253     virtual void docCharacters
    01254     (
    01255         const   XMLCh* const    chars
    01256         , const XMLSize_t       length
    01257         , const bool            cdataSection
    01258     );
    01259
    01268     virtual void docComment
    01269     (
    01270         const   XMLCh* const    comment
    01271     );
    01272
    01285     virtual void docPI
    01286     (
    01287         const   XMLCh* const    target
    01288         , const XMLCh* const    data
    01289     );
    01290
    01295     virtual void endDocument();
    01296
    01313     virtual void endElement
    01314     (
    01315         const   XMLElementDecl& elemDecl
    01316         , const unsigned int    urlId
    01317         , const bool            isRoot
    01318         , const XMLCh* const    elemPrefix
    01319     );
    01320
    01329     virtual void endEntityReference
    01330     (
    01331         const   XMLEntityDecl&  entDecl
    01332     );
    01333
    01352     virtual void ignorableWhitespace
    01353     (
    01354         const   XMLCh* const    chars
    01355         , const XMLSize_t       length
    01356         , const bool            cdataSection
    01357     );
    01358
    01365     virtual void resetDocument();
    01366
    01371     virtual void startDocument();
    01372
    01400     virtual void startElement
    01401     (
    01402         const   XMLElementDecl&         elemDecl
    01403         , const unsigned int            urlId
    01404         , const XMLCh* const            elemPrefix
    01405         , const RefVectorOf<XMLAttr>&   attrList
    01406         , const XMLSize_t               attrCount
    01407         , const bool                    isEmpty
    01408         , const bool                    isRoot
    01409     );
    01410
    01420     virtual void startEntityReference
    01421     (
    01422         const   XMLEntityDecl&  entDecl
    01423     );
    01424
    01443     virtual void XMLDecl
    01444     (
    01445         const   XMLCh* const    versionStr
    01446         , const XMLCh* const    encodingStr
    01447         , const XMLCh* const    standaloneStr
    01448         , const XMLCh* const    actualEncStr
    01449     );
    01450
    01452
    01453
    01454     // -----------------------------------------------------------------------
    01455     //  Implementation of the deprecated DocTypeHandler interface.
    01456     // -----------------------------------------------------------------------
    01459     virtual void attDef
    01460     (
    01461         const   DTDElementDecl&     elemDecl
    01462         , const DTDAttDef&          attDef
    01463         , const bool                ignoring
    01464     );
    01465
    01466     virtual void doctypeComment
    01467     (
    01468         const   XMLCh* const    comment
    01469     );
    01470
    01471     virtual void doctypeDecl
    01472     (
    01473         const   DTDElementDecl& elemDecl
    01474         , const XMLCh* const    publicId
    01475         , const XMLCh* const    systemId
    01476         , const bool            hasIntSubset
    01477         , const bool            hasExtSubset = false
    01478     );
    01479
    01480     virtual void doctypePI
    01481     (
    01482         const   XMLCh* const    target
    01483         , const XMLCh* const    data
    01484     );
    01485
    01486     virtual void doctypeWhitespace
    01487     (
    01488         const   XMLCh* const    chars
    01489         , const XMLSize_t       length
    01490     );
    01491
    01492     virtual void elementDecl
    01493     (
    01494         const   DTDElementDecl& decl
    01495         , const bool            isIgnored
    01496     );
    01497
    01498     virtual void endAttList
    01499     (
    01500         const   DTDElementDecl& elemDecl
    01501     );
    01502
    01503     virtual void endIntSubset();
    01504
    01505     virtual void endExtSubset();
    01506
    01507     virtual void entityDecl
    01508     (
    01509         const   DTDEntityDecl&  entityDecl
    01510         , const bool            isPEDecl
    01511         , const bool            isIgnored
    01512     );
    01513
    01514     virtual void resetDocType();
    01515
    01516     virtual void notationDecl
    01517     (
    01518         const   XMLNotationDecl&    notDecl
    01519         , const bool                isIgnored
    01520     );
    01521
    01522     virtual void startAttList
    01523     (
    01524         const   DTDElementDecl& elemDecl
    01525     );
    01526
    01527     virtual void startIntSubset();
    01528
    01529     virtual void startExtSubset();
    01530
    01531     virtual void TextDecl
    01532     (
    01533         const   XMLCh* const    versionStr
    01534         , const XMLCh* const    encodingStr
    01535     );
    01536
    01538
    01539 protected:
    01540     // DOM node creation hooks. Override them if you are using your own
    01541     // DOM node types.
    01542     //
    01543     virtual DOMCDATASection* createCDATASection (const XMLCh*, XMLSize_t);
    01544     virtual DOMText* createText (const XMLCh*, XMLSize_t);
    01545
    01546     virtual DOMElement* createElement (const XMLCh* name);
    01547     virtual DOMElement* createElementNS (const XMLCh* namespaceURI,
    01548                                          const XMLCh* elemPrefix,
    01549                                          const XMLCh* localName,
    01550                                          const XMLCh* qName);
    01551
    01552     virtual DOMAttr* createAttr (const XMLCh* name);
    01553     virtual DOMAttr* createAttrNS (const XMLCh* namespaceURI,
    01554                                    const XMLCh* elemPrefix,
    01555                                    const XMLCh* localName,
    01556                                    const XMLCh* qName);
    01557
    01558
    01559
    01560
    01561 protected :
    01562     // -----------------------------------------------------------------------
    01563     //  Protected Constructor Methods
    01564     // -----------------------------------------------------------------------
    01583     AbstractDOMParser
    01584     (
    01585           XMLValidator* const   valToAdopt = 0
    01586         , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
    01587         , XMLGrammarPool* const gramPool = 0
    01588     );
    01589
    01591
    01592     // -----------------------------------------------------------------------
    01593     //  Protected getter methods
    01594     // -----------------------------------------------------------------------
    01602     DOMNode* getCurrentNode();
    01603
    01608     XMLScanner* getScanner() const;
    01609
    01614     GrammarResolver* getGrammarResolver() const;
    01615
    01621     bool getParseInProgress() const;
    01622
    01623     MemoryManager* getMemoryManager() const;
    01624
    01626
    01627
    01628     // -----------------------------------------------------------------------
    01629     //  Protected setter methods
    01630     // -----------------------------------------------------------------------
    01631
    01634
    01642     void setCurrentNode(DOMNode* toSet);
    01643
    01650     void setDocument(DOMDocument* toSet);
    01651
    01658     void setParseInProgress(const bool toSet);
    01660
    01661     // -----------------------------------------------------------------------
    01662     //  Protected Helper methods
    01663     // -----------------------------------------------------------------------
    01666     void resetPool();
    01667
    01671     bool isDocumentAdopted() const;
    01672
    01674
    01675
    01676 private :
    01677     // -----------------------------------------------------------------------
    01678     //  Initialize/Cleanup methods
    01679     // -----------------------------------------------------------------------
    01680     void initialize();
    01681     void cleanUp();
    01682     void resetInProgress();
    01683
    01684     // -----------------------------------------------------------------------
    01685     //  Unimplemented constructors and operators
    01686     // -----------------------------------------------------------------------
    01687     AbstractDOMParser(const AbstractDOMParser&);
    01688     AbstractDOMParser& operator=(const AbstractDOMParser&);
    01689
    01690 protected:
    01691     // -----------------------------------------------------------------------
    01692     //  Protected data members
    01693     //
    01694     //  fCurrentNode
    01695     //  fCurrentParent
    01696     //      Used to track the current node during nested element events. Since
    01697     //      the tree must be built from a set of disjoint callbacks, we need
    01698     //      these to keep up with where we currently are.
    01699     //
    01700     //  fCurrentEntity
    01701     //      Used to track the current entity decl.  If a text decl is seen later on,
    01702     //      it is used to update the encoding and version information.
    01703     //
    01704     //  fDocument
    01705     //      The root document object, filled with the document contents.
    01706     //
    01707     //  fCreateEntityReferenceNodes
    01708     //      Indicates whether entity reference nodes should be created.
    01709     //
    01710     //  fIncludeIgnorableWhitespace
    01711     //      Indicates whether ignorable whitespace should be added to
    01712     //      the DOM tree for validating parsers.
    01713     //
    01714     //  fScanner
    01715     //      The scanner used for this parser. This is created during the
    01716     //      constructor.
    01717     //
    01718     //  fImplementationFeatures
    01719     //      The implementation features that we use to get an implementation
    01720     //      for use in creating the DOMDocument used during parse. If this is
    01721     //      null then the default DOMImplementation is used
    01722     //
    01723     //  fParseInProgress
    01724     //      Used to prevent multiple entrance to the parser while its doing
    01725     //      a parse.
    01726     //
    01727     //  fWithinElement
    01728     //      A flag to indicate that the parser is within at least one level
    01729     //      of element processing.
    01730     //
    01731     //  fDocumentType
    01732     //      Used to store and update the documentType variable information
    01733     //      in fDocument
    01734     //
    01735     //  fDocumentVector
    01736     //      Store all the previous fDocument(s) (thus not the current fDocument)
    01737     //      created in this parser.  It is destroyed when the parser is destructed.
    01738     //
    01739     //  fCreateCommentNodes
    01740     //      Indicates whether comment nodes should be created.
    01741     //
    01742     //  fDocumentAdoptedByUser
    01743     //      The DOMDocument ownership has been transferred to application
    01744     //      If set to true, the parser does not own the document anymore
    01745     //      and thus will not release its memory.
    01746     //
    01747     //  fInternalSubset
    01748     //      Buffer for storing the internal subset information.
    01749     //      Once complete (after DOCTYPE is finished scanning), send
    01750     //      it to DocumentType Node
    01751     //
    01752     //   fGrammarPool
    01753     //      The grammar pool passed from external application (through derivatives).
    01754     //      which could be 0, not owned.
    01755     //
    01756     //  fCreateSchemaInfo
    01757     //      Indicates whether element and attributes will have schema info associated
    01758     //
    01759     //   fDoXinclude
    01760     //      A bool used to request that XInlcude processing occur on the
    01761     //      Document the parser parses.
    01762     // -----------------------------------------------------------------------
    01763     bool                          fCreateEntityReferenceNodes;
    01764     bool                          fIncludeIgnorableWhitespace;
    01765     bool                          fWithinElement;
    01766     bool                          fParseInProgress;
    01767     bool                          fCreateCommentNodes;
    01768     bool                          fDocumentAdoptedByUser;
    01769     bool                          fCreateSchemaInfo;
    01770     bool                          fDoXInclude;
    01771     XMLScanner*                   fScanner;
    01772     XMLCh*                        fImplementationFeatures;
    01773     DOMNode*                      fCurrentParent;
    01774     DOMNode*                      fCurrentNode;
    01775     DOMEntityImpl*                fCurrentEntity;
    01776     DOMDocumentImpl*              fDocument;
    01777     DOMDocumentTypeImpl*          fDocumentType;
    01778     RefVectorOf<DOMDocumentImpl>* fDocumentVector;
    01779     GrammarResolver*              fGrammarResolver;
    01780     XMLStringPool*                fURIStringPool;
    01781     XMLValidator*                 fValidator;
    01782     MemoryManager*                fMemoryManager;
    01783     XMLGrammarPool*               fGrammarPool;
    01784     XMLBufferMgr                  fBufMgr;
    01785     XMLBuffer&                    fInternalSubset;
    01786     PSVIHandler*                  fPSVIHandler;
    01787 };
    01788
    01789
    01790
    01791 // ---------------------------------------------------------------------------
    01792 //  AbstractDOMParser: Getter methods
    01793 // ---------------------------------------------------------------------------
    01794 inline bool AbstractDOMParser::getCreateEntityReferenceNodes() const
    01795 {
    01796     return fCreateEntityReferenceNodes;
    01797 }
    01798
    01799 inline bool AbstractDOMParser::getIncludeIgnorableWhitespace() const
    01800 {
    01801     return fIncludeIgnorableWhitespace;
    01802 }
    01803
    01804 inline bool AbstractDOMParser::getParseInProgress() const
    01805 {
    01806     return fParseInProgress;
    01807 }
    01808
    01809 inline XMLScanner* AbstractDOMParser::getScanner() const
    01810 {
    01811     return fScanner;
    01812 }
    01813
    01814 inline GrammarResolver* AbstractDOMParser::getGrammarResolver() const
    01815 {
    01816     return fGrammarResolver;
    01817 }
    01818
    01819 inline bool AbstractDOMParser::getCreateCommentNodes() const
    01820 {
    01821     return fCreateCommentNodes;
    01822 }
    01823
    01824 inline PSVIHandler* AbstractDOMParser::getPSVIHandler()
    01825 {
    01826     return fPSVIHandler;
    01827 }
    01828
    01829 inline const PSVIHandler* AbstractDOMParser::getPSVIHandler() const
    01830 {
    01831     return fPSVIHandler;
    01832 }
    01833
    01834 inline bool AbstractDOMParser::getCreateSchemaInfo() const
    01835 {
    01836     return fCreateSchemaInfo;
    01837 }
    01838
    01839 inline bool AbstractDOMParser::getDoXInclude() const
    01840 {
    01841     return fDoXInclude;
    01842 }
    01843 // ---------------------------------------------------------------------------
    01844 //  AbstractDOMParser: Setter methods
    01845 // ---------------------------------------------------------------------------
    01846 inline void AbstractDOMParser::setCreateEntityReferenceNodes(const bool create)
    01847 {
    01848     fCreateEntityReferenceNodes = create;
    01849 }
    01850
    01851 inline void AbstractDOMParser::setIncludeIgnorableWhitespace(const bool include)
    01852 {
    01853     fIncludeIgnorableWhitespace = include;
    01854 }
    01855
    01856 inline void AbstractDOMParser::setCreateCommentNodes(const bool create)
    01857 {
    01858     fCreateCommentNodes = create;
    01859 }
    01860
    01861 inline void AbstractDOMParser::useImplementation(const XMLCh* const implementationFeatures)
    01862 {
    01863     fMemoryManager->deallocate(fImplementationFeatures);
    01864     fImplementationFeatures = XMLString::replicate(implementationFeatures, fMemoryManager);
    01865 }
    01866
    01867 inline void AbstractDOMParser::setDoXInclude(const bool newState)
    01868 {
    01869     fDoXInclude = newState;
    01870 }
    01871
    01872 // ---------------------------------------------------------------------------
    01873 //  AbstractDOMParser: Protected getter methods
    01874 // ---------------------------------------------------------------------------
    01875 inline DOMNode* AbstractDOMParser::getCurrentNode()
    01876 {
    01877     return fCurrentNode;
    01878 }
    01879
    01880 inline MemoryManager* AbstractDOMParser::getMemoryManager() const
    01881 {
    01882     return fMemoryManager;
    01883 }
    01884
    01885 // ---------------------------------------------------------------------------
    01886 //  AbstractDOMParser: Protected setter methods
    01887 // ---------------------------------------------------------------------------
    01888 inline void AbstractDOMParser::setCurrentNode(DOMNode* toSet)
    01889 {
    01890     fCurrentNode = toSet;
    01891 }
    01892
    01893 inline void AbstractDOMParser::setParseInProgress(const bool toSet)
    01894 {
    01895     fParseInProgress = toSet;
    01896 }
    01897
    01898 XERCES_CPP_NAMESPACE_END
    01899
    01900 #endif