http://xml.apache.org/http://www.apache.org/http://www.w3.org/

Home

Readme
Release Info

Installation
Download
Build

FAQs
Samples
API Docs

DOM C++ Binding
Programming
Migration Guide

Feedback
Bug-Reporting
PDF Document

CVS Repository
Mail Archive

API Docs for SAX and DOM
 

Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

SAXParser.hpp

Go to the documentation of this file.
00001 /*
00002  * The Apache Software License, Version 1.1
00003  *
00004  * Copyright (c) 1999-2001 The Apache Software Foundation.  All rights
00005  * reserved.
00006  *
00007  * Redistribution and use in source and binary forms, with or without
00008  * modification, are permitted provided that the following conditions
00009  * are met:
00010  *
00011  * 1. Redistributions of source code must retain the above copyright
00012  *    notice, this list of conditions and the following disclaimer.
00013  *
00014  * 2. Redistributions in binary form must reproduce the above copyright
00015  *    notice, this list of conditions and the following disclaimer in
00016  *    the documentation and/or other materials provided with the
00017  *    distribution.
00018  *
00019  * 3. The end-user documentation included with the redistribution,
00020  *    if any, must include the following acknowledgment:
00021  *       "This product includes software developed by the
00022  *        Apache Software Foundation (http://www.apache.org/)."
00023  *    Alternately, this acknowledgment may appear in the software itself,
00024  *    if and wherever such third-party acknowledgments normally appear.
00025  *
00026  * 4. The names "Xerces" and "Apache Software Foundation" must
00027  *    not be used to endorse or promote products derived from this
00028  *    software without prior written permission. For written
00029  *    permission, please contact apache\@apache.org.
00030  *
00031  * 5. Products derived from this software may not be called "Apache",
00032  *    nor may "Apache" appear in their name, without prior written
00033  *    permission of the Apache Software Foundation.
00034  *
00035  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
00036  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
00037  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00038  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
00039  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00040  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00041  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
00042  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
00043  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00044  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
00045  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
00046  * SUCH DAMAGE.
00047  * ====================================================================
00048  *
00049  * This software consists of voluntary contributions made by many
00050  * individuals on behalf of the Apache Software Foundation, and was
00051  * originally based on software copyright (c) 1999, International
00052  * Business Machines, Inc., http://www.ibm.com .  For more information
00053  * on the Apache Software Foundation, please see
00054  * <http://www.apache.org/>.
00055  */
00056 
00057 /*
00058  * $Log: SAXParser.hpp,v $
00059  * Revision 1.12  2002/07/11 18:27:03  knoaman
00060  * Grammar caching/preparsing - initial implementation.
00061  *
00062  * Revision 1.11  2002/06/27 18:48:04  tng
00063  * API Documentation Update and move getScanner as protected
00064  *
00065  * Revision 1.10  2002/06/17 15:41:44  tng
00066  * Update API Documentation
00067  *
00068  * Revision 1.9  2002/06/06 20:38:18  tng
00069  * Document Fix: document that the returned object from resolveEntity is owned by the parser
00070  *
00071  * Revision 1.8  2002/05/31 15:13:53  tng
00072  * Fix doxygen documentation.
00073  *
00074  * Revision 1.7  2002/05/30 16:39:06  knoaman
00075  * DOM L3 LS.
00076  *
00077  * Revision 1.6  2002/05/30 16:20:09  tng
00078  * Add feature to optionally ignore external DTD.
00079  *
00080  * Revision 1.5  2002/05/29 21:37:47  knoaman
00081  * Add baseURI to resolveEntity to support DOMInputSource.
00082  *
00083  * Revision 1.4  2002/05/28 20:44:14  tng
00084  * [Bug 9104] prefixes dissapearing when schema validation turned on.
00085  *
00086  * Revision 1.3  2002/05/27 18:39:21  tng
00087  * To get ready for 64 bit large file, use XMLSSize_t to represent line and column number.
00088  *
00089  * Revision 1.2  2002/02/20 18:17:01  tng
00090  * [Bug 5977] Warnings on generating apiDocs.
00091  *
00092  * Revision 1.1.1.1  2002/02/01 22:22:07  peiyongz
00093  * sane_include
00094  *
00095  * Revision 1.22  2001/12/05 22:09:02  tng
00096  * Update documentation for setExternalSchemaLocation and setExternalNoNamespaceSchemaLocation.
00097  *
00098  * Revision 1.21  2001/11/20 18:51:44  tng
00099  * Schema: schemaLocation and noNamespaceSchemaLocation to be specified outside the instance document.  New methods setExternalSchemaLocation and setExternalNoNamespaceSchemaLocation are added (for SAX2, two new properties are added).
00100  *
00101  * Revision 1.20  2001/08/01 19:11:02  tng
00102  * Add full schema constraint checking flag to the samples and the parser.
00103  *
00104  * Revision 1.19  2001/07/27 20:24:21  tng
00105  * put getScanner() back as they were there before, not to break existing apps.
00106  *
00107  * Revision 1.18  2001/07/16 12:52:09  tng
00108  * APIDocs fix: default for schema processing in DOMParser, IDOMParser, and SAXParser should be false.
00109  *
00110  * Revision 1.17  2001/06/23 14:13:16  tng
00111  * Remove getScanner from the Parser headers as this is not needed and Scanner is not internal class.
00112  *
00113  * Revision 1.16  2001/06/03 19:26:20  jberry
00114  * Add support for querying error count following parse; enables simple parse without requiring error handler.
00115  *
00116  * Revision 1.15  2001/05/11 13:26:22  tng
00117  * Copyright update.
00118  *
00119  * Revision 1.14  2001/05/03 19:09:25  knoaman
00120  * Support Warning/Error/FatalError messaging.
00121  * Validity constraints errors are treated as errors, with the ability by user to set
00122  * validity constraints as fatal errors.
00123  *
00124  * Revision 1.13  2001/03/30 16:46:57  tng
00125  * Schema: Use setDoSchema instead of setSchemaValidation which makes more sense.
00126  *
00127  * Revision 1.12  2001/03/21 21:56:09  tng
00128  * Schema: Add Schema Grammar, Schema Validator, and split the DTDValidator into DTDValidator, DTDScanner, and DTDGrammar.
00129  *
00130  * Revision 1.11  2001/02/15 15:56:29  tng
00131  * Schema: Add setSchemaValidation and getSchemaValidation for DOMParser and SAXParser.
00132  * Add feature "http://apache.org/xml/features/validation/schema" for SAX2XMLReader.
00133  * New data field  fSchemaValidation in XMLScanner as the flag.
00134  *
00135  * Revision 1.10  2001/01/12 21:23:41  tng
00136  * Documentation Enhancement: explain values of Val_Scheme
00137  *
00138  * Revision 1.9  2000/08/02 18:05:15  jpolast
00139  * changes required for sax2
00140  * (changed private members to protected)
00141  *
00142  * Revision 1.8  2000/04/12 22:58:30  roddey
00143  * Added support for 'auto validate' mode.
00144  *
00145  * Revision 1.7  2000/03/03 01:29:34  roddey
00146  * Added a scanReset()/parseReset() method to the scanner and
00147  * parsers, to allow for reset after early exit from a progressive parse.
00148  * Added calls to new Terminate() call to all of the samples. Improved
00149  * documentation in SAX and DOM parsers.
00150  *
00151  * Revision 1.6  2000/02/17 03:54:27  rahulj
00152  * Added some new getters to query the parser state and
00153  * clarified the documentation.
00154  *
00155  * Revision 1.5  2000/02/16 03:42:58  rahulj
00156  * Finished documenting the SAX Driver implementation.
00157  *
00158  * Revision 1.4  2000/02/15 04:47:37  rahulj
00159  * Documenting the SAXParser framework. Not done yet.
00160  *
00161  * Revision 1.3  2000/02/06 07:47:56  rahulj
00162  * Year 2K copyright swat.
00163  *
00164  * Revision 1.2  1999/12/15 19:57:48  roddey
00165  * Got rid of redundant 'const' on boolean return value. Some compilers choke
00166  * on this and its useless.
00167  *
00168  * Revision 1.1.1.1  1999/11/09 01:07:51  twl
00169  * Initial checkin
00170  *
00171  * Revision 1.6  1999/11/08 20:44:54  rahul
00172  * Swat for adding in Product name and CVS comment log variable.
00173  *
00174  */
00175 
00176 #if !defined(SAXPARSER_HPP)
00177 #define SAXPARSER_HPP
00178 
00179 #include <xercesc/sax/Parser.hpp>
00180 #include <xercesc/internal/VecAttrListImpl.hpp>
00181 #include <xercesc/framework/XMLDocumentHandler.hpp>
00182 #include <xercesc/framework/XMLElementDecl.hpp>
00183 #include <xercesc/framework/XMLEntityHandler.hpp>
00184 #include <xercesc/framework/XMLErrorReporter.hpp>
00185 #include <xercesc/validators/DTD/DocTypeHandler.hpp>
00186 
00187 class DocumentHandler;
00188 class EntityResolver;
00189 class XMLPScanToken;
00190 class XMLScanner;
00191 class XMLValidator;
00192 class Grammar;
00193 
00194 
00204 
00205 class  SAXParser :
00206 
00207     public Parser
00208     , public XMLDocumentHandler
00209     , public XMLErrorReporter
00210     , public XMLEntityHandler
00211     , public DocTypeHandler
00212 {
00213 public :
00214     // -----------------------------------------------------------------------
00215     //  Class types
00216     // -----------------------------------------------------------------------
00224 
00225     enum ValSchemes
00226     {
00227         Val_Never
00228         , Val_Always
00229         , Val_Auto
00230     };
00231 
00232 
00233     // -----------------------------------------------------------------------
00234     //  Constructors and Destructor
00235     // -----------------------------------------------------------------------
00238     /** Constructor with an instance of validator class to use for
00239       * validation.
00240       * @param valToAdopt Pointer to the validator instance to use. The
00241       *                   parser is responsible for freeing the memory.
00242       */
00243     SAXParser(XMLValidator* const valToAdopt = 0);
00244 
00248     ~SAXParser();
00250 
00251 
00252     // -----------------------------------------------------------------------
00253     //  Getter Methods
00254     // -----------------------------------------------------------------------
00257 
00263     DocumentHandler* getDocumentHandler();
00264 
00271     const DocumentHandler* getDocumentHandler() const;
00272 
00279     EntityResolver* getEntityResolver();
00280 
00287     const EntityResolver* getEntityResolver() const;
00288 
00295     ErrorHandler* getErrorHandler();
00296 
00303     const ErrorHandler* getErrorHandler() const;
00304 
00311     const XMLValidator& getValidator() const;
00312 
00320     ValSchemes getValidationScheme() const;
00321 
00332     bool getDoSchema() const;
00333 
00344     bool getValidationSchemaFullChecking() const;
00345 
00356     int getErrorCount() const;
00357 
00367     bool getDoNamespaces() const;
00368 
00378     bool getExitOnFirstFatalError() const;
00379 
00390     bool getValidationConstraintFatal() const;
00391 
00411     XMLCh* getExternalSchemaLocation() const;
00412 
00432     XMLCh* getExternalNoNamespaceSchemaLocation() const;
00433 
00445     bool getLoadExternalDTD() const;
00446 
00457     bool isCachingGrammarFromParse() const;
00458 
00469     bool isUsingCachedGrammarInParse() const;
00470 
00477     Grammar* getGrammar(const XMLCh* const nameSpaceKey);
00478 
00484     Grammar* getRootGrammar();
00485     
00492     const XMLCh* getURIText(unsigned int uriId);
00493 
00495 
00496 
00497     // -----------------------------------------------------------------------
00498     //  Setter methods
00499     // -----------------------------------------------------------------------
00500 
00503 
00516     void setDoNamespaces(const bool newState);
00517 
00534     void setValidationScheme(const ValSchemes newScheme);
00535 
00551     void setDoSchema(const bool newState);
00552 
00569     void setValidationSchemaFullChecking(const bool schemaFullChecking);
00570 
00586     void setExitOnFirstFatalError(const bool newState);
00587 
00607     void setValidationConstraintFatal(const bool newState);
00608 
00628 
00629     void setExternalSchemaLocation(const XMLCh* const schemaLocation);
00630 
00639     void setExternalSchemaLocation(const char* const schemaLocation);
00640 
00655     void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
00656 
00665     void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
00666 
00683     void setLoadExternalDTD(const bool newState);
00684 
00702     void cacheGrammarFromParse(const bool newState);
00703 
00722     void useCachedGrammarInParse(const bool newState);
00723 
00724 
00726 
00727 
00728     // -----------------------------------------------------------------------
00729     //  Advanced document handler list maintenance methods
00730     // -----------------------------------------------------------------------
00731 
00734 
00747     void installAdvDocHandler(XMLDocumentHandler* const toInstall);
00748 
00758     bool removeAdvDocHandler(XMLDocumentHandler* const toRemove);
00760 
00761 
00762     // -----------------------------------------------------------------------
00763     //  Progressive scan methods
00764     // -----------------------------------------------------------------------
00765 
00768 
00796     bool parseFirst
00797     (
00798         const   XMLCh* const    systemId
00799         ,       XMLPScanToken&  toFill
00800     );
00801 
00829     bool parseFirst
00830     (
00831         const   char* const     systemId
00832         ,       XMLPScanToken&  toFill
00833     );
00834 
00862     bool parseFirst
00863     (
00864         const   InputSource&    source
00865         ,       XMLPScanToken&  toFill
00866     );
00867 
00892     bool parseNext(XMLPScanToken& token);
00893 
00915     void parseReset(XMLPScanToken& token);
00916 
00918 
00919     // -----------------------------------------------------------------------
00920     //  Grammar preparsing interface
00921     // -----------------------------------------------------------------------
00922 
00925 
00952     Grammar* loadGrammar(const InputSource& source,
00953                          const short grammarType,
00954                          const bool toCache = false);
00955 
00981     Grammar* loadGrammar(const XMLCh* const systemId,
00982                          const short grammarType,
00983                          const bool toCache = false);
00984 
01009     Grammar* loadGrammar(const char* const systemId,
01010                          const short grammarType,
01011                          const bool toCache = false);
01012 
01016     void resetCachedGrammarPool();
01017 
01019 
01020 
01021     // -----------------------------------------------------------------------
01022     //  Implementation of the SAX Parser interface
01023     // -----------------------------------------------------------------------
01024 
01027 
01036     virtual void parse(const InputSource& source);
01037 
01047     virtual void parse(const XMLCh* const systemId);
01048 
01056     virtual void parse(const char* const systemId);
01057 
01068     virtual void setDocumentHandler(DocumentHandler* const handler);
01069 
01079     virtual void setDTDHandler(DTDHandler* const handler);
01080 
01091     virtual void setErrorHandler(ErrorHandler* const handler);
01092 
01104     virtual void setEntityResolver(EntityResolver* const resolver);
01106 
01107 
01108     // -----------------------------------------------------------------------
01109     //  Implementation of the XMLDocumentHandler interface
01110     // -----------------------------------------------------------------------
01111 
01114 
01129     virtual void docCharacters
01130     (
01131         const   XMLCh* const    chars
01132         , const unsigned int    length
01133         , const bool            cdataSection
01134     );
01135 
01145     virtual void docComment
01146     (
01147         const   XMLCh* const    comment
01148     );
01149 
01169     virtual void docPI
01170     (
01171         const   XMLCh* const    target
01172         , const XMLCh* const    data
01173     );
01174 
01186     virtual void endDocument();
01187 
01207     virtual void endElement
01208     (
01209         const   XMLElementDecl& elemDecl
01210         , const unsigned int    urlId
01211         , const bool            isRoot
01212         , const XMLCh* const    elemPrefix
01213     );
01214 
01225     virtual void endEntityReference
01226     (
01227         const   XMLEntityDecl&  entDecl
01228     );
01229 
01249     virtual void ignorableWhitespace
01250     (
01251         const   XMLCh* const    chars
01252         , const unsigned int    length
01253         , const bool            cdataSection
01254     );
01255 
01260     virtual void resetDocument();
01261 
01272     virtual void startDocument();
01273 
01300     virtual void startElement
01301     (
01302         const   XMLElementDecl&         elemDecl
01303         , const unsigned int            urlId
01304         , const XMLCh* const            elemPrefix
01305         , const RefVectorOf<XMLAttr>&   attrList
01306         , const unsigned int            attrCount
01307         , const bool                    isEmpty
01308         , const bool                    isRoot
01309     );
01310 
01320     virtual void startEntityReference
01321     (
01322         const   XMLEntityDecl&  entDecl
01323     );
01324 
01342     virtual void XMLDecl
01343     (
01344         const   XMLCh* const    versionStr
01345         , const XMLCh* const    encodingStr
01346         , const XMLCh* const    standaloneStr
01347         , const XMLCh* const    actualEncodingStr
01348     );
01350 
01351 
01352     // -----------------------------------------------------------------------
01353     //  Implementation of the XMLErrorReporter interface
01354     // -----------------------------------------------------------------------
01355 
01358 
01381     virtual void error
01382     (
01383         const   unsigned int                errCode
01384         , const XMLCh* const                msgDomain
01385         , const XMLErrorReporter::ErrTypes  errType
01386         , const XMLCh* const                errorText
01387         , const XMLCh* const                systemId
01388         , const XMLCh* const                publicId
01389         , const XMLSSize_t                  lineNum
01390         , const XMLSSize_t                  colNum
01391     );
01392 
01401     virtual void resetErrors();
01403 
01404 
01405     // -----------------------------------------------------------------------
01406     //  Implementation of the XMLEntityHandler interface
01407     // -----------------------------------------------------------------------
01408 
01411 
01422     virtual void endInputSource(const InputSource& inputSource);
01423 
01438     virtual bool expandSystemId
01439     (
01440         const   XMLCh* const    systemId
01441         ,       XMLBuffer&      toFill
01442     );
01443 
01451     virtual void resetEntities();
01452 
01473     virtual InputSource* resolveEntity
01474     (
01475         const   XMLCh* const    publicId
01476         , const XMLCh* const    systemId
01477         , const XMLCh* const    baseURI = 0
01478     );
01479 
01491     virtual void startInputSource(const InputSource& inputSource);
01493 
01494 
01495     // -----------------------------------------------------------------------
01496     //  Implementation of the Deprecated DocTypeHandler Interface
01497     // -----------------------------------------------------------------------
01500 
01514     virtual void attDef
01515     (
01516         const   DTDElementDecl& elemDecl
01517         , const DTDAttDef&      attDef
01518         , const bool            ignore
01519     );
01520 
01530     virtual void doctypeComment
01531     (
01532         const   XMLCh* const    comment
01533     );
01534 
01551     virtual void doctypeDecl
01552     (
01553         const   DTDElementDecl& elemDecl
01554         , const XMLCh* const    publicId
01555         , const XMLCh* const    systemId
01556         , const bool            hasIntSubset
01557     );
01558 
01572     virtual void doctypePI
01573     (
01574         const   XMLCh* const    target
01575         , const XMLCh* const    data
01576     );
01577 
01589     virtual void doctypeWhitespace
01590     (
01591         const   XMLCh* const    chars
01592         , const unsigned int    length
01593     );
01594 
01607     virtual void elementDecl
01608     (
01609         const   DTDElementDecl& decl
01610         , const bool            isIgnored
01611     );
01612 
01623     virtual void endAttList
01624     (
01625         const   DTDElementDecl& elemDecl
01626     );
01627 
01634     virtual void endIntSubset();
01635 
01642     virtual void endExtSubset();
01643 
01658     virtual void entityDecl
01659     (
01660         const   DTDEntityDecl&  entityDecl
01661         , const bool            isPEDecl
01662         , const bool            isIgnored
01663     );
01664 
01669     virtual void resetDocType();
01670 
01683     virtual void notationDecl
01684     (
01685         const   XMLNotationDecl&    notDecl
01686         , const bool                isIgnored
01687     );
01688 
01699     virtual void startAttList
01700     (
01701         const   DTDElementDecl& elemDecl
01702     );
01703 
01710     virtual void startIntSubset();
01711 
01718     virtual void startExtSubset();
01719 
01732     virtual void TextDecl
01733     (
01734         const   XMLCh* const    versionStr
01735         , const XMLCh* const    encodingStr
01736     );
01738 
01739 
01740     // -----------------------------------------------------------------------
01741     //  Deprecated Methods
01742     // -----------------------------------------------------------------------
01745 
01755     bool getDoValidation() const;
01756 
01770     void setDoValidation(const bool newState);
01772 
01773 
01774 protected :
01775     // -----------------------------------------------------------------------
01776     //  Protected Methods
01777     // -----------------------------------------------------------------------
01784     const XMLScanner& getScanner() const;
01785 
01786 
01787 private:
01788     // -----------------------------------------------------------------------
01789     //  Unimplemented constructors and operators
01790     // -----------------------------------------------------------------------
01791     SAXParser(const SAXParser&);
01792     void operator=(const SAXParser&);
01793 
01794 
01795     // -----------------------------------------------------------------------
01796     //  Private data members
01797     //
01798     //  fAttrList
01799     //      A temporary implementation of the basic SAX attribute list
01800     //      interface. We use this one over and over on each startElement
01801     //      event to allow SAX-like access to the element attributes.
01802     //
01803     //  fDocHandler
01804     //      The installed SAX doc handler, if any. Null if none.
01805     //
01806     //  fDTDHandler
01807     //      The installed SAX DTD handler, if any. Null if none.
01808     //
01809     //  fElemDepth
01810     //      This is used to track the element nesting depth, so that we can
01811     //      know when we are inside content. This is so we can ignore char
01812     //      data outside of content.
01813     //
01814     //  fEntityResolver
01815     //      The installed SAX entity handler, if any. Null if none.
01816     //
01817     //  fErrorHandler
01818     //      The installed SAX error handler, if any. Null if none.
01819     //
01820     //  fAdvDHCount
01821     //  fAdvDHList
01822     //  fAdvDHListSize
01823     //      This is an array of pointers to XMLDocumentHandlers, which is
01824     //      how we see installed advanced document handlers. There will
01825     //      usually not be very many at all, so a simple array is used
01826     //      instead of a collection, for performance. It will grow if needed,
01827     //      but that is unlikely.
01828     //
01829     //      The count is how many handlers are currently installed. The size
01830     //      is how big the array itself is (for expansion purposes.) When
01831     //      count == size, is time to expand.
01832     //
01833     //  fParseInProgress
01834     //      This flag is set once a parse starts. It is used to prevent
01835     //      multiple entrance or reentrance of the parser.
01836     //
01837     //  fScanner
01838     //      The scanner being used by this parser. It is created internally
01839     //      during construction.
01840     //
01841     // -----------------------------------------------------------------------
01842     VecAttrListImpl         fAttrList;
01843     DocumentHandler*        fDocHandler;
01844     DTDHandler*             fDTDHandler;
01845     unsigned int            fElemDepth;
01846     EntityResolver*         fEntityResolver;
01847     ErrorHandler*           fErrorHandler;
01848     unsigned int            fAdvDHCount;
01849     XMLDocumentHandler**    fAdvDHList;
01850     unsigned int            fAdvDHListSize;
01851     bool                    fParseInProgress;
01852     XMLScanner*             fScanner;
01853 };
01854 
01855 
01856 // ---------------------------------------------------------------------------
01857 //  SAXParser: Getter methods
01858 // ---------------------------------------------------------------------------
01859 inline DocumentHandler* SAXParser::getDocumentHandler()
01860 {
01861     return fDocHandler;
01862 }
01863 
01864 inline const DocumentHandler* SAXParser::getDocumentHandler() const
01865 {
01866     return fDocHandler;
01867 }
01868 
01869 inline EntityResolver* SAXParser::getEntityResolver()
01870 {
01871     return fEntityResolver;
01872 }
01873 
01874 inline const EntityResolver* SAXParser::getEntityResolver() const
01875 {
01876     return fEntityResolver;
01877 }
01878 
01879 inline ErrorHandler* SAXParser::getErrorHandler()
01880 {
01881     return fErrorHandler;
01882 }
01883 
01884 inline const ErrorHandler* SAXParser::getErrorHandler() const
01885 {
01886     return fErrorHandler;
01887 }
01888 
01889 inline const XMLScanner& SAXParser::getScanner() const
01890 {
01891     return *fScanner;
01892 }
01893 
01894 #endif


Copyright © 2000 The Apache Software Foundation. All Rights Reserved.