XercesDOMParser.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$
 */
 
#if !defined(XERCESC_INCLUDE_GUARD_XERCESDOMPARSER_HPP)
#define XERCESC_INCLUDE_GUARD_XERCESDOMPARSER_HPP
 
 
#include <xercesc/parsers/AbstractDOMParser.hpp>
#include <xercesc/validators/common/Grammar.hpp>
 
XERCES_CPP_NAMESPACE_BEGIN
 
 
class EntityResolver;
class ErrorHandler;
class XMLEntityResolver;
class XMLResourceIdentifier;
 
class PARSERS_EXPORT XercesDOMParser : public AbstractDOMParser
{
public :
    // -----------------------------------------------------------------------
    //  Constructors and Destructor
    // -----------------------------------------------------------------------
 
    XercesDOMParser
    (
          XMLValidator* const   valToAdopt = 0
        , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
        , XMLGrammarPool* const gramPool = 0
    );
 
    virtual ~XercesDOMParser();
 
 
 
    // -----------------------------------------------------------------------
    //  Getter methods
    // -----------------------------------------------------------------------
 
 
    ErrorHandler* getErrorHandler();
 
    const ErrorHandler* getErrorHandler() const;
 
    EntityResolver* getEntityResolver();
 
    const EntityResolver* getEntityResolver() const;
 
    XMLEntityResolver* getXMLEntityResolver();
 
    const XMLEntityResolver* getXMLEntityResolver() const;
 
    bool isCachingGrammarFromParse() const;
 
    bool isUsingCachedGrammarInParse() const;
 
    Grammar* getGrammar(const XMLCh* const nameSpaceKey);
 
    Grammar* getRootGrammar();
 
    const XMLCh* getURIText(unsigned int uriId) const;
 
    XMLFilePos getSrcOffset() const;
 
    bool getIgnoreCachedDTD() const;
 
 
 
    // -----------------------------------------------------------------------
    //  Setter methods
    // -----------------------------------------------------------------------
 
 
    void setErrorHandler(ErrorHandler* const handler);
 
    void setEntityResolver(EntityResolver* const handler);
 
    void setXMLEntityResolver(XMLEntityResolver* const handler);
 
    void cacheGrammarFromParse(const bool newState);
 
    void useCachedGrammarInParse(const bool newState);
 
    void setIgnoreCachedDTD(const bool newValue);
 
 
    // -----------------------------------------------------------------------
    //  Utility methods
    // -----------------------------------------------------------------------
 
    void resetDocumentPool();
 
 
    // -----------------------------------------------------------------------
    //  Implementation of the XMLErrorReporter interface.
    // -----------------------------------------------------------------------
 
 
    virtual void error
    (
        const   unsigned int                errCode
        , const XMLCh* const                msgDomain
        , const XMLErrorReporter::ErrTypes  errType
        , const XMLCh* const                errorText
        , const XMLCh* const                systemId
        , const XMLCh* const                publicId
        , const XMLFileLoc                  lineNum
        , const XMLFileLoc                  colNum
    );
 
    virtual void resetErrors();
 
 
    // -----------------------------------------------------------------------
    //  Implementation of the XMLEntityHandler interface.
    // -----------------------------------------------------------------------
 
 
    virtual void endInputSource(const InputSource& inputSource);
 
    virtual bool expandSystemId
    (
        const   XMLCh* const    systemId
        ,       XMLBuffer&      toFill
    );
 
    virtual void resetEntities();
 
    virtual InputSource* resolveEntity
    (
        XMLResourceIdentifier* resourceIdentifier
    );
 
    virtual void startInputSource(const InputSource& inputSource);
 
 
    // -----------------------------------------------------------------------
    //  Grammar preparsing interface
    // -----------------------------------------------------------------------
 
    Grammar* loadGrammar(const InputSource& source,
                         const Grammar::GrammarType grammarType,
                         const bool toCache = false);
 
    Grammar* loadGrammar(const XMLCh* const systemId,
                         const Grammar::GrammarType grammarType,
                         const bool toCache = false);
 
    Grammar* loadGrammar(const char* const systemId,
                         const Grammar::GrammarType grammarType,
                         const bool toCache = false);
 
    void resetCachedGrammarPool();
 
 
 
private :
    // -----------------------------------------------------------------------
    //  Initialize/Cleanup methods
    // -----------------------------------------------------------------------
    void resetParse();
 
    // -----------------------------------------------------------------------
    //  Unimplemented constructors and operators
    // -----------------------------------------------------------------------
    XercesDOMParser(const XercesDOMParser&);
    XercesDOMParser& operator=(const XercesDOMParser&);
 
    // -----------------------------------------------------------------------
    //  Private data members
    //
    //  fEntityResolver
    //      The installed SAX entity resolver, if any. Null if none.
    //
    //  fErrorHandler
    //      The installed SAX error handler, if any. Null if none.
    //-----------------------------------------------------------------------
    EntityResolver*          fEntityResolver;
    XMLEntityResolver*       fXMLEntityResolver;
    ErrorHandler*            fErrorHandler;
};
 
 
 
// ---------------------------------------------------------------------------
//  XercesDOMParser: Handlers for the XMLEntityHandler interface
// ---------------------------------------------------------------------------
inline void XercesDOMParser::endInputSource(const InputSource&)
{
    // The DOM entity resolver doesn't handle this
}
 
inline bool XercesDOMParser::expandSystemId(const XMLCh* const, XMLBuffer&)
{
    // The DOM entity resolver doesn't handle this
    return false;
}
 
inline void XercesDOMParser::resetEntities()
{
    // Nothing to do on this one
}
 
inline void XercesDOMParser::startInputSource(const InputSource&)
{
    // The DOM entity resolver doesn't handle this
}
 
 
// ---------------------------------------------------------------------------
//  XercesDOMParser: Getter methods
// ---------------------------------------------------------------------------
inline ErrorHandler* XercesDOMParser::getErrorHandler()
{
    return fErrorHandler;
}
 
inline const ErrorHandler* XercesDOMParser::getErrorHandler() const
{
    return fErrorHandler;
}
 
inline EntityResolver* XercesDOMParser::getEntityResolver()
{
    return fEntityResolver;
}
 
inline const EntityResolver* XercesDOMParser::getEntityResolver() const
{
    return fEntityResolver;
}
 
inline XMLEntityResolver* XercesDOMParser::getXMLEntityResolver()
{
    return fXMLEntityResolver;
}
 
inline const XMLEntityResolver* XercesDOMParser::getXMLEntityResolver() const
{
    return fXMLEntityResolver;
}
 
XERCES_CPP_NAMESPACE_END
 
#endif