Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.9

XercesParserLiaison.hpp

Go to the documentation of this file.

/*
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * Licensed 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.
 */
#if !defined(XercesPARSERLIAISON_HEADER_GUARD_1357924680)
#define XercesPARSERLIAISON_HEADER_GUARD_1357924680


// Base include file.  Must be first.
#include <xalanc/XercesParserLiaison/XercesParserLiaisonDefinitions.hpp>



// Standard Library header files.
#include <xalanc/Include/XalanMap.hpp>



// Xerces DOM header files
#include <xercesc/sax/ErrorHandler.hpp>



// Base class header file.
#include <xalanc/XMLSupport/XMLParserLiaison.hpp>



#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
#include <xalanc/XercesParserLiaison/Deprecated/XercesBridgeTypes.hpp>
#endif
#include <xalanc/XercesParserLiaison/XercesWrapperTypes.hpp>



#if XERCES_VERSION_MAJOR >= 2
XALAN_DECLARE_XERCES_CLASS(XercesDOMParser)
#else
XALAN_DECLARE_XERCES_CLASS(DOMParser)
#endif
XALAN_DECLARE_XERCES_CLASS(SAXParser)



XALAN_CPP_NAMESPACE_BEGIN



class XercesDOMSupport;
#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
class XercesDocumentBridge;
#endif
class XercesDocumentWrapper;


typedef XERCES_CPP_NAMESPACE_QUALIFIER SAXParseException    SAXParseExceptionType;


class XALAN_XERCESPARSERLIAISON_EXPORT XercesParserLiaison :
    public XMLParserLiaison,
    public ErrorHandlerType
{
    
public:

    typedef XERCES_CPP_NAMESPACE_QUALIFIER SAXParser            SAXParserType;

    XercesParserLiaison( XercesDOMSupport&  theSupport, MemoryManagerType& theManager XALAN_DEFAULT_MEMMGR);

    XercesParserLiaison(MemoryManagerType& theManager XALAN_DEFAULT_MEMMGR);

    virtual
    ~XercesParserLiaison();



    // These interfaces are inherited from XMLParserLiaison...
    MemoryManagerType&
    getMemoryManager()
    {
        return m_externalSchemaLocation.getMemoryManager();
    }

    virtual void
    reset();

    virtual ExecutionContext*
    getExecutionContext() const;

    virtual void
    setExecutionContext(ExecutionContext&   theContext);

    virtual XalanDocument*
    parseXMLStream(
            const InputSourceType&  reader,
            const XalanDOMString&   identifier = XalanDOMString(XalanMemMgrs::getDummyMemMgr()));

    virtual void
    parseXMLStream(
            const InputSourceType&  urlInputSource,
            DocumentHandlerType&    handler,
            const XalanDOMString&   identifier = XalanDOMString(XalanMemMgrs::getDummyMemMgr()));

    virtual void
    destroyDocument(XalanDocument*  theDocument);

    virtual int
    getIndent() const;

    virtual void
    setIndent(int   i);

    virtual bool
    getUseValidation() const;

    virtual void
    setUseValidation(bool   b);

    virtual const XalanDOMString&
    getParserDescription(XalanDOMString& theResult) const;

    virtual EntityResolverType*
    getEntityResolver() const;

    virtual void
    setEntityResolver(EntityResolverType*   resolver);


    // These interfaces are new to XercesParserLiaison...

    virtual DOMDocument_Type*
    createDOMFactory();

    virtual void
    destroyDocument(DOMDocument_Type*   theDocument);

    virtual bool
    getIncludeIgnorableWhitespace() const;

    virtual void
    setIncludeIgnorableWhitespace(bool  include);

    virtual ErrorHandlerType*
    getErrorHandler() const;

    virtual void
    setErrorHandler(ErrorHandlerType*   handler);

    virtual bool
    getDoNamespaces() const;

    virtual void
    setDoNamespaces(bool    newState);

    virtual bool
    getExitOnFirstFatalError() const;

    virtual void
    setExitOnFirstFatalError(bool   newState);

    virtual const XalanDOMChar*
    getExternalSchemaLocation() const;

    virtual void
    setExternalSchemaLocation(const XalanDOMChar*   location);

    virtual const XalanDOMChar*
    getExternalNoNamespaceSchemaLocation() const;

    virtual void
    setExternalNoNamespaceSchemaLocation(const XalanDOMChar*    location);

#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)

    XalanDocument*
    createDocument(const DOM_Document_Type&     theXercesDocument)
    {
        return createDocument(theXercesDocument, m_threadSafe, m_buildBridge);
    }

    XalanDocument*
    createDocument(
            const DOM_Document_Type&    theXercesDocument,
            bool                        threadSafe,
            bool                        buildBridge);
#endif

    XalanDocument*
    createDocument(const DOMDocument_Type*  theXercesDocument)
    {
        return createDocument(theXercesDocument, m_threadSafe, m_buildWrapper, m_buildMaps);
    }

    XalanDocument*
    createDocument(
            const DOMDocument_Type*     theXercesDocument,
            bool                        threadSafe,
            bool                        buildWrapper,
            bool                        buildMaps = false);

#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)

    XercesDocumentBridge*
    mapDocument(const XalanDocument*    theDocument) const;
#endif

    XercesDocumentWrapper*
    mapDocumentToWrapper(const XalanDocument*   theDocument) const;

#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)

    DOM_Document_Type
    mapXercesDocument(const XalanDocument*  theDocument) const;
#endif

    const DOMDocument_Type*
    mapToXercesDocument(const XalanDocument*    theDocument) const;

    // Implementations for SAX ErrorHandler

    virtual void
    warning(const SAXParseExceptionType&    exception);

    virtual void
    error(const SAXParseExceptionType&  exception);
   
    virtual void
    fatalError(const SAXParseExceptionType&     exception);

    virtual void
    resetErrors();

    struct DocumentEntry
    {
#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
        bool    m_isDeprecated;

        bool
        isDeprecated() const
        {
            return m_isDeprecated;
        }
#else
        bool
        isDeprecated() const
        {
            return false;
        }
#endif

        bool    m_isOwned;

        bool
        isOwned() const
        {
            return m_isOwned;
        }

#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
        union
        {
            XercesDocumentBridge*   m_bridge;
            XercesDocumentWrapper*  m_wrapper;
        };

        DocumentEntry&
        operator=(XercesDocumentBridge*     theBridge)
        {
            m_isDeprecated = true;

            m_bridge = theBridge;

            m_isOwned = true;

            return *this;
        }

        DocumentEntry&
        operator=(XercesDocumentWrapper*    theWrapper)
        {
            m_isDeprecated = false;

            m_wrapper = theWrapper;

            m_isOwned = true;

            return *this;
        }
#else
        XercesDocumentWrapper*  m_wrapper;

        DocumentEntry&
        operator=(XercesDocumentWrapper*    theWrapper)
        {
            m_wrapper = theWrapper;

            m_isOwned = true;

            return *this;
        }
#endif
    };

    typedef XalanMap<const XalanDocument*, DocumentEntry>   DocumentMapType;

    bool
    getBuildBridgeNodes() const
    
    {
        return m_buildBridge;
    }

    void
    setBuildBridgeNodes(bool    newState)
    {
        m_buildBridge = newState;

        if (newState == false)
        {
            m_threadSafe = false;
        }
    }

    bool
    getBuildWrapperNodes() const
    
    {
        return m_buildWrapper;
    }

    void
    setBuildWrapperNodes(bool   newState)
    {
        m_buildWrapper = newState;

        if (newState == false)
        {
            m_threadSafe = false;
        }
    }

    bool
    getThreadSafe() const
    
    {
        return m_threadSafe;
    }

    void
    setThreadSafe(bool  newState)
    {
        m_threadSafe = newState;

        if (m_threadSafe == true)
        {
            m_buildWrapper = true;
            m_buildBridge = true;
        }
    }

    bool
    getBuildMaps() const
    
    {
        return m_buildMaps;
    }
 
    void
    setBuildMaps(bool   newState)
    {
        m_buildMaps = newState;
    }

#if XERCES_VERSION_MAJOR >= 2
    typedef XERCES_CPP_NAMESPACE_QUALIFIER XercesDOMParser  DOMParserType;
#else
    typedef XERCES_CPP_NAMESPACE_QUALIFIER DOMParser        DOMParserType;
#endif

protected:

    static void
    formatErrorMessage(
            const SAXParseExceptionType&    e,
            XalanDOMString&                 theMessage);

#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)

    XercesDocumentBridge*
    doCreateDocument(
            const DOM_Document_Type&    theXercesDocument,
            bool                        threadSafe,
            bool                        buildBridge);
#endif

    XercesDocumentWrapper*
    doCreateDocument(
            const DOMDocument_Type*     theXercesDocument,
            bool                        threadSafe,
            bool                        buildWrapper,
            bool                        buildMaps,
            bool                        isOwned);

private:

    void
    ensureSAXParser();

    void
    ensureDOMParser();

    DOMParserType*
    createDOMParser();

    SAXParserType*
    createSAXParser();



    // Data members...
    int                 m_indent;

    bool                m_useValidation;

    bool                m_includeIgnorableWhitespace;

    bool                m_doNamespaces;

    bool                m_exitOnFirstFatalError;

    EntityResolverType* m_entityResolver;

    ErrorHandlerType*   m_errorHandler;

    XalanDOMString      m_externalSchemaLocation;

    XalanDOMString      m_externalNoNamespaceSchemaLocation;

    DocumentMapType     m_documentMap;

    bool                m_buildWrapper;

    bool                m_buildBridge;

    bool                m_threadSafe;

    bool                m_buildMaps;

    ExecutionContext*   m_executionContext;

    SAXParserType*      m_saxParser;

    DOMParserType*      m_domParser;
};



XALAN_CPP_NAMESPACE_END



#endif  // XercesPARSERLIAISON_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.9 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.