XercesDocumentBridge.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.
 */
#if !defined(XERCESDOCUMENTBRIDGE_HEADER_GUARD_1357924680)
#define XERCESDOCUMENTBRIDGE_HEADER_GUARD_1357924680
 
 
 
#include <xalanc/XercesParserLiaison/XercesParserLiaisonDefinitions.hpp>
 
 
 
#include <xalanc/Include/XalanVector.hpp>
#include <xalanc/Include/XalanDeque.hpp>
 
 
 
#if XERCES_VERSION_MAJOR >= 2
#include <xercesc/dom/deprecated/DOM_Document.hpp>
#else
#include <xercesc/dom/DOM_Document.hpp>
#endif
 
 
 
#include <xalanc/XalanDOM/XalanDocument.hpp>
 
 
 
#if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION)
#include <xalanc/XalanDOM/XalanDOMImplementation.hpp>
#include <xalanc/PlatformSupport/XalanDOMStringPool.hpp>
#endif
 
 
 
#include <xalanc/Include/XalanAutoPtr.hpp>
 
 
 
#include <xalanc/DOMSupport/TreeWalker.hpp>
 
 
 
#include <xalanc/XercesParserLiaison/Deprecated/XercesToXalanNodeMap.hpp>
#include <xalanc/XercesParserLiaison/Deprecated/XercesBridgeNavigator.hpp>
#include <xalanc/XercesParserLiaison/Deprecated/XercesNodeListBridge.hpp>
#include <xalanc/XercesParserLiaison/Deprecated/XercesTreeWalker.hpp>
#include <xalanc/XercesParserLiaison/Deprecated/XercesElementBridgeAllocator.hpp>
#include <xalanc/XercesParserLiaison/Deprecated/XercesTextBridgeAllocator.hpp>
#include <xalanc/XercesParserLiaison/Deprecated/XercesAttributeBridgeAllocator.hpp>
 
 
 
namespace XALAN_CPP_NAMESPACE {
 
 
 
class XalanDOMStringPool;
class XercesAttrBridge;
class XercesCommentBridge;
class XercesCDATASectionBridge;
class XercesDocumentFragmentBridge;
class XercesDocumentTypeBridge;
class XercesElementBridge;
class XercesEntityBridge;
class XercesEntityReferenceBridge;
class XercesProcessingInstructionBridge;
class XercesNotationBridge;
class XercesTextBridge;
 
 
/**
 * This class is deprecated.
 *
 * @deprecated This class is part of the deprecated Xerces DOM bridge.
 */
class XALAN_XERCESPARSERLIAISON_EXPORT XercesDocumentBridge : public XalanDocument
{
public:
 
    friend class XercesBridgeNavigator;
 
    /**
     *
     * Constructor for XercesDocumentBridge.
     *
     * If the document will be shared amongst multiple threads of execution,
     * the parameter buildBridge must be true.  Otherwise, the bridge
     * nodes will be built on demand, a process which is not synchronized.
     * This could cause serious problems if multiple threads tried to visit
     * an unbuilt node at the same time.
     *
     * @param theXercesDocument The Xerces document to bridge
     * @param threadSafe If true, the tree can safely be shared amongst multiple threads.  (Also implies buildBridge == true)
     * @param buildBridge If true, all of the bridge nodes will be built during construction.
     *
     */
    XercesDocumentBridge(
            const DOM_Document_Type&    theXercesDocument,
            bool                        threadSafe = true,
            bool                        buildBridge = true);
 
    virtual
    ~XercesDocumentBridge();
 
    // These interfaces are inherited from XalanNode...
 
    virtual const XalanDOMString&
    getNodeName() const;
 
    virtual const XalanDOMString&
    getNodeValue() const;
 
    virtual NodeType
    getNodeType() const;
 
    virtual XalanNode*
    getParentNode() const;
 
    virtual const XalanNodeList*
    getChildNodes() const;
 
    virtual XalanNode*
    getFirstChild() const;
 
    virtual XalanNode*
    getLastChild() const;
 
    virtual XalanNode*
    getPreviousSibling() const;
 
    virtual XalanNode*
    getNextSibling() const;
 
    virtual const XalanNamedNodeMap*
    getAttributes() const;
 
    virtual XalanDocument*
    getOwnerDocument() const;
 
    virtual XercesDocumentBridge*
    cloneNode(bool deep) const;
 
    virtual XalanNode*
    insertBefore(
            XalanNode*  newChild,
            XalanNode*  refChild);
 
    virtual XalanNode*
    replaceChild(
            XalanNode*  newChild,
            XalanNode*  oldChild);
 
    virtual XalanNode*
    removeChild(XalanNode*  oldChild);
 
    virtual XalanNode*
    appendChild(XalanNode*  newChild);
 
    virtual bool
    hasChildNodes() const;
 
    virtual void
    setNodeValue(const XalanDOMString&      nodeValue);
 
    virtual void
    normalize();
 
    virtual bool
    isSupported(
            const XalanDOMString&   feature,
            const XalanDOMString&   version) const;
 
    virtual const XalanDOMString&
    getNamespaceURI() const;
 
    virtual const XalanDOMString&
    getPrefix() const;
 
    virtual const XalanDOMString&
    getLocalName() const;
 
    virtual void
    setPrefix(const XalanDOMString& prefix);
 
    virtual bool
    isIndexed() const;
 
    virtual IndexType
    getIndex() const;
 
    virtual XalanElement*
    createElement(const XalanDOMString& tagName);
 
    virtual XalanDocumentFragment*
    createDocumentFragment();
 
    virtual XalanText*
    createTextNode(const XalanDOMString&    data);
 
    virtual XalanComment*
    createComment(const XalanDOMString& data);
 
    virtual XalanCDATASection*
    createCDATASection(const XalanDOMString&    data);
 
    virtual XalanProcessingInstruction*
    createProcessingInstruction(
            const XalanDOMString&   target,
            const XalanDOMString&   data);
 
    virtual XalanAttr*
    createAttribute(const XalanDOMString&   name);
 
    virtual XalanEntityReference*
    createEntityReference(const XalanDOMString& name);
 
    virtual XalanDocumentType*
    getDoctype() const;
 
    virtual XalanDOMImplementation*
    getImplementation() const;
 
    virtual XalanElement*
    getDocumentElement() const;
 
    virtual XalanNodeList*
    getElementsByTagName(const XalanDOMString&      tagname) const;
 
    virtual XalanNode*
    importNode(
            XalanNode*  importedNode,
            bool        deep);
 
    virtual XalanElement*
    createElementNS(
            const XalanDOMString&   namespaceURI,
            const XalanDOMString&   qualifiedName);
 
    virtual XalanAttr*
    createAttributeNS(
            const XalanDOMString& namespaceURI,
            const XalanDOMString& qualifiedName);
 
    virtual XalanNodeList*
    getElementsByTagNameNS(
            const XalanDOMString&   namespaceURI,
            const XalanDOMString&   localName) const;
 
    virtual XalanElement*
    getElementById(const XalanDOMString&    elementId) const;
 
    // These are some special interfaces to manage relationships between
    // our nodes and Xerces nodes.
 
    /**
     * Destroy the entire bridge structure that connects
     * the Xerces document to this XercesDocumentBridge
     * instance.  This will invalidate any pointers to
     * any nodes in the document (except, of course, the
     * document itself).
     */
    void
    destroyBridge();
 
    /**
     * Rebuild the entire bridge structure that connects
     * the Xerces document to this XercesDocumentBridge
     * instance.  This destroys the bridge before
     * rebuilding.
     */
    void
    rebuildBridge();
 
    XalanNode*
    mapNode(const DOM_NodeType&     theXercesNode) const;
 
    XalanAttr*
    mapNode(const DOM_AttrType&     theXercesNode) const;
 
    XalanElement*
    mapNode(const DOM_ElementType&  theXercesNode) const;
 
    DOM_NodeType
    mapNode(const XalanNode*    theXalanNode) const;
 
    DOM_AttrType
    mapNode(const XalanAttr*    theXalanNode) const;
 
    NodeImplType*
    mapNodeToImpl(const XalanNode*  theXalanNode) const;
 
    /**
     *
     * Get the Xerces DOM_Document that this XercesDocument represents.
     *
     * @return the Xerces DOM_Document instance.
     *
     */
    DOM_Document_Type
    getXercesDocument() const
    {
        return m_xercesDocument;
    }
 
    /**
     * Build the entire bridge structure.  This should be done before any
     * processing begins, if the tree will be shared amongst multiple
     * threads.
     */
    void
    buildBridgeNodes();
 
 
    typedef XalanDeque<XercesBridgeNavigator>   NavigatorBridgeVectorType;
    typedef XalanDeque<XalanNode*>              NodeVectorType;
 
 
    // Helper class to walk the tree and build everything...
    class BuildBridgeTreeWalker : public XercesTreeWalker
    {
    public:
 
        typedef NavigatorBridgeVectorType   NavigatorBridgeVectorInnerType;
 
        BuildBridgeTreeWalker(
                XercesDocumentBridge*           theDocument,
                XercesBridgeNavigator*          theDocumentNavigator,
                NavigatorBridgeVectorInnerType& theNavigators,
                IndexType                       theStartIndex);
 
        virtual
        ~BuildBridgeTreeWalker();
 
        struct NavigatorStackEntryType
        {
            NavigatorStackEntryType(
                        XercesBridgeNavigator*  theNavigator = 0,
                        XalanNode*              theNode = 0) :
                m_navigator(theNavigator),
                m_node(theNode)
            {
            }
 
            XercesBridgeNavigator*  m_navigator;
 
            XalanNode*              m_node;
        };
 
    
        typedef XalanVector<NavigatorStackEntryType>    NavigatorStackType;
 
    protected:
 
        virtual void
        startNode(const DOM_NodeType&   node);
 
        virtual void
        endNode(const DOM_NodeType&     node);
 
    private:
 
        XercesDocumentBridge*           m_document;
 
        NavigatorBridgeVectorInnerType& m_navigators;
 
        IndexType                       m_currentIndex;
 
        NavigatorStackType              m_parentNavigatorStack;
 
        NavigatorStackType              m_siblingNavigatorStack;
    };
 
 
    /**
     * Get a pooled string.  If the string is not in the pool,
     * add it.
     *
     * @param theString The string to pool.
     * @return A const reference to the pooled string.
     */
    const XalanDOMString&
    getPooledString(const XalanDOMString&   theString) const;
 
    /**
     * Get a pooled string.  If the string is not in the pool,
     * add it.
     *
     * @param theString The string to pool.
     * @param theLength The length of the string.  If XalanDOMString::npos, the string is assumed to be null-terminated.
     * @return A const reference to the pooled string.
     */
    const XalanDOMString&
    getPooledString(
            const XalanDOMChar*         theString,
            XalanDOMString::size_type   theLength /* = XalanDOMString::npos */) const;
 
private:
 
    XalanNode*
    mapNode(NodeImplType*   theXercesNodeImpl) const;
 
    // Destruction API...
    void
    destroyBridgeNode(XalanNode*    theNode);
 
    // Not implemented...
    XercesDocumentBridge(const XercesDocumentBridge&    theSource);
 
    XercesDocumentBridge&
    operator=(const XercesDocumentBridge&   theRHS);
 
    bool
    operator==(const XercesDocumentBridge&  theRHS) const;
 
    // Private delete function...
    void
    destroyNode(XalanNode*  theNode);
 
    // More internal implementation stuff...
    XalanNode*
    internalCloneNode(
            const XalanNode*        theXalanNode,
            const DOM_NodeType&     theXercesNode,
            bool                    deep);
 
    // Factory methods for our implementation nodes...
    XalanNode*
    createBridgeNode(
            const DOM_NodeType&     theXercesNode,
            IndexType               theIndex,
            bool                    mapNode) const;
 
    XercesDocumentTypeBridge*
    createBridgeNode(
            const DOM_DocumentType_Type&    theDoctype,
            IndexType                       theIndex,
            bool                            mapNode) const;
 
    XercesElementBridge*
    createBridgeNode(
            const DOM_ElementType&  theXercesNode,
            IndexType               theIndex,
            bool                    mapNode) const;
 
    XercesDocumentFragmentBridge*
    createBridgeNode(
            const DOM_DocumentFragmentType&     theXercesNode,
            IndexType                           theIndex,
            bool                                mapNode) const;
 
    XercesTextBridge*
    createBridgeNode(
            const DOM_TextType&     theXercesNode,
            IndexType               theIndex,
            bool                    mapNode) const;
 
    XercesCommentBridge*
    createBridgeNode(
            const DOM_CommentType&  theXercesNode,
            IndexType               theIndex,
            bool                    mapNode) const;
 
    XercesCDATASectionBridge*
    createBridgeNode(
            const DOM_CDATASectionType&     theXercesNode,
            IndexType                       theIndex,
            bool                            mapNode) const;
 
    XercesProcessingInstructionBridge*
    createBridgeNode(
            const DOM_ProcessingInstructionType&    theXercesNode,
            IndexType                               theIndex,
            bool                                    mapNode) const;
 
    XercesAttrBridge*
    createBridgeNode(
            const DOM_AttrType&     theXercesNode,
            IndexType               theIndex,
            bool                    mapNode) const;
 
    XercesEntityBridge*
    createBridgeNode(
            const DOM_EntityType&   theXercesNode,
            IndexType               theIndex,
            bool                    mapNode) const;
 
    XercesEntityReferenceBridge*
    createBridgeNode(
            const DOM_EntityReferenceType&  theXercesNode,
            IndexType                       theIndex,
            bool                            mapNode) const;
 
    XercesNotationBridge*
    createBridgeNode(
            const DOM_NotationType&     theXercesNode,
            IndexType                   theIndex,
            bool                        mapNode) const;
 
    XercesBridgeNavigator&
    pushNavigator(bool  mappingMode) const;
 
    // This is a private helper class for building the tree...
    friend class BuildBridgeTreeWalker;
 
    // $$$ ToDo: This is because DOM_Document::getElementById() is not
    // const...
    mutable DOM_Document_Type               m_xercesDocument;
 
    XalanElement*                           m_documentElement;
 
    mutable XercesToXalanNodeMap            m_nodeMap;
 
    XalanAutoPtr<XalanDOMImplementation>    m_domImplementation;
 
    mutable NavigatorBridgeVectorType       m_navigators;
 
    // Our navigator will be the first entry in m_navigators,
    // but we'll cache this so access is faster...
    XercesBridgeNavigator*                  m_navigator;
 
    XercesNodeListBridge                    m_children;
 
    mutable NodeVectorType                  m_nodes;
 
    mutable XercesDocumentTypeBridge*       m_doctype;
 
    bool                                    m_mappingMode;
 
    bool                                    m_indexValid;
 
    mutable XercesElementBridgeAllocator    m_elementAllocator;
 
    mutable XercesTextBridgeAllocator       m_textAllocator;
 
    mutable XercesAttributeBridgeAllocator  m_attributeAllocator;
 
    const XalanAutoPtr<XalanDOMStringPool>  m_stringPool;
};
 
 
 
}
 
 
 
#endif  // !defined(XERCESDOCUMENTBRIDGE_HEADER_GUARD_1357924680)