## Xalan-C++ API Documentation

### The Xalan C++ XSLT Processor Version 1.9

Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Related Pages

# XercesDocumentBridge.hpp

Go to the documentation of this file.

    00001 /*
    00002  * Copyright 1999-2004 The Apache Software Foundation.
    00003  *
    00004  * Licensed under the Apache License, Version 2.0 (the "License");
    00005  * you may not use this file except in compliance with the License.
    00006  * You may obtain a copy of the License at
    00007  *
    00008  *     http://www.apache.org/licenses/LICENSE-2.0
    00009  *
    00010  * Unless required by applicable law or agreed to in writing, software
    00011  * distributed under the License is distributed on an "AS IS" BASIS,
    00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    00013  * See the License for the specific language governing permissions and
    00014  * limitations under the License.
    00015  */
    00016 #if !defined(XERCESDOCUMENTBRIDGE_HEADER_GUARD_1357924680)
    00017 #define XERCESDOCUMENTBRIDGE_HEADER_GUARD_1357924680
    00018
    00019
    00020
    00021 #include <xalanc/XercesParserLiaison/XercesParserLiaisonDefinitions.hpp>
    00022
    00023
    00024
    00025 #include <xalanc/Include/XalanVector.hpp>
    00026 #include <xalanc/Include/XalanDeque.hpp>
    00027
    00028
    00029
    00030 #if XERCES_VERSION_MAJOR >= 2
    00031 #include <xercesc/dom/deprecated/DOM_Document.hpp>
    00032 #else
    00033 #include <xercesc/dom/DOM_Document.hpp>
    00034 #endif
    00035
    00036
    00037
    00038 #include <xalanc/XalanDOM/XalanDocument.hpp>
    00039
    00040
    00041
    00042 #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION)
    00043 #include <xalanc/XalanDOM/XalanDOMImplementation.hpp>
    00044 #include <xalanc/PlatformSupport/XalanDOMStringPool.hpp>
    00045 #endif
    00046
    00047
    00048
    00049 #include <xalanc/Include/XalanAutoPtr.hpp>
    00050
    00051
    00052
    00053 #include <xalanc/DOMSupport/TreeWalker.hpp>
    00054
    00055
    00056
    00057 #include <xalanc/XercesParserLiaison/Deprecated/XercesToXalanNodeMap.hpp>
    00058 #include <xalanc/XercesParserLiaison/Deprecated/XercesBridgeNavigator.hpp>
    00059 #include <xalanc/XercesParserLiaison/Deprecated/XercesNodeListBridge.hpp>
    00060 #include <xalanc/XercesParserLiaison/Deprecated/XercesTreeWalker.hpp>
    00061 #include <xalanc/XercesParserLiaison/Deprecated/XercesElementBridgeAllocator.hpp>
    00062 #include <xalanc/XercesParserLiaison/Deprecated/XercesTextBridgeAllocator.hpp>
    00063 #include <xalanc/XercesParserLiaison/Deprecated/XercesAttributeBridgeAllocator.hpp>
    00064
    00065
    00066
    00067 XALAN_CPP_NAMESPACE_BEGIN
    00068
    00069
    00070
    00071 class XalanDOMStringPool;
    00072 class XercesAttrBridge;
    00073 class XercesCommentBridge;
    00074 class XercesCDATASectionBridge;
    00075 class XercesDocumentFragmentBridge;
    00076 class XercesDocumentTypeBridge;
    00077 class XercesElementBridge;
    00078 class XercesEntityBridge;
    00079 class XercesEntityReferenceBridge;
    00080 class XercesProcessingInstructionBridge;
    00081 class XercesNotationBridge;
    00082 class XercesTextBridge;
    00083
    00084
    00090 class XALAN_XERCESPARSERLIAISON_EXPORT XercesDocumentBridge : public XalanDocument
    00091 {
    00092 public:
    00093
    00094     friend class XercesBridgeNavigator;
    00095
    00111     XercesDocumentBridge(
    00112             const DOM_Document_Type&    theXercesDocument,
    00113             bool                        threadSafe = true,
    00114             bool                        buildBridge = true);
    00115
    00116     virtual
    00117     ~XercesDocumentBridge();
    00118
    00119     // These interfaces are inherited from XalanNode...
    00120
    00121     virtual const XalanDOMString&
    00122     getNodeName() const;
    00123
    00124     virtual const XalanDOMString&
    00125     getNodeValue() const;
    00126
    00127     virtual NodeType
    00128     getNodeType() const;
    00129
    00130     virtual XalanNode*
    00131     getParentNode() const;
    00132
    00133     virtual const XalanNodeList*
    00134     getChildNodes() const;
    00135
    00136     virtual XalanNode*
    00137     getFirstChild() const;
    00138
    00139     virtual XalanNode*
    00140     getLastChild() const;
    00141
    00142     virtual XalanNode*
    00143     getPreviousSibling() const;
    00144
    00145     virtual XalanNode*
    00146     getNextSibling() const;
    00147
    00148     virtual const XalanNamedNodeMap*
    00149     getAttributes() const;
    00150
    00151     virtual XalanDocument*
    00152     getOwnerDocument() const;
    00153
    00154 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
    00155     virtual XalanNode*
    00156 #else
    00157     virtual XercesDocumentBridge*
    00158 #endif
    00159     cloneNode(bool deep) const;
    00160
    00161     virtual XalanNode*
    00162     insertBefore(
    00163             XalanNode*  newChild,
    00164             XalanNode*  refChild);
    00165
    00166     virtual XalanNode*
    00167     replaceChild(
    00168             XalanNode*  newChild,
    00169             XalanNode*  oldChild);
    00170
    00171     virtual XalanNode*
    00172     removeChild(XalanNode*  oldChild);
    00173
    00174     virtual XalanNode*
    00175     appendChild(XalanNode*  newChild);
    00176
    00177     virtual bool
    00178     hasChildNodes() const;
    00179
    00180     virtual void
    00181     setNodeValue(const XalanDOMString&      nodeValue);
    00182
    00183     virtual void
    00184     normalize();
    00185
    00186     virtual bool
    00187     isSupported(
    00188             const XalanDOMString&   feature,
    00189             const XalanDOMString&   version) const;
    00190
    00191     virtual const XalanDOMString&
    00192     getNamespaceURI() const;
    00193
    00194     virtual const XalanDOMString&
    00195     getPrefix() const;
    00196
    00197     virtual const XalanDOMString&
    00198     getLocalName() const;
    00199
    00200     virtual void
    00201     setPrefix(const XalanDOMString& prefix);
    00202
    00203     virtual bool
    00204     isIndexed() const;
    00205
    00206     virtual IndexType
    00207     getIndex() const;
    00208
    00209     virtual XalanElement*
    00210     createElement(const XalanDOMString& tagName);
    00211
    00212     virtual XalanDocumentFragment*
    00213     createDocumentFragment();
    00214
    00215     virtual XalanText*
    00216     createTextNode(const XalanDOMString&    data);
    00217
    00218     virtual XalanComment*
    00219     createComment(const XalanDOMString& data);
    00220
    00221     virtual XalanCDATASection*
    00222     createCDATASection(const XalanDOMString&    data);
    00223
    00224     virtual XalanProcessingInstruction*
    00225     createProcessingInstruction(
    00226             const XalanDOMString&   target,
    00227             const XalanDOMString&   data);
    00228
    00229     virtual XalanAttr*
    00230     createAttribute(const XalanDOMString&   name);
    00231
    00232     virtual XalanEntityReference*
    00233     createEntityReference(const XalanDOMString& name);
    00234
    00235     virtual XalanDocumentType*
    00236     getDoctype() const;
    00237
    00238     virtual XalanDOMImplementation*
    00239     getImplementation() const;
    00240
    00241     virtual XalanElement*
    00242     getDocumentElement() const;
    00243
    00244     virtual XalanNodeList*
    00245     getElementsByTagName(const XalanDOMString&      tagname) const;
    00246
    00247     virtual XalanNode*
    00248     importNode(
    00249             XalanNode*  importedNode,
    00250             bool        deep);
    00251
    00252     virtual XalanElement*
    00253     createElementNS(
    00254             const XalanDOMString&   namespaceURI,
    00255             const XalanDOMString&   qualifiedName);
    00256
    00257     virtual XalanAttr*
    00258     createAttributeNS(
    00259             const XalanDOMString& namespaceURI,
    00260             const XalanDOMString& qualifiedName);
    00261
    00262     virtual XalanNodeList*
    00263     getElementsByTagNameNS(
    00264             const XalanDOMString&   namespaceURI,
    00265             const XalanDOMString&   localName) const;
    00266
    00267     virtual XalanElement*
    00268     getElementById(const XalanDOMString&    elementId) const;
    00269
    00270     // These are some special interfaces to manage relationships between
    00271     // our nodes and Xerces nodes.
    00272
    00280     void
    00281     destroyBridge();
    00282
    00289     void
    00290     rebuildBridge();
    00291
    00292     XalanNode*
    00293     mapNode(const DOM_NodeType&     theXercesNode) const;
    00294
    00295     XalanAttr*
    00296     mapNode(const DOM_AttrType&     theXercesNode) const;
    00297
    00298     XalanElement*
    00299     mapNode(const DOM_ElementType&  theXercesNode) const;
    00300
    00301     DOM_NodeType
    00302     mapNode(const XalanNode*    theXalanNode) const;
    00303
    00304     DOM_AttrType
    00305     mapNode(const XalanAttr*    theXalanNode) const;
    00306
    00307     NodeImplType*
    00308     mapNodeToImpl(const XalanNode*  theXalanNode) const;
    00309
    00317     DOM_Document_Type
    00318     getXercesDocument() const
    00319     {
    00320         return m_xercesDocument;
    00321     }
    00322
    00328     void
    00329     buildBridgeNodes();
    00330
    00331
    00332     typedef XalanDeque<XercesBridgeNavigator>   NavigatorBridgeVectorType;
    00333     typedef XalanDeque<XalanNode*>              NodeVectorType;
    00334
    00335
    00336     // Helper class to walk the tree and build everything...
    00337     class BuildBridgeTreeWalker : public XercesTreeWalker
    00338     {
    00339     public:
    00340
    00341         typedef NavigatorBridgeVectorType   NavigatorBridgeVectorInnerType;
    00342
    00343         BuildBridgeTreeWalker(
    00344                 XercesDocumentBridge*           theDocument,
    00345                 XercesBridgeNavigator*          theDocumentNavigator,
    00346                 NavigatorBridgeVectorInnerType& theNavigators,
    00347                 IndexType                       theStartIndex);
    00348
    00349         virtual
    00350         ~BuildBridgeTreeWalker();
    00351
    00352         struct NavigatorStackEntryType
    00353         {
    00354             NavigatorStackEntryType(
    00355                         XercesBridgeNavigator*  theNavigator = 0,
    00356                         XalanNode*              theNode = 0) :
    00357                 m_navigator(theNavigator),
    00358                 m_node(theNode)
    00359             {
    00360             }
    00361
    00362             XercesBridgeNavigator*  m_navigator;
    00363
    00364             XalanNode*              m_node;
    00365         };
    00366
    00367
    00368         typedef XalanVector<NavigatorStackEntryType>    NavigatorStackType;
    00369
    00370     protected:
    00371
    00372         virtual void
    00373         startNode(const DOM_NodeType&   node);
    00374
    00375         virtual void
    00376         endNode(const DOM_NodeType&     node);
    00377
    00378     private:
    00379
    00380         XercesDocumentBridge*           m_document;
    00381
    00382         NavigatorBridgeVectorInnerType& m_navigators;
    00383
    00384         IndexType                       m_currentIndex;
    00385
    00386         NavigatorStackType              m_parentNavigatorStack;
    00387
    00388         NavigatorStackType              m_siblingNavigatorStack;
    00389     };
    00390
    00391
    00399     const XalanDOMString&
    00400     getPooledString(const XalanDOMString&   theString) const;
    00401
    00410     const XalanDOMString&
    00411     getPooledString(
    00412             const XalanDOMChar*         theString,
    00413             XalanDOMString::size_type   theLength /* = XalanDOMString::npos */) const;
    00414
    00415 private:
    00416
    00417     XalanNode*
    00418     mapNode(NodeImplType*   theXercesNodeImpl) const;
    00419
    00420     // Destruction API...
    00421     void
    00422     destroyBridgeNode(XalanNode*    theNode);
    00423
    00424     // Not implemented...
    00425     XercesDocumentBridge(const XercesDocumentBridge&    theSource);
    00426
    00427     XercesDocumentBridge&
    00428     operator=(const XercesDocumentBridge&   theRHS);
    00429
    00430     bool
    00431     operator==(const XercesDocumentBridge&  theRHS) const;
    00432
    00433     // Private delete function...
    00434     void
    00435     destroyNode(XalanNode*  theNode);
    00436
    00437     // More internal implementation stuff...
    00438     XalanNode*
    00439     internalCloneNode(
    00440             const XalanNode*        theXalanNode,
    00441             const DOM_NodeType&     theXercesNode,
    00442             bool                    deep);
    00443
    00444     // Factory methods for our implementation nodes...
    00445     XalanNode*
    00446     createBridgeNode(
    00447             const DOM_NodeType&     theXercesNode,
    00448             IndexType               theIndex,
    00449             bool                    mapNode) const;
    00450
    00451     XercesDocumentTypeBridge*
    00452     createBridgeNode(
    00453             const DOM_DocumentType_Type&    theDoctype,
    00454             IndexType                       theIndex,
    00455             bool                            mapNode) const;
    00456
    00457     XercesElementBridge*
    00458     createBridgeNode(
    00459             const DOM_ElementType&  theXercesNode,
    00460             IndexType               theIndex,
    00461             bool                    mapNode) const;
    00462
    00463     XercesDocumentFragmentBridge*
    00464     createBridgeNode(
    00465             const DOM_DocumentFragmentType&     theXercesNode,
    00466             IndexType                           theIndex,
    00467             bool                                mapNode) const;
    00468
    00469     XercesTextBridge*
    00470     createBridgeNode(
    00471             const DOM_TextType&     theXercesNode,
    00472             IndexType               theIndex,
    00473             bool                    mapNode) const;
    00474
    00475     XercesCommentBridge*
    00476     createBridgeNode(
    00477             const DOM_CommentType&  theXercesNode,
    00478             IndexType               theIndex,
    00479             bool                    mapNode) const;
    00480
    00481     XercesCDATASectionBridge*
    00482     createBridgeNode(
    00483             const DOM_CDATASectionType&     theXercesNode,
    00484             IndexType                       theIndex,
    00485             bool                            mapNode) const;
    00486
    00487     XercesProcessingInstructionBridge*
    00488     createBridgeNode(
    00489             const DOM_ProcessingInstructionType&    theXercesNode,
    00490             IndexType                               theIndex,
    00491             bool                                    mapNode) const;
    00492
    00493     XercesAttrBridge*
    00494     createBridgeNode(
    00495             const DOM_AttrType&     theXercesNode,
    00496             IndexType               theIndex,
    00497             bool                    mapNode) const;
    00498
    00499     XercesEntityBridge*
    00500     createBridgeNode(
    00501             const DOM_EntityType&   theXercesNode,
    00502             IndexType               theIndex,
    00503             bool                    mapNode) const;
    00504
    00505     XercesEntityReferenceBridge*
    00506     createBridgeNode(
    00507             const DOM_EntityReferenceType&  theXercesNode,
    00508             IndexType                       theIndex,
    00509             bool                            mapNode) const;
    00510
    00511     XercesNotationBridge*
    00512     createBridgeNode(
    00513             const DOM_NotationType&     theXercesNode,
    00514             IndexType                   theIndex,
    00515             bool                        mapNode) const;
    00516
    00517     XercesBridgeNavigator&
    00518     pushNavigator(bool  mappingMode) const;
    00519
    00520     // This is a private helper class for building the tree...
    00521     friend class BuildBridgeTreeWalker;
    00522
    00523     // $$$ ToDo: This is because DOM_Document::getElementById() is not
    00524     // const...
    00525     mutable DOM_Document_Type               m_xercesDocument;
    00526
    00527     XalanElement*                           m_documentElement;
    00528
    00529     mutable XercesToXalanNodeMap            m_nodeMap;
    00530
    00531     XalanAutoPtr<XalanDOMImplementation>    m_domImplementation;
    00532
    00533     mutable NavigatorBridgeVectorType       m_navigators;
    00534
    00535     // Our navigator will be the first entry in m_navigators,
    00536     // but we'll cache this so access is faster...
    00537     XercesBridgeNavigator*                  m_navigator;
    00538
    00539     XercesNodeListBridge                    m_children;
    00540
    00541     mutable NodeVectorType                  m_nodes;
    00542
    00543     mutable XercesDocumentTypeBridge*       m_doctype;
    00544
    00545     bool                                    m_mappingMode;
    00546
    00547     bool                                    m_indexValid;
    00548
    00549     mutable XercesElementBridgeAllocator    m_elementAllocator;
    00550
    00551     mutable XercesTextBridgeAllocator       m_textAllocator;
    00552
    00553     mutable XercesAttributeBridgeAllocator  m_attributeAllocator;
    00554
    00555     const XalanAutoPtr<XalanDOMStringPool>  m_stringPool;
    00556 };
    00557
    00558
    00559
    00560 XALAN_CPP_NAMESPACE_END
    00561
    00562
    00563
    00564 #endif  // !defined(XERCESDOCUMENTBRIDGE_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.