dbertoni 00/08/10 11:41:47
Modified: c/src/XercesParserLiaison XercesAttrBridge.cpp
XercesAttrBridge.hpp XercesBridgeNavigator.cpp
XercesBridgeNavigator.hpp
XercesCDATASectionBridge.cpp
XercesCDATASectionBridge.hpp
XercesCommentBridge.cpp XercesCommentBridge.hpp
XercesDocumentBridge.cpp XercesDocumentBridge.hpp
XercesDocumentFragmentBridge.cpp
XercesDocumentFragmentBridge.hpp
XercesDocumentTypeBridge.cpp
XercesDocumentTypeBridge.hpp
XercesElementBridge.cpp XercesElementBridge.hpp
XercesEntityBridge.cpp XercesEntityBridge.hpp
XercesEntityReferenceBridge.cpp
XercesEntityReferenceBridge.hpp
XercesNotationBridge.cpp XercesNotationBridge.hpp
XercesParserLiaison.cpp
XercesProcessingInstructionBridge.cpp
XercesProcessingInstructionBridge.hpp
XercesTextBridge.cpp XercesTextBridge.hpp
XercesToXalanNodeMap.cpp XercesToXalanNodeMap.hpp
Log:
Added document order indexing. By default, now build the entire structure
and keeps pointers to navigate rather than rely on mapping nodes. Added
experimental block allocaters, which, by default, are not enabled.
Revision Changes Path
1.2 +28 -0 xml-xalan/c/src/XercesParserLiaison/XercesAttrBridge.cpp
Index: XercesAttrBridge.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesAttrBridge.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesAttrBridge.cpp 2000/04/11 14:39:29 1.1
+++ XercesAttrBridge.cpp 2000/08/10 18:41:35 1.2
@@ -62,6 +62,10 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include "XercesDOMException.hpp"
#include "XercesDocumentBridge.hpp"
#include "XercesElementBridge.hpp"
@@ -317,6 +321,30 @@
}
}
+
+
+
+bool
+XercesAttrBridge::isIndexed() const
+{
+ return m_navigator.getOwnerDocument()->isIndexed();
+}
+
+
+
+unsigned long
+XercesAttrBridge::getIndex() const
+{
+ return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesAttrBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
+}
1.3 +9 -0 xml-xalan/c/src/XercesParserLiaison/XercesAttrBridge.hpp
Index: XercesAttrBridge.hpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesAttrBridge.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- XercesAttrBridge.hpp 2000/04/11 21:39:14 1.2
+++ XercesAttrBridge.hpp 2000/08/10 18:41:35 1.3
@@ -429,6 +429,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
//@}
// These interfaces are inherited from XalanAttr...
1.3 +12 -28
xml-xalan/c/src/XercesParserLiaison/XercesBridgeNavigator.cpp
Index: XercesBridgeNavigator.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesBridgeNavigator.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- XercesBridgeNavigator.cpp 2000/07/21 19:38:31 1.2
+++ XercesBridgeNavigator.cpp 2000/08/10 18:41:36 1.3
@@ -76,13 +76,16 @@
-XercesBridgeNavigator::XercesBridgeNavigator(XercesDocumentBridge*
theOwnerDocument) :
+XercesBridgeNavigator::XercesBridgeNavigator(
+ XercesDocumentBridge* theOwnerDocument,
+ bool mappingMode) :
m_ownerDocument(theOwnerDocument),
- m_parentNode(invalidNodeAddress),
- m_previousSibling(invalidNodeAddress),
- m_nextSibling(invalidNodeAddress),
- m_firstChild(invalidNodeAddress),
- m_lastChild(invalidNodeAddress)
+ m_parentNode(mappingMode == true ? invalidNodeAddress : 0),
+ m_previousSibling(mappingMode == true ? invalidNodeAddress : 0),
+ m_nextSibling(mappingMode == true ? invalidNodeAddress : 0),
+ m_firstChild(mappingMode == true ? invalidNodeAddress : 0),
+ m_lastChild(mappingMode == true ? invalidNodeAddress : 0),
+ m_index(UINT_MAX)
{
}
@@ -94,7 +97,8 @@
m_previousSibling(theSource.m_previousSibling),
m_nextSibling(theSource.m_nextSibling),
m_firstChild(theSource.m_firstChild),
- m_lastChild(theSource.m_lastChild)
+ m_lastChild(theSource.m_lastChild),
+ m_index(theSource.m_index)
{
}
@@ -106,26 +110,6 @@
-void
-XercesBridgeNavigator::clearCachedNodes()
-{
- m_parentNode = invalidNodeAddress;
- m_previousSibling = invalidNodeAddress;
- m_nextSibling = invalidNodeAddress;
- m_firstChild = invalidNodeAddress;
- m_lastChild = invalidNodeAddress;
-}
-
-
-
-XercesDocumentBridge*
-XercesBridgeNavigator::getOwnerDocument() const
-{
- return m_ownerDocument;
-}
-
-
-
XalanNode*
XercesBridgeNavigator::mapNode(const DOM_Node& theXercesNode)
const
{
@@ -368,7 +352,7 @@
DOM_Text theNewXercesText =
theXercesText.splitText(offset);
assert(theXercesText.isNull() == false);
- theXalanText =
m_ownerDocument->createBridgeNode(theNewXercesText);
+ theXalanText =
m_ownerDocument->createBridgeNode(theNewXercesText, 0, true);
}
catch(const DOM_DOMException& theException)
{
1.4 +100 -25
xml-xalan/c/src/XercesParserLiaison/XercesBridgeNavigator.hpp
Index: XercesBridgeNavigator.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesBridgeNavigator.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- XercesBridgeNavigator.hpp 2000/07/21 19:38:31 1.3
+++ XercesBridgeNavigator.hpp 2000/08/10 18:41:36 1.4
@@ -83,7 +83,9 @@
public:
explicit
- XercesBridgeNavigator(XercesDocumentBridge*
theOwnerDocument);
+ XercesBridgeNavigator(
+ XercesDocumentBridge* theOwnerDocument,
+ bool mappingMode);
XercesBridgeNavigator(const XercesBridgeNavigator& theSource);
@@ -91,71 +93,145 @@
~XercesBridgeNavigator();
- void
- clearCachedNodes();
-
- virtual XercesDocumentBridge*
- getOwnerDocument() const;
+ XercesDocumentBridge*
+ getOwnerDocument() const
+ {
+ return m_ownerDocument;
+ }
- virtual XalanNode*
+ XalanNode*
mapNode(const DOM_Node& theXercesNode) const;
- virtual XalanAttr*
+ XalanAttr*
mapNode(const DOM_Attr& theXercesNode) const;
- virtual DOM_Node
+ DOM_Node
mapNode(const XalanNode* theXalanNode) const;
- virtual DOM_Attr
+ DOM_Attr
mapNode(const XalanAttr* theXercesNode) const;
+
+public:
+
+ unsigned long
+ getIndex() const
+ {
+ return m_index;
+ }
+
+ void
+ setIndex(unsigned long theIndex)
+ {
+ m_index = theIndex;
+ }
- virtual XalanNode*
+ XalanNode*
getParentNode(const DOM_Node& theXercesNode) const;
- virtual XalanNode*
+ XalanNode*
+ getParentNode() const
+ {
+ return m_parentNode;
+ }
+
+ void
+ setParentNode(XalanNode* theParent)
+ {
+ m_parentNode = theParent;
+ }
+
+ XalanNode*
getPreviousSibling(const DOM_Node& theXercesNode) const;
+
+ XalanNode*
+ getPreviousSibling() const
+ {
+ return m_previousSibling;
+ }
+
+ void
+ setPreviousSibling(XalanNode* thePreviousSibling)
+ {
+ m_previousSibling = thePreviousSibling;
+ }
- virtual XalanNode*
+ XalanNode*
getNextSibling(const DOM_Node& theXercesNode) const;
- virtual XalanNode*
+ XalanNode*
+ getNextSibling() const
+ {
+ return m_nextSibling;
+ }
+
+ void
+ setNextSibling(XalanNode* theNextSibling)
+ {
+ m_nextSibling = theNextSibling;
+ }
+
+ XalanNode*
getFirstChild(const DOM_Node& theXercesNode) const;
+
+ XalanNode*
+ getFirstChild() const
+ {
+ return m_firstChild;
+ }
+
+ void
+ setFirstChild(XalanNode* theFirstChild)
+ {
+ m_firstChild = theFirstChild;
+ }
- virtual XalanNode*
+ XalanNode*
getLastChild(const DOM_Node& theXercesNode) const;
- virtual XalanNode*
+ XalanNode*
+ getLastChild() const
+ {
+ return m_lastChild;
+ }
+
+ void
+ setLastChild(XalanNode* theLastChild)
+ {
+ m_lastChild = theLastChild;
+ }
+
+ XalanNode*
insertBefore(
DOM_Node& theXercesParent,
XalanNode* newChild,
XalanNode* refChild) const;
- virtual XalanNode*
+ XalanNode*
replaceChild(
DOM_Node& theXercesParent,
XalanNode* newChild,
XalanNode* oldChild) const;
- virtual XalanNode*
+ XalanNode*
removeChild(
DOM_Node& theXercesParent,
XalanNode* oldChild) const;
- virtual XalanNode*
+ XalanNode*
appendChild(
DOM_Node& theXercesParent,
XalanNode* newChild) const;
- virtual XalanElement*
+ XalanElement*
getOwnerElement(const DOM_Attr& theXercesAttr) const;
- virtual XalanNode*
+ XalanNode*
cloneNode(
const XalanNode* theXalanNode,
const DOM_Node& theXercesNode,
bool deep) const;
- virtual XalanText*
+ XalanText*
splitText(
DOM_Text& theXercesText,
unsigned int offset) const;
@@ -163,9 +239,6 @@
private:
// Not implemented...
-// XercesBridgeNavigator&
-// operator=(const XercesBridgeNavigator& theRHS);
-
bool
operator==(const XercesBridgeNavigator& theRHS) const;
@@ -181,6 +254,8 @@
mutable XalanNode* m_firstChild;
mutable XalanNode* m_lastChild;
+
+ unsigned long m_index;
};
1.2 +36 -0
xml-xalan/c/src/XercesParserLiaison/XercesCDATASectionBridge.cpp
Index: XercesCDATASectionBridge.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesCDATASectionBridge.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesCDATASectionBridge.cpp 2000/04/11 14:39:29 1.1
+++ XercesCDATASectionBridge.cpp 2000/08/10 18:41:36 1.2
@@ -62,6 +62,10 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include "XercesDOMException.hpp"
#include "XercesDocumentBridge.hpp"
@@ -323,6 +327,30 @@
+bool
+XercesCDATASectionBridge::isIndexed() const
+{
+ return m_navigator.getOwnerDocument()->isIndexed();
+}
+
+
+
+unsigned long
+XercesCDATASectionBridge::getIndex() const
+{
+ return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesCDATASectionBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
+}
+
+
+
XalanDOMString
XercesCDATASectionBridge::getData() const
{
@@ -427,4 +455,12 @@
XercesCDATASectionBridge::splitText(unsigned int offset)
{
return m_navigator.splitText(m_xercesNode, offset);
+}
+
+
+
+bool
+XercesCDATASectionBridge::isIgnorableWhitespace() const
+{
+ return isWhiteSpace(m_xercesNode.getData());
}
1.2 +13 -0
xml-xalan/c/src/XercesParserLiaison/XercesCDATASectionBridge.hpp
Index: XercesCDATASectionBridge.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesCDATASectionBridge.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesCDATASectionBridge.hpp 2000/04/11 14:39:29 1.1
+++ XercesCDATASectionBridge.hpp 2000/08/10 18:41:36 1.2
@@ -426,6 +426,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
//@}
// These interfaces are inherited from XalanCDATASection...
@@ -583,6 +592,10 @@
splitText(unsigned int offset);
//@}
+
+ virtual bool
+ isIgnorableWhitespace() const;
+
private:
// Not implemented...
1.2 +28 -0
xml-xalan/c/src/XercesParserLiaison/XercesCommentBridge.cpp
Index: XercesCommentBridge.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesCommentBridge.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesCommentBridge.cpp 2000/04/11 14:39:29 1.1
+++ XercesCommentBridge.cpp 2000/08/10 18:41:36 1.2
@@ -58,6 +58,10 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include "XercesDOMException.hpp"
#include "XercesDocumentBridge.hpp"
@@ -313,6 +317,30 @@
{
throw XercesDOMException(theException);
}
+}
+
+
+
+bool
+XercesCommentBridge::isIndexed() const
+{
+ return m_navigator.getOwnerDocument()->isIndexed();
+}
+
+
+
+unsigned long
+XercesCommentBridge::getIndex() const
+{
+ return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesCommentBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
}
1.2 +9 -0
xml-xalan/c/src/XercesParserLiaison/XercesCommentBridge.hpp
Index: XercesCommentBridge.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesCommentBridge.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesCommentBridge.hpp 2000/04/11 14:39:29 1.1
+++ XercesCommentBridge.hpp 2000/08/10 18:41:36 1.2
@@ -425,6 +425,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
//@}
// These interfaces are inherited from XalanCDATASection...
1.10 +737 -278
xml-xalan/c/src/XercesParserLiaison/XercesDocumentBridge.cpp
Index: XercesDocumentBridge.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesDocumentBridge.cpp,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- XercesDocumentBridge.cpp 2000/07/21 19:38:31 1.9
+++ XercesDocumentBridge.cpp 2000/08/10 18:41:36 1.10
@@ -72,12 +72,15 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include <XalanDOM/XalanDocumentType.hpp>
#include <XalanDOM/XalanElement.hpp>
-#include "NullTreeWalker.hpp"
#include "XercesAttrBridge.hpp"
#include "XercesCommentBridge.hpp"
#include "XercesCDATASectionBridge.hpp"
@@ -93,6 +96,7 @@
#include "XercesNotationBridge.hpp"
#include "XercesProcessingInstructionBridge.hpp"
#include "XercesTextBridge.hpp"
+#include "XercesTreeWalker.hpp"
@@ -101,32 +105,42 @@
bool buildBridge) :
XalanDocument(),
m_xercesDocument(theXercesDocument),
- m_navigator(this),
+ m_documentElement(0),
m_children(theXercesDocument.getChildNodes(),
m_navigator),
m_cachedNodeLists(theXercesDocument,
m_navigator),
m_nodeMap(),
m_domImplementation(new
XercesDOMImplementationBridge(theXercesDocument.getImplementation())),
- m_navigators(),
+ m_navigators(1, XercesBridgeNavigator(this, !buildBridge)),
+ m_navigator(m_navigators.front()),
m_nodes(),
- m_doctype(0)
+ m_doctype(0),
+ m_mappingMode(!buildBridge),
+ m_indexValid(false)
+#if defined(XALAN_USE_BLOCK_ALLOCATORS)
+ , m_elementAllocator(25),
+ m_textAllocator(25),
+ m_attributeAllocator(25)
+#endif
{
#if !defined(XALAN_NO_NAMESPACES)
using std::make_pair;
#endif
- // Put ourself into the node map, and don't assign an index...
- m_nodeMap.addAssociation(m_xercesDocument, this, false);
-
- m_doctype = buildDocumentTypeBridge();
-
- if (buildBridge == true)
+ if (m_mappingMode == false)
{
+ // The document index is always 1...
+ m_navigator.setIndex(1);
+
// OK, let's build the nodes. This makes things
// thread-safe, so the document can be shared...
buildBridgeNodes();
}
+ else
+ {
+ m_nodeMap.addAssociation(m_xercesDocument, this);
+ }
}
@@ -165,11 +179,11 @@
{
throw
XalanDOMException(XalanDOMException::WRONG_DOCUMENT_ERR);
}
- else
+ else if (m_mappingMode == true)
{
// OK, we haven't yet created a bridge not, so
go ahead and
// create one.
- theXalanNode = createBridgeNode(theHack);
+ theXalanNode = createBridgeNode(theHack, 0,
true);
assert(theXalanNode != 0);
}
}
@@ -234,7 +248,11 @@
XalanAttr*
XercesDocumentBridge::mapNode(const DOM_Attr& theXercesNode) const
{
+#if defined(XALAN_OLD_STYLE_CASTS)
+ return
(XercesAttrBridge*)mapNode(XercesDOM_NodeHack::getImpl(theXercesNode));
+#else
return
static_cast<XercesAttrBridge*>(mapNode(XercesDOM_NodeHack::getImpl(theXercesNode)));
+#endif
}
@@ -242,36 +260,11 @@
XalanElement*
XercesDocumentBridge::mapNode(const DOM_Element& theXercesNode) const
{
+#if defined(XALAN_OLD_STYLE_CASTS)
+ return
(XercesElementBridge*)mapNode(XercesDOM_NodeHack::getImpl(theXercesNode));
+#else
return
static_cast<XercesElementBridge*>(mapNode(XercesDOM_NodeHack::getImpl(theXercesNode)));
-}
-
-
-
-class ClearCacheFunctor
-{
-public:
-
- void
- operator()(XercesBridgeNavigator& theNavigator)
- {
- theNavigator.clearCachedNodes();
- }
-};
-
-
-
-void
-XercesDocumentBridge::clearCachedNodes()
-{
-#if !defined(XALAN_NO_NAMESPACES)
- using std::for_each;
#endif
- // m_bridgeMap contains all of the nodes that
- // are still alive...
- for_each(m_navigators.begin(),
- m_navigators.end(),
- ClearCacheFunctor());
-
}
@@ -282,6 +275,7 @@
#if !defined(XALAN_NO_NAMESPACES)
using std::for_each;
#endif
+
// Set this to null, since it will be deleted
// by the next for_each...
m_doctype = 0;
@@ -292,12 +286,18 @@
m_nodes.end(),
DeleteFunctor<XalanNode>());
- // Clear everything out...
+ // Clear everything out, since we just delete everything...
m_nodes.clear();
- m_navigators.clear();
+ // Clear out all of the navigators, except ours...
+ m_navigators.erase(m_navigators.begin() + 1, m_navigators.end());
+ // Clear the node map...
m_nodeMap.clear();
+
+ m_indexValid = false;
+
+ m_mappingMode = true;
}
@@ -307,53 +307,88 @@
{
destroyBridge();
- // Create the doctype...
- m_doctype = buildDocumentTypeBridge();
-
buildBridgeNodes();
}
-void
-XercesDocumentBridge::buildBridgeNodes()
+XercesBridgeNavigator&
+XercesDocumentBridge::pushNavigator(bool mappingMode) const
{
- // First, build any children of the document...
- const XalanNode* theChild = getFirstChild();
+ XercesDocumentBridge* const This =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (XercesDocumentBridge*)this;
+#else
+ const_cast<XercesDocumentBridge*>(this);
+#endif
- while(theChild != 0)
- {
- // Note that just accessing the sibling is
- // enough to build the bridge nodes...
- theChild = theChild->getNextSibling();
- }
+ This->m_navigators.push_back(XercesBridgeNavigator(This, mappingMode));
- // OK, now walk everything below the document
- // element...
- const XalanNode* const theDocumentElement =
- getDocumentElement();
+ return This->m_navigators.back();
+}
- if (theDocumentElement != 0)
- {
- NullTreeWalker theTreeWalker(true);
+
+
+XercesDocumentTypeBridge*
+XercesDocumentBridge::createBridgeNode(
+ const DOM_DocumentType& theDoctype,
+ unsigned long theIndex,
+ bool
mapNode) const
+{
+ // This is a special case, since there is only one
+ // doctype node allowed...
+ assert(m_doctype == 0);
+ assert(m_xercesDocument.getDoctype().isNull() == false &&
+ m_xercesDocument.getDoctype() == theDoctype);
+
+ // Create a navigator...
+ XercesBridgeNavigator& theNavigator = pushNavigator(mapNode);
+
+ theNavigator.setIndex(theIndex);
+
+ // Update the member variable for the new instance.
+ m_doctype = new XercesDocumentTypeBridge(theDoctype, theNavigator);;
- theTreeWalker.traverse(theDocumentElement, this);
+ if (mapNode == true)
+ {
+ m_nodeMap.addAssociation(theDoctype, m_doctype);
}
+
+ m_nodes.push_back(m_doctype);
+
+ return m_doctype;
}
XercesElementBridge*
-XercesDocumentBridge::createBridgeNode(const DOM_Element& theXercesNode)
const
+XercesDocumentBridge::createBridgeNode(
+ const DOM_Element& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const
{
+ // Create a navigator...
+ XercesBridgeNavigator& theNavigator = pushNavigator(mapNode);
+
+ theNavigator.setIndex(theIndex);
+
XercesElementBridge* const theBridge =
+#if defined(XALAN_USE_BLOCK_ALLOCATORS)
+ m_elementAllocator.create(theXercesNode,
+ theNavigator);
+#else
new XercesElementBridge(theXercesNode,
-
pushNavigator());
+ theNavigator);
- m_nodes.insert(theBridge);
+ m_nodes.push_back(theBridge);
+#endif
- // Add it to the node map...
- m_nodeMap.addAssociation(theXercesNode, theBridge, false);
+ if (m_doctype != 0 || mapNode == true)
+ {
+ // Add it to the node map, since we my need it for getting
+ // elements by ID, or we're in mapping mode.
+ m_nodeMap.addAssociation(theXercesNode, theBridge);
+ }
return theBridge;
}
@@ -361,16 +396,27 @@
XercesDocumentFragmentBridge*
-XercesDocumentBridge::createBridgeNode(const DOM_DocumentFragment&
theXercesNode) const
+XercesDocumentBridge::createBridgeNode(
+ const DOM_DocumentFragment& theXercesNode,
+ unsigned long
theIndex,
+ bool
mapNode) const
{
+ // Create a navigator...
+ XercesBridgeNavigator& theNavigator = pushNavigator(mapNode);
+
+ theNavigator.setIndex(theIndex);
+
XercesDocumentFragmentBridge* const theBridge =
new XercesDocumentFragmentBridge(theXercesNode,
-
pushNavigator());
+
theNavigator);
- m_nodes.insert(theBridge);
+ m_nodes.push_back(theBridge);
- // Add it to the node map...
- m_nodeMap.addAssociation(theXercesNode, theBridge, false);
+ if (mapNode == true)
+ {
+ // Add it to the node map...
+ m_nodeMap.addAssociation(theXercesNode, theBridge);
+ }
return theBridge;
}
@@ -378,16 +424,32 @@
XercesTextBridge*
-XercesDocumentBridge::createBridgeNode(const DOM_Text& theXercesNode)
const
+XercesDocumentBridge::createBridgeNode(
+ const DOM_Text& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const
{
+ // Create a navigator...
+ XercesBridgeNavigator& theNavigator = pushNavigator(mapNode);
+
+ theNavigator.setIndex(theIndex);
+
XercesTextBridge* const theBridge =
+#if defined(XALAN_USE_BLOCK_ALLOCATORS)
+ m_textAllocator.create(theXercesNode,
+ theNavigator);
+#else
new XercesTextBridge(theXercesNode,
- pushNavigator());
+ theNavigator);
- m_nodes.insert(theBridge);
+ m_nodes.push_back(theBridge);
+#endif
- // Add it to the node map...
- m_nodeMap.addAssociation(theXercesNode, theBridge, false);
+ if (mapNode == true)
+ {
+ // Add it to the node map...
+ m_nodeMap.addAssociation(theXercesNode, theBridge);
+ }
return theBridge;
}
@@ -395,16 +457,27 @@
XercesCommentBridge*
-XercesDocumentBridge::createBridgeNode(const DOM_Comment& theXercesNode)
const
+XercesDocumentBridge::createBridgeNode(
+ const DOM_Comment& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const
{
+ // Create a navigator...
+ XercesBridgeNavigator& theNavigator = pushNavigator(mapNode);
+
+ theNavigator.setIndex(theIndex);
+
XercesCommentBridge* const theBridge =
new XercesCommentBridge(theXercesNode,
-
pushNavigator());
+ theNavigator);
- m_nodes.insert(theBridge);
+ m_nodes.push_back(theBridge);
- // Add it to the node map...
- m_nodeMap.addAssociation(theXercesNode, theBridge, false);
+ if (mapNode == true)
+ {
+ // Add it to the node map...
+ m_nodeMap.addAssociation(theXercesNode, theBridge);
+ }
return theBridge;
}
@@ -412,16 +485,27 @@
XercesCDATASectionBridge*
-XercesDocumentBridge::createBridgeNode(const DOM_CDATASection&
theXercesNode) const
+XercesDocumentBridge::createBridgeNode(
+ const DOM_CDATASection& theXercesNode,
+ unsigned long theIndex,
+ bool
mapNode) const
{
+ // Create a navigator...
+ XercesBridgeNavigator& theNavigator = pushNavigator(mapNode);
+
+ theNavigator.setIndex(theIndex);
+
XercesCDATASectionBridge* const theBridge =
new XercesCDATASectionBridge(theXercesNode,
-
pushNavigator());
+
theNavigator);
- m_nodes.insert(theBridge);
+ m_nodes.push_back(theBridge);
- // Add it to the node map...
- m_nodeMap.addAssociation(theXercesNode, theBridge, false);
+ if (mapNode == true)
+ {
+ // Add it to the node map...
+ m_nodeMap.addAssociation(theXercesNode, theBridge);
+ }
return theBridge;
}
@@ -429,16 +513,27 @@
XercesProcessingInstructionBridge*
-XercesDocumentBridge::createBridgeNode(const DOM_ProcessingInstruction&
theXercesNode) const
+XercesDocumentBridge::createBridgeNode(
+ const DOM_ProcessingInstruction& theXercesNode,
+ unsigned long
theIndex,
+ bool
mapNode) const
{
+ // Create a navigator...
+ XercesBridgeNavigator& theNavigator = pushNavigator(mapNode);
+
+ theNavigator.setIndex(theIndex);
+
XercesProcessingInstructionBridge* const theBridge =
new XercesProcessingInstructionBridge(theXercesNode,
-
pushNavigator());
+
theNavigator);
- m_nodes.insert(theBridge);
+ m_nodes.push_back(theBridge);
- // Add it to the node map...
- m_nodeMap.addAssociation(theXercesNode, theBridge, false);
+ if (mapNode == true)
+ {
+ // Add it to the node map...
+ m_nodeMap.addAssociation(theXercesNode, theBridge);
+ }
return theBridge;
}
@@ -446,16 +541,30 @@
XercesAttrBridge*
-XercesDocumentBridge::createBridgeNode(const DOM_Attr& theXercesNode)
const
+XercesDocumentBridge::createBridgeNode(
+ const DOM_Attr& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const
{
+ // Create a navigator...
+ XercesBridgeNavigator& theNavigator = pushNavigator(mapNode);
+
+ theNavigator.setIndex(theIndex);
+
XercesAttrBridge* const theBridge =
+#if defined(XALAN_USE_BLOCK_ALLOCATORS)
+ m_attributeAllocator.create(theXercesNode,
+
theNavigator);
+#else
new XercesAttrBridge(theXercesNode,
- pushNavigator());
+ theNavigator);
- m_nodes.insert(theBridge);
+ m_nodes.push_back(theBridge);
+#endif
- // Add it to the node map...
- m_nodeMap.addAssociation(theXercesNode, theBridge, false);
+ // Add it to the node map -- attributes ALWAYS go in the map
+ // for now...
+ m_nodeMap.addAssociation(theXercesNode, theBridge);
return theBridge;
}
@@ -463,16 +572,25 @@
XercesEntityBridge*
-XercesDocumentBridge::createBridgeNode(const DOM_Entity& theXercesNode)
const
+XercesDocumentBridge::createBridgeNode(
+ const DOM_Entity& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const
{
+ // Create a navigator...
+ XercesBridgeNavigator& theNavigator = pushNavigator(mapNode);
+
+ theNavigator.setIndex(theIndex);
+
XercesEntityBridge* const theBridge =
new XercesEntityBridge(theXercesNode,
- pushNavigator());
+ theNavigator);
- m_nodes.insert(theBridge);
+ m_nodes.push_back(theBridge);
- // Add it to the node map...
- m_nodeMap.addAssociation(theXercesNode, theBridge, false);
+ // Add it to the node map -- entities ALWAYS go in the map
+ // for now...
+ m_nodeMap.addAssociation(theXercesNode, theBridge);
return theBridge;
}
@@ -480,16 +598,27 @@
XercesEntityReferenceBridge*
-XercesDocumentBridge::createBridgeNode(const DOM_EntityReference&
theXercesNode) const
+XercesDocumentBridge::createBridgeNode(
+ const DOM_EntityReference& theXercesNode,
+ unsigned long theIndex,
+ bool
mapNode) const
{
+ // Create a navigator...
+ XercesBridgeNavigator& theNavigator = pushNavigator(mapNode);
+
+ theNavigator.setIndex(theIndex);
+
XercesEntityReferenceBridge* const theBridge =
new XercesEntityReferenceBridge(theXercesNode,
-
pushNavigator());
+
theNavigator);
- m_nodes.insert(theBridge);
+ m_nodes.push_back(theBridge);
- // Add it to the node map...
- m_nodeMap.addAssociation(theXercesNode, theBridge, false);
+ if (mapNode == true)
+ {
+ // Add it to the node map...
+ m_nodeMap.addAssociation(theXercesNode, theBridge);
+ }
return theBridge;
}
@@ -497,27 +626,217 @@
XercesNotationBridge*
-XercesDocumentBridge::createBridgeNode(const DOM_Notation& theXercesNode)
const
+XercesDocumentBridge::createBridgeNode(
+ const DOM_Notation& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const
{
+ // Create a navigator...
+ XercesBridgeNavigator& theNavigator = pushNavigator(mapNode);
+
+ theNavigator.setIndex(theIndex);
+
XercesNotationBridge* const theBridge =
new XercesNotationBridge(theXercesNode,
-
pushNavigator());
+ theNavigator);
- m_nodes.insert(theBridge);
+ m_nodes.push_back(theBridge);
- // Add it to the node map...
- m_nodeMap.addAssociation(theXercesNode, theBridge, false);
+ // Add it to the node map -- notations ALWAYS go in the map
+ // for now...
+ m_nodeMap.addAssociation(theXercesNode, theBridge);
return theBridge;
}
+XalanNode*
+XercesDocumentBridge::createBridgeNode(
+ const DOM_Node& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const
+{
+ XalanNode* theNewNode = 0;
+
+ switch(theXercesNode.getNodeType())
+ {
+ case DOM_Node::ATTRIBUTE_NODE:
+ {
+ const DOM_Attr& theAttrNode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const DOM_Attr&)theXercesNode;
+#else
+ static_cast<const
DOM_Attr&>(theXercesNode);
+#endif
+
+ theNewNode = createBridgeNode(theAttrNode, theIndex,
mapNode);
+ assert(theNewNode != 0);
+ }
+ break;
+
+ case DOM_Node::CDATA_SECTION_NODE:
+ {
+ const DOM_CDATASection& theCDATASectionNode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const
DOM_CDATASection&)theXercesNode;
+#else
+ static_cast<const
DOM_CDATASection&>(theXercesNode);
+#endif
+
+ theNewNode = createBridgeNode(theCDATASectionNode,
theIndex, mapNode);
+ assert(theNewNode != 0);
+
+ }
+ break;
+
+ case DOM_Node::COMMENT_NODE:
+ {
+ const DOM_Comment& theCommentNode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const
DOM_Comment&)theXercesNode;
+#else
+ static_cast<const
DOM_Comment&>(theXercesNode);
+#endif
+
+ theNewNode = createBridgeNode(theCommentNode, theIndex,
mapNode);
+ assert(theNewNode != 0);
+ }
+ break;
+
+ case DOM_Node::DOCUMENT_FRAGMENT_NODE:
+ {
+ const DOM_DocumentFragment&
theDocumentFragmentNode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const
DOM_DocumentFragment&)theXercesNode;
+#else
+ static_cast<const
DOM_DocumentFragment&>(theXercesNode);
+#endif
+
+ theNewNode = createBridgeNode(theDocumentFragmentNode,
theIndex, mapNode);
+ assert(theNewNode != 0);
+
+ }
+ break;
+
+ case DOM_Node::ELEMENT_NODE:
+ {
+ const DOM_Element& theElementNode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const
DOM_Element&)theXercesNode;
+#else
+ static_cast<const
DOM_Element&>(theXercesNode);
+#endif
+
+ theNewNode = createBridgeNode(theElementNode, theIndex,
mapNode);
+ assert(theNewNode != 0);
+ }
+ break;
+
+ case DOM_Node::ENTITY_NODE:
+ {
+ const DOM_Entity& theEntityNode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const
DOM_Entity&)theXercesNode;
+#else
+ static_cast<const
DOM_Entity&>(theXercesNode);
+#endif
+
+ theNewNode = createBridgeNode(theEntityNode, theIndex,
mapNode);
+ assert(theNewNode != 0);
+ }
+ break;
+
+ case DOM_Node::ENTITY_REFERENCE_NODE:
+ {
+ const DOM_EntityReference& theEntityReferenceNode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const
DOM_EntityReference&)theXercesNode;
+#else
+ static_cast<const
DOM_EntityReference&>(theXercesNode);
+#endif
+
+ theNewNode = createBridgeNode(theEntityReferenceNode,
theIndex, mapNode);
+ assert(theNewNode != 0);
+ }
+ break;
+
+ case DOM_Node::NOTATION_NODE:
+ {
+ const DOM_Notation& theNotationNode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const
DOM_Notation&)theXercesNode;
+#else
+ static_cast<const
DOM_Notation&>(theXercesNode);
+#endif
+
+ theNewNode = createBridgeNode(theNotationNode,
theIndex, mapNode);
+ assert(theNewNode != 0);
+ }
+ break;
+
+ case DOM_Node::PROCESSING_INSTRUCTION_NODE:
+ {
+ const DOM_ProcessingInstruction& thePINode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const
DOM_ProcessingInstruction&)theXercesNode;
+#else
+ static_cast<const
DOM_ProcessingInstruction&>(theXercesNode);
+#endif
+
+ theNewNode = createBridgeNode(thePINode, theIndex,
mapNode);
+ assert(theNewNode != 0);
+ }
+ break;
+
+ case DOM_Node::TEXT_NODE:
+ {
+ const DOM_Text& theTextNode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const DOM_Text&)theXercesNode;
+#else
+ static_cast<const
DOM_Text&>(theXercesNode);
+#endif
+
+ theNewNode = createBridgeNode(theTextNode, theIndex,
mapNode);
+ assert(theNewNode != 0);
+ }
+ break;
+
+ case DOM_Node::DOCUMENT_TYPE_NODE:
+ {
+ const DOM_DocumentType& theDoctypeNode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const
DOM_DocumentType&)theXercesNode;
+#else
+ static_cast<const
DOM_DocumentType&>(theXercesNode);
+#endif
+
+ theNewNode = createBridgeNode(theDoctypeNode, theIndex,
mapNode);
+
+ assert(theNewNode != 0);
+ }
+ break;
+
+ default:
+ assert(false);
+ break;
+ }
+
+ return theNewNode;
+}
+
+
+
void
XercesDocumentBridge::destroyNode(XalanNode* theNode)
{
- const NodeSetType::iterator i =
- m_nodes.find(theNode);
+#if !defined(XALAN_NO_NAMESPACES)
+ using std::find;
+#endif
+
+ const NodeVectorType::iterator i =
+ find(m_nodes.begin(), m_nodes.end(), theNode);
if (i == m_nodes.end())
{
@@ -554,7 +873,7 @@
const DOM_Node theNewXercesNode =
theXercesNode.cloneNode(deep);
- theNewNode = createBridgeNode(theNewXercesNode);
+ theNewNode = createBridgeNode(theNewXercesNode, 0, true);
}
catch(const DOM_DOMException& theException)
{
@@ -566,35 +885,6 @@
-XercesDocumentTypeBridge*
-XercesDocumentBridge::buildDocumentTypeBridge() const
-{
- XercesDocumentTypeBridge* theResult = 0;
-
- // Try to build the doctype...
- DOM_DocumentType theDoctype = m_xercesDocument.getDoctype();
-
- if (theDoctype.isNull() == false)
- {
- theResult = new XercesDocumentTypeBridge(theDoctype,
pushNavigator());
-#if defined(XALAN_NO_MUTABLE)
- // Add it to the node map...
-
((XercesDocumentBridge*)this)->m_nodeMap.addAssociation(theDoctype, theResult,
false);
-
- ((XercesDocumentBridge*)this)->m_nodes.insert(theResult);
-#else
- // Add it to the node map...
- m_nodeMap.addAssociation(theDoctype, theResult, false);
-
- m_nodes.insert(theResult);
-#endif
- }
-
- return theResult;
-}
-
-
-
// The rest of these are the standard DOM interfaces...
XalanDOMString
@@ -699,7 +989,11 @@
const DOM_Node theNewDocument =
m_xercesDocument.cloneNode(deep);
theBridge =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ new XercesDocumentBridge((const
DOM_Document&)theNewDocument);
+#else
new XercesDocumentBridge(static_cast<const
DOM_Document&>(theNewDocument));
+#endif
}
catch(const DOM_DOMException& theException)
{
@@ -833,6 +1127,32 @@
+bool
+XercesDocumentBridge::isIndexed() const
+{
+ return m_indexValid;
+}
+
+
+
+unsigned long
+XercesDocumentBridge::getIndex() const
+{
+ assert(m_navigator.getIndex() == 1);
+
+ return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesDocumentBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
+}
+
+
+
XalanElement*
XercesDocumentBridge::createElement(const XalanDOMString& tagName)
{
@@ -844,7 +1164,7 @@
m_xercesDocument.createElement(tagName);
assert(theXercesNode.isNull() == false);
- theBridgeNode = createBridgeNode(theXercesNode);
+ theBridgeNode = createBridgeNode(theXercesNode, 0, true);
assert(mapNode(theXercesNode) == theBridgeNode);
}
catch(const DOM_DOMException& theException)
@@ -868,7 +1188,7 @@
m_xercesDocument.createDocumentFragment();
assert(theXercesNode.isNull() == false);
- theBridgeNode = createBridgeNode(theXercesNode);
+ theBridgeNode = createBridgeNode(theXercesNode, 0, true);
assert(mapNode(theXercesNode) == theBridgeNode);
}
catch(const DOM_DOMException& theException)
@@ -892,7 +1212,7 @@
m_xercesDocument.createTextNode(data);
assert(theXercesNode.isNull() == false);
- theBridgeNode = createBridgeNode(theXercesNode);
+ theBridgeNode = createBridgeNode(theXercesNode, 0, true);
assert(mapNode(theXercesNode) == theBridgeNode);
}
catch(const DOM_DOMException& theException)
@@ -916,7 +1236,7 @@
m_xercesDocument.createComment(data);
assert(theXercesNode.isNull() == false);
- theBridgeNode = createBridgeNode(theXercesNode);
+ theBridgeNode = createBridgeNode(theXercesNode, 0, true);
assert(mapNode(theXercesNode) == theBridgeNode);
}
catch(const DOM_DOMException& theException)
@@ -940,7 +1260,7 @@
m_xercesDocument.createCDATASection(data);
assert(theXercesNode.isNull() == false);
- theBridgeNode = createBridgeNode(theXercesNode);
+ theBridgeNode = createBridgeNode(theXercesNode, 0, true);
assert(mapNode(theXercesNode) == theBridgeNode);
}
catch(const DOM_DOMException& theException)
@@ -966,7 +1286,7 @@
m_xercesDocument.createProcessingInstruction(target,
data);
assert(theXercesNode.isNull() == false);
- theBridgeNode = createBridgeNode(theXercesNode);
+ theBridgeNode = createBridgeNode(theXercesNode, 0, true);
assert(mapNode(theXercesNode) == theBridgeNode);
}
catch(const DOM_DOMException& theException)
@@ -990,7 +1310,7 @@
m_xercesDocument.createAttribute(name);
assert(theXercesNode.isNull() == false);
- theBridgeNode = createBridgeNode(theXercesNode);
+ theBridgeNode = createBridgeNode(theXercesNode, 0, true);
assert(mapNode(theXercesNode) == theBridgeNode);
}
catch(const DOM_DOMException& theException)
@@ -1014,7 +1334,7 @@
m_xercesDocument.createEntityReference(name);
assert(theXercesNode.isNull() == false);
- theBridgeNode = createBridgeNode(theXercesNode);
+ theBridgeNode = createBridgeNode(theXercesNode, 0, true);
assert(mapNode(theXercesNode) == theBridgeNode);
}
catch(const DOM_DOMException& theException)
@@ -1030,31 +1350,6 @@
XalanDocumentType*
XercesDocumentBridge::getDoctype() const
{
- if (m_doctype == 0)
- {
- // Try to build the doctype...
- DOM_DocumentType theDoctype =
m_xercesDocument.getDoctype();
-
- if (theDoctype.isNull() == false)
- {
-#if defined(XALAN_NO_MUTABLE)
- ((XercesDocumentBridge*)this)->m_doctype = new
XercesDocumentTypeBridge(theDoctype, pushNavigator());
-
- // Add it to the node map...
-
((XercesDocumentBridge*)this)->m_nodeMap.addAssociation(theDoctype, m_doctype,
false);
-
-
((XercesDocumentBridge*)this)->m_nodes.insert(m_doctype);
-#else
- m_doctype = new XercesDocumentTypeBridge(theDoctype,
pushNavigator());
-
- // Add it to the node map...
- m_nodeMap.addAssociation(theDoctype, m_doctype, false);
-
- m_nodes.insert(m_doctype);
-#endif
- }
- }
-
return m_doctype;
}
@@ -1072,7 +1367,9 @@
XalanElement*
XercesDocumentBridge::getDocumentElement() const
{
- return mapNode(m_xercesDocument.getDocumentElement());
+ // If we're working in mapping mode, m_documentElement will
+ // be null, so we'll have to map the node...
+ return m_documentElement != 0 ? m_documentElement :
mapNode(m_xercesDocument.getDocumentElement());
}
@@ -1114,7 +1411,7 @@
m_xercesDocument.createElementNS(namespaceURI,
qualifiedName);
assert(theXercesNode.isNull() == false);
- theBridgeNode = createBridgeNode(theXercesNode);
+ theBridgeNode = createBridgeNode(theXercesNode, 0, true);
assert(mapNode(theXercesNode) == theBridgeNode);
}
catch(const DOM_DOMException& theException)
@@ -1140,7 +1437,7 @@
m_xercesDocument.createAttributeNS(namespaceURI,
qualifiedName);
assert(theXercesNode.isNull() == false);
- theBridgeNode = createBridgeNode(theXercesNode);
+ theBridgeNode = createBridgeNode(theXercesNode, 0, true);
assert(mapNode(theXercesNode) == theBridgeNode);
}
catch(const DOM_DOMException& theException)
@@ -1174,143 +1471,305 @@
const DOM_Node
theXercesNode(m_xercesDocument.getElementById(elementId));
#endif
- assert(theXercesNode.isNull() == true ||
- (mapNode(theXercesNode) != 0 &&
- mapNode(theXercesNode)->getNodeType() ==
XalanNode::ELEMENT_NODE));
-
return theXercesNode.isNull() == true ? 0 :
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (XalanElement*)mapNode(theXercesNode);
+#else
static_cast<XalanElement*>(mapNode(theXercesNode));
+#endif
}
-XalanNode*
-XercesDocumentBridge::createBridgeNode(const DOM_Node& theXercesNode)
const
+// Helper class to walk the tree and build everything...
+class BuildBridgeTreeWalker : public XercesTreeWalker
{
- XalanNode* theNewNode = 0;
+public:
- switch(theXercesNode.getNodeType())
+ typedef XercesDocumentBridge::NavigatorBridgeVectorType
NavigatorBridgeVectorType;
+
+ BuildBridgeTreeWalker(
+ XercesDocumentBridge* theDocument,
+ XercesBridgeNavigator* theDocumentNavigator,
+ NavigatorBridgeVectorType& theNavigators,
+ unsigned long theStartIndex);
+
+ virtual
+ ~BuildBridgeTreeWalker();
+
+protected:
+
+ virtual void
+ startNode(const DOM_Node& node);
+
+ virtual void
+ endNode(const DOM_Node& node);
+
+private:
+
+ XercesDocumentBridge* m_document;
+
+ NavigatorBridgeVectorType& m_navigators;
+
+ unsigned long m_currentIndex;
+
+ struct NavigatorStackEntryType
{
- case DOM_Node::ATTRIBUTE_NODE:
+ NavigatorStackEntryType(
+ XercesBridgeNavigator* theNavigator,
+ XalanNode*
theNode) :
+ m_navigator(theNavigator),
+ m_node(theNode)
{
- const DOM_Attr& theAttrNode =
- static_cast<const
DOM_Attr&>(theXercesNode);
-
- theNewNode = createBridgeNode(theAttrNode);
- assert(theNewNode != 0);
}
- break;
- case DOM_Node::CDATA_SECTION_NODE:
- {
- const DOM_CDATASection& theCDATASectionNode =
- static_cast<const
DOM_CDATASection&>(theXercesNode);
+ XercesBridgeNavigator* m_navigator;
- theNewNode = createBridgeNode(theCDATASectionNode);
- assert(theNewNode != 0);
+ XalanNode* m_node;
+ };
- }
- break;
+#if defined(XALAN_NO_NAMESPACES)
+ typedef vector<NavigatorStackEntryType> NavigatorStackType;
+#else
+ typedef std::vector<NavigatorStackEntryType> NavigatorStackType;
+#endif
- case DOM_Node::COMMENT_NODE:
- {
- const DOM_Comment& theCommentNode =
- static_cast<const
DOM_Comment&>(theXercesNode);
+ NavigatorStackType m_parentNavigatorStack;
- theNewNode = createBridgeNode(theCommentNode);
- assert(theNewNode != 0);
- }
- break;
+ NavigatorStackType m_siblingNavigatorStack;
+};
- case DOM_Node::DOCUMENT_FRAGMENT_NODE:
- {
- const DOM_DocumentFragment&
theDocumentFragmentNode =
- static_cast<const
DOM_DocumentFragment&>(theXercesNode);
- theNewNode = createBridgeNode(theDocumentFragmentNode);
- assert(theNewNode != 0);
- }
- break;
+void
+XercesDocumentBridge::buildBridgeNodes()
+{
+ const DOM_Node theStartChild = m_xercesDocument.getFirstChild();
- case DOM_Node::ELEMENT_NODE:
- {
- const DOM_Element& theElementNode =
- static_cast<const
DOM_Element&>(theXercesNode);
+ if (theStartChild.isNull() == false)
+ {
+ assert(m_navigators.back().getIndex() == 1);
+ assert(m_navigators.size() == 1);
- theNewNode = createBridgeNode(theElementNode);
- assert(theNewNode != 0);
- }
- break;
+ BuildBridgeTreeWalker theTreeWalker(
+ this,
+ &m_navigators.back(),
+ m_navigators,
+ 2);
- case DOM_Node::ENTITY_NODE:
- {
- const DOM_Entity& theEntityNode =
- static_cast<const
DOM_Entity&>(theXercesNode);
+ theTreeWalker.traverse(theStartChild, m_xercesDocument);
+ }
- theNewNode = createBridgeNode(theEntityNode);
- assert(theNewNode != 0);
- }
- break;
+ // OK, now set m_documentElement...
+ XalanNode* theChild = m_navigator.getFirstChild();
- case DOM_Node::ENTITY_REFERENCE_NODE:
- {
- const DOM_EntityReference& theEntityReferenceNode =
- static_cast<const
DOM_EntityReference&>(theXercesNode);
+ while(theChild != 0 && theChild->getNodeType() !=
XalanNode::ELEMENT_NODE)
+ {
+ theChild = theChild->getNextSibling();
+ }
- theNewNode = createBridgeNode(theEntityReferenceNode);
- assert(theNewNode != 0);
- }
- break;
+#if defined(XALAN_OLD_STYLE_CASTS)
+ m_documentElement = (XalanElement*)theChild;
+#else
+ m_documentElement = static_cast<XalanElement*>(theChild);
+#endif
- case DOM_Node::NOTATION_NODE:
- {
- const DOM_Notation& theNotationNode =
- static_cast<const
DOM_Notation&>(theXercesNode);
+ m_indexValid = true;
- theNewNode = createBridgeNode(theNotationNode);
- assert(theNewNode != 0);
- }
- break;
+ m_mappingMode = false;
+}
- case DOM_Node::PROCESSING_INSTRUCTION_NODE:
- {
- const DOM_ProcessingInstruction& thePINode =
- static_cast<const
DOM_ProcessingInstruction&>(theXercesNode);
- theNewNode = createBridgeNode(thePINode);
- assert(theNewNode != 0);
+
+BuildBridgeTreeWalker::BuildBridgeTreeWalker(
+ XercesDocumentBridge* theDocument,
+ XercesBridgeNavigator* theDocumentNavigator,
+ NavigatorBridgeVectorType& theNavigators,
+ unsigned long theStartIndex) :
+ m_document(theDocument),
+ m_navigators(theNavigators),
+ m_currentIndex(theStartIndex),
+ m_parentNavigatorStack(),
+ m_siblingNavigatorStack()
+{
+ assert(theDocument != 0 && theDocumentNavigator != 0);
+
+ // Reserve some space...
+ m_parentNavigatorStack.reserve(100);
+ m_parentNavigatorStack.reserve(100);
+
+ // The document navigator is the last navigator on the stack...
+
m_parentNavigatorStack.push_back(NavigatorStackEntryType(theDocumentNavigator,
theDocument));
+
+ // There is no previous sibling...
+ m_siblingNavigatorStack.push_back(NavigatorStackEntryType(0, 0));
+}
+
+
+
+BuildBridgeTreeWalker::~BuildBridgeTreeWalker()
+{
+}
+
+
+
+void
+BuildBridgeTreeWalker::startNode(const DOM_Node& node)
+{
+ XalanNode* const theBridgeNode =
m_document->createBridgeNode(node, m_currentIndex, false);
+
+ XercesBridgeNavigator& theCurrentNodeNavigator = m_navigators.back();
+
+ assert(m_parentNavigatorStack.empty() == false);
+ assert(m_siblingNavigatorStack.empty() == false);
+
+ // Get the two navigators...
+ NavigatorStackEntryType& theParentEntry =
m_parentNavigatorStack.back();
+ NavigatorStackEntryType& theSiblingEntry =
m_siblingNavigatorStack.back();
+
+ theCurrentNodeNavigator.setParentNode(theParentEntry.m_node);
+
+ // If the first child has not been set, then set it
+ // now...
+ if (theParentEntry.m_navigator->getFirstChild() == 0)
+ {
+ assert(theSiblingEntry.m_node == 0);
+
+ theParentEntry.m_navigator->setFirstChild(theBridgeNode);
+ }
+
+ // Always set the last child...
+ theParentEntry.m_navigator->setLastChild(theBridgeNode);
+
+ theCurrentNodeNavigator.setPreviousSibling(theSiblingEntry.m_node);
+
+ if (theSiblingEntry.m_navigator != 0)
+ {
+ theSiblingEntry.m_navigator->setNextSibling(theBridgeNode);
+ }
+
+ // Build an entry for the stacks...
+ const NavigatorStackEntryType
theCurrentEntry(&theCurrentNodeNavigator, theBridgeNode);
+
+ // My child nodes will now be visited, so push the current
+ // context on the parent stack...
+ m_parentNavigatorStack.push_back(theCurrentEntry);
+
+ // My siblings will also need to know about me as well...
+ m_siblingNavigatorStack.push_back(theCurrentEntry);
+
+ // This will serve to mark the sibling context for my first child,
+ // since it has no previous sibling. This will be popped off
+ // when endNode() is called.
+ m_siblingNavigatorStack.push_back(NavigatorStackEntryType(0, 0));
+
+ // Finally, increment the index counter...
+ ++m_currentIndex;
+
+ const short theType = node.getNodeType();
+
+ if (theType == DOM_Node::DOCUMENT_TYPE_NODE)
+ {
+ // Special case for doctype -- we have to build its entities...
+ const DOM_DocumentType& theDoctype =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const DOM_DocumentType&)node;
+#else
+ static_cast<const DOM_DocumentType&>(node);
+#endif
+
+ const DOM_NamedNodeMap theEntities =
+ theDoctype.getEntities();
+
+ const unsigned int theLength =
+ theEntities.getLength();
+
+ for (unsigned int i = 0; i < theLength; ++i)
+ {
+ // Build it, but don't index it...
+ m_document->createBridgeNode(theEntities.item(i),
m_currentIndex++, true);
}
- break;
+ }
+ else if (theType == DOM_Node::ELEMENT_NODE)
+ {
+ // Special case for element nodes -- we have to build the attributes...
+ const DOM_Element& theElement =
+#if defined(XALAN_OLD_STYLE_CASTS)
+ (const DOM_Element&)node;
+#else
+ static_cast<const DOM_Element&>(node);
+#endif
- case DOM_Node::TEXT_NODE:
+ const DOM_NamedNodeMap theAttributes =
+ theElement.getAttributes();
+
+ const unsigned int theLength =
+ theAttributes.getLength();
+
+ XercesBridgeNavigator* thePreviousAttrNavigator = 0;
+ XalanNode* thePreviousAttr = 0;
+
+ for (unsigned int i = 0; i < theLength; ++i)
{
- const DOM_Text& theTextNode =
- static_cast<const
DOM_Text&>(theXercesNode);
+ // Get the attribute from the node map...
+ const DOM_Node theAttr = theAttributes.item(i);
+ assert(theAttr.isNull() == false);
+
+ // Create a bridge node.
+ XalanNode* const theCurrentAttr =
+ m_document->createBridgeNode(theAttr,
m_currentIndex, false);
+ assert(theCurrentAttr != 0);
+
+ // Get the attribute node's navigator...
+ XercesBridgeNavigator& theCurrentAttrNavigator =
+ m_navigators.back();
- theNewNode = createBridgeNode(theTextNode);
- assert(theNewNode != 0);
- }
- break;
+ // Set the parent node...
+ theCurrentAttrNavigator.setParentNode(theBridgeNode);
- default:
- assert(false);
- break;
- }
+ if (thePreviousAttr != 0)
+ {
+ assert(thePreviousAttrNavigator != 0);
- return theNewNode;
+ // Link in the previous attribute...
+
theCurrentAttrNavigator.setPreviousSibling(thePreviousAttr);
+
+
thePreviousAttrNavigator->setNextSibling(theCurrentAttr);
+ }
+
+ // Update the pointers so they point to this
attribute...
+ thePreviousAttr = theCurrentAttr;
+ thePreviousAttrNavigator = &theCurrentAttrNavigator;
+
+ // Finally, increment the index...
+ ++m_currentIndex;
+ }
+ }
}
-const XercesBridgeNavigator&
-XercesDocumentBridge::pushNavigator() const
+void
+BuildBridgeTreeWalker::endNode(const DOM_Node& /* node */)
{
- XercesDocumentBridge* const This =
- const_cast<XercesDocumentBridge*>(this);
+ assert(m_parentNavigatorStack.empty() == false);
+ assert(m_siblingNavigatorStack.empty() == false);
- m_navigators.push_back(XercesBridgeNavigator(This));
+ // I have to pop my entry, since my children are finished...
+ m_parentNavigatorStack.pop_back();
- return m_navigators.back();
-}
+ // Pop any sibling navigators my child pushed...
+ while(m_siblingNavigatorStack.back().m_navigator != 0)
+ {
+ assert(m_siblingNavigatorStack.back().m_node != 0);
+ m_siblingNavigatorStack.pop_back();
+ }
+
+ // There must be a context marker...
+ assert(m_siblingNavigatorStack.back().m_navigator == 0 &&
+ m_siblingNavigatorStack.back().m_node == 0);
+
+ // Pop the context marker...
+ m_siblingNavigatorStack.pop_back();
+}
1.5 +107 -38
xml-xalan/c/src/XercesParserLiaison/XercesDocumentBridge.hpp
Index: XercesDocumentBridge.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesDocumentBridge.hpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- XercesDocumentBridge.hpp 2000/07/21 19:38:31 1.4
+++ XercesDocumentBridge.hpp 2000/08/10 18:41:36 1.5
@@ -66,6 +66,7 @@
#include <deque>
#include <memory>
#include <set>
+#include <vector>
@@ -77,11 +78,23 @@
+#include <DOMSupport/TreeWalker.hpp>
+
+
+
#include <XercesParserLiaison/XercesToXalanNodeMap.hpp>
#include <XercesParserLiaison/XercesBridgeNavigator.hpp>
#include <XercesParserLiaison/XercesDocumentNamedNodeListCache.hpp>
#include <XercesParserLiaison/XercesNodeListBridge.hpp>
+//#define XALAN_USE_BLOCK_ALLOCATORS
+
+#if defined(XALAN_USE_BLOCK_ALLOCATORS)
+#include <XercesParserLiaison/XercesElementBridgeAllocator.hpp>
+#include <XercesParserLiaison/XercesTextBridgeAllocator.hpp>
+#include <XercesParserLiaison/XercesAttributeBridgeAllocator.hpp>
+#endif
+
class XalanDOMImplementation;
@@ -210,6 +223,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
virtual XalanElement*
createElement(const XalanDOMString& tagName);
@@ -271,6 +293,7 @@
virtual XalanElement*
getElementById(const XalanDOMString& elementId) const;
+
// These are some special interfaces to manage relationships between
// our nodes and Xerces nodes.
@@ -293,35 +316,24 @@
void
rebuildBridge();
- /**
- * Clears any node relationships that may have been
- * cached. This should be done if the document is
- * modified in any way.
- */
- void
- clearCachedNodes();
-
XalanNode*
mapNode(const DOM_Node& theXercesNode) const;
+ XalanAttr*
+ mapNode(const DOM_Attr& theXercesNode) const;
+
+ XalanElement*
+ mapNode(const DOM_Element& theXercesNode) const;
+
DOM_Node
mapNode(const XalanNode* theXalanNode) const;
- XalanNode*
- mapNode(NodeImpl* theXercesNodeImpl) const;
-
DOM_Attr
mapNode(const XalanAttr* theXalanNode) const;
NodeImpl*
mapNodeToImpl(const XalanNode* theXalanNode) const;
- XalanAttr*
- mapNode(const DOM_Attr& theXercesNode) const;
-
- XalanElement*
- mapNode(const DOM_Element& theXercesNode) const;
-
/**
*
* Get the Xerces DOM_Document that this XercesDocument represents.
@@ -348,6 +360,9 @@
private:
+ XalanNode*
+ mapNode(NodeImpl* theXercesNodeImpl) const;
+
// Destruction API...
void
destroyBridgeNode(XalanNode* theNode);
@@ -372,52 +387,90 @@
const DOM_Node& theXercesNode,
bool deep);
- // Convenience function to build the Doctype node...
- XercesDocumentTypeBridge*
- buildDocumentTypeBridge() const;
-
// Factory methods for our implementation nodes...
XalanNode*
- createBridgeNode(const DOM_Node& theXercesNode) const;
+ createBridgeNode(
+ const DOM_Node& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const;
+
+ XercesDocumentTypeBridge*
+ createBridgeNode(
+ const DOM_DocumentType& theDoctype,
+ unsigned long theIndex,
+ bool
mapNode) const;
XercesElementBridge*
- createBridgeNode(const DOM_Element& theXercesNode) const;
+ createBridgeNode(
+ const DOM_Element& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const;
XercesDocumentFragmentBridge*
- createBridgeNode(const DOM_DocumentFragment& theXercesNode) const;
+ createBridgeNode(
+ const DOM_DocumentFragment& theXercesNode,
+ unsigned long
theIndex,
+ bool
mapNode) const;
XercesTextBridge*
- createBridgeNode(const DOM_Text& theXercesNode) const;
+ createBridgeNode(
+ const DOM_Text& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const;
XercesCommentBridge*
- createBridgeNode(const DOM_Comment& theXercesNode) const;
+ createBridgeNode(
+ const DOM_Comment& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const;
XercesCDATASectionBridge*
- createBridgeNode(const DOM_CDATASection& theXercesNode) const;
+ createBridgeNode(
+ const DOM_CDATASection& theXercesNode,
+ unsigned long theIndex,
+ bool
mapNode) const;
XercesProcessingInstructionBridge*
- createBridgeNode(const DOM_ProcessingInstruction& theXercesNode)
const;
+ createBridgeNode(
+ const DOM_ProcessingInstruction& theXercesNode,
+ unsigned long
theIndex,
+ bool
mapNode) const;
XercesAttrBridge*
- createBridgeNode(const DOM_Attr& theXercesNode) const;
+ createBridgeNode(
+ const DOM_Attr& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const;
XercesEntityBridge*
- createBridgeNode(const DOM_Entity& theXercesNode) const;
+ createBridgeNode(
+ const DOM_Entity& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const;
XercesEntityReferenceBridge*
- createBridgeNode(const DOM_EntityReference& theXercesNode)
const;
+ createBridgeNode(
+ const DOM_EntityReference& theXercesNode,
+ unsigned long theIndex,
+ bool
mapNode) const;
XercesNotationBridge*
- createBridgeNode(const DOM_Notation& theXercesNode) const;
+ createBridgeNode(
+ const DOM_Notation& theXercesNode,
+ unsigned long theIndex,
+ bool mapNode) const;
- const XercesBridgeNavigator&
- pushNavigator() 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
m_xercesDocument;
- XercesBridgeNavigator m_navigator;
+ XalanElement*
m_documentElement;
XercesNodeListBridge m_children;
@@ -430,20 +483,36 @@
typedef deque<XercesBridgeNavigator> NavigatorBridgeVectorType;
- typedef set<XalanNode*> NodeSetType;
+ typedef deque<XalanNode*> NodeVectorType;
#else
std::auto_ptr<XalanDOMImplementation> m_domImplementation;
typedef std::deque<XercesBridgeNavigator>
NavigatorBridgeVectorType;
- typedef std::set<XalanNode*> NodeSetType;
+ typedef std::deque<XalanNode*> NodeVectorType;
#endif
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;
- mutable NodeSetType m_nodes;
+ mutable NodeVectorType m_nodes;
mutable XercesDocumentTypeBridge* m_doctype;
+
+ bool
m_mappingMode;
+
+ bool
m_indexValid;
+
+#if defined(XALAN_USE_BLOCK_ALLOCATORS)
+ mutable XercesElementBridgeAllocator m_elementAllocator;
+
+ mutable XercesTextBridgeAllocator m_textAllocator;
+
+ mutable XercesAttributeBridgeAllocator m_attributeAllocator;
+#endif
};
1.3 +34 -0
xml-xalan/c/src/XercesParserLiaison/XercesDocumentFragmentBridge.cpp
Index: XercesDocumentFragmentBridge.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesDocumentFragmentBridge.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- XercesDocumentFragmentBridge.cpp 2000/05/03 18:42:11 1.2
+++ XercesDocumentFragmentBridge.cpp 2000/08/10 18:41:36 1.3
@@ -62,6 +62,10 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include "XercesDOMException.hpp"
#include "XercesDocumentBridge.hpp"
@@ -311,4 +315,34 @@
{
throw XercesDOMException(theException);
}
+}
+
+
+
+bool
+XercesDocumentFragmentBridge::isIndexed() const
+{
+ // $$$ ToDo: Are document fragments ever indexed?
+ // I don't think so...
+ return false;
+
+// return m_navigator.getOwnerDocument()->isIndexed();
+}
+
+
+
+unsigned long
+XercesDocumentFragmentBridge::getIndex() const
+{
+ return 0;
+
+// return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesDocumentFragmentBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
}
1.2 +9 -0
xml-xalan/c/src/XercesParserLiaison/XercesDocumentFragmentBridge.hpp
Index: XercesDocumentFragmentBridge.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesDocumentFragmentBridge.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesDocumentFragmentBridge.hpp 2000/04/11 14:39:29 1.1
+++ XercesDocumentFragmentBridge.hpp 2000/08/10 18:41:36 1.2
@@ -429,6 +429,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
//@}
private:
1.3 +28 -0
xml-xalan/c/src/XercesParserLiaison/XercesDocumentTypeBridge.cpp
Index: XercesDocumentTypeBridge.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesDocumentTypeBridge.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- XercesDocumentTypeBridge.cpp 2000/05/03 18:42:12 1.2
+++ XercesDocumentTypeBridge.cpp 2000/08/10 18:41:36 1.3
@@ -58,6 +58,10 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include "XercesDOMException.hpp"
#include "XercesDocumentBridge.hpp"
@@ -321,6 +325,30 @@
{
throw XercesDOMException(theException);
}
+}
+
+
+
+bool
+XercesDocumentTypeBridge::isIndexed() const
+{
+ return m_navigator.getOwnerDocument()->isIndexed();
+}
+
+
+
+unsigned long
+XercesDocumentTypeBridge::getIndex() const
+{
+ return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesDocumentTypeBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
}
1.2 +9 -0
xml-xalan/c/src/XercesParserLiaison/XercesDocumentTypeBridge.hpp
Index: XercesDocumentTypeBridge.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesDocumentTypeBridge.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesDocumentTypeBridge.hpp 2000/04/11 14:39:29 1.1
+++ XercesDocumentTypeBridge.hpp 2000/08/10 18:41:37 1.2
@@ -430,6 +430,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
//@}
// These interfaces are inherited from XalanDocumentType...
1.2 +28 -0
xml-xalan/c/src/XercesParserLiaison/XercesElementBridge.cpp
Index: XercesElementBridge.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesElementBridge.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesElementBridge.cpp 2000/04/11 14:39:29 1.1
+++ XercesElementBridge.cpp 2000/08/10 18:41:37 1.2
@@ -62,6 +62,10 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include "XercesDOMException.hpp"
#include "XercesBridgeNavigator.hpp"
#include "XercesDocumentBridge.hpp"
@@ -316,6 +320,30 @@
{
throw XercesDOMException(theException);
}
+}
+
+
+
+bool
+XercesElementBridge::isIndexed() const
+{
+ return m_navigator.getOwnerDocument()->isIndexed();
+}
+
+
+
+unsigned long
+XercesElementBridge::getIndex() const
+{
+ return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesElementBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
}
1.2 +9 -0
xml-xalan/c/src/XercesParserLiaison/XercesElementBridge.hpp
Index: XercesElementBridge.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesElementBridge.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesElementBridge.hpp 2000/04/11 14:39:29 1.1
+++ XercesElementBridge.hpp 2000/08/10 18:41:37 1.2
@@ -436,6 +436,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
//@}
// These interfaces are inherited from XalanElement...
1.3 +28 -0
xml-xalan/c/src/XercesParserLiaison/XercesEntityBridge.cpp
Index: XercesEntityBridge.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesEntityBridge.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- XercesEntityBridge.cpp 2000/05/03 18:41:10 1.2
+++ XercesEntityBridge.cpp 2000/08/10 18:41:37 1.3
@@ -58,6 +58,10 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include "XercesBridgeNavigator.hpp"
#include "XercesDOMException.hpp"
#include "XercesDocumentBridge.hpp"
@@ -308,6 +312,30 @@
{
throw XercesDOMException(theException);
}
+}
+
+
+
+bool
+XercesEntityBridge::isIndexed() const
+{
+ return m_navigator.getOwnerDocument()->isIndexed();
+}
+
+
+
+unsigned long
+XercesEntityBridge::getIndex() const
+{
+ return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesEntityBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
}
1.3 +9 -0
xml-xalan/c/src/XercesParserLiaison/XercesEntityBridge.hpp
Index: XercesEntityBridge.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesEntityBridge.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- XercesEntityBridge.hpp 2000/05/03 18:41:11 1.2
+++ XercesEntityBridge.hpp 2000/08/10 18:41:38 1.3
@@ -429,6 +429,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
//@}
// These interfaces are inherited from XalanEntity...
1.2 +28 -0
xml-xalan/c/src/XercesParserLiaison/XercesEntityReferenceBridge.cpp
Index: XercesEntityReferenceBridge.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesEntityReferenceBridge.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesEntityReferenceBridge.cpp 2000/04/11 14:39:30 1.1
+++ XercesEntityReferenceBridge.cpp 2000/08/10 18:41:38 1.2
@@ -58,6 +58,10 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include "XercesDOMException.hpp"
#include "XercesDocumentBridge.hpp"
@@ -308,4 +312,28 @@
{
throw XercesDOMException(theException);
}
+}
+
+
+
+bool
+XercesEntityReferenceBridge::isIndexed() const
+{
+ return m_navigator.getOwnerDocument()->isIndexed();
+}
+
+
+
+unsigned long
+XercesEntityReferenceBridge::getIndex() const
+{
+ return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesEntityReferenceBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
}
1.2 +9 -0
xml-xalan/c/src/XercesParserLiaison/XercesEntityReferenceBridge.hpp
Index: XercesEntityReferenceBridge.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesEntityReferenceBridge.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesEntityReferenceBridge.hpp 2000/04/11 14:39:30 1.1
+++ XercesEntityReferenceBridge.hpp 2000/08/10 18:41:38 1.2
@@ -429,6 +429,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
//@}
private:
1.2 +28 -0
xml-xalan/c/src/XercesParserLiaison/XercesNotationBridge.cpp
Index: XercesNotationBridge.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesNotationBridge.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesNotationBridge.cpp 2000/04/11 14:39:30 1.1
+++ XercesNotationBridge.cpp 2000/08/10 18:41:38 1.2
@@ -58,6 +58,10 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include "XercesDOMException.hpp"
#include "XercesDocumentBridge.hpp"
@@ -305,6 +309,30 @@
{
throw XercesDOMException(theException);
}
+}
+
+
+
+bool
+XercesNotationBridge::isIndexed() const
+{
+ return m_navigator.getOwnerDocument()->isIndexed();
+}
+
+
+
+unsigned long
+XercesNotationBridge::getIndex() const
+{
+ return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesNotationBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
}
1.2 +9 -0
xml-xalan/c/src/XercesParserLiaison/XercesNotationBridge.hpp
Index: XercesNotationBridge.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesNotationBridge.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesNotationBridge.hpp 2000/04/11 14:39:30 1.1
+++ XercesNotationBridge.hpp 2000/08/10 18:41:39 1.2
@@ -425,6 +425,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
//@}
// These interfaces are inherited from XalanNotation...
1.14 +6 -4
xml-xalan/c/src/XercesParserLiaison/XercesParserLiaison.cpp
Index: XercesParserLiaison.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesParserLiaison.cpp,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -r1.13 -r1.14
--- XercesParserLiaison.cpp 2000/07/21 19:28:25 1.13
+++ XercesParserLiaison.cpp 2000/08/10 18:41:39 1.14
@@ -96,7 +96,7 @@
m_shouldExpandEntityRefs(false),
m_useValidation(false),
m_includeIgnorableWhitespace(true),
- m_doNamespaces(false),
+ m_doNamespaces(true),
m_exitOnFirstFatalError(true),
m_entityResolver(0),
m_errorHandler(this),
@@ -414,7 +414,7 @@
const DocumentMapType::const_iterator i =
m_documentMap.find(theDocument);
- return i != m_documentMap.end() ? i->second : 0;
+ return i != m_documentMap.end() ? (*i).second : 0;
}
@@ -425,7 +425,7 @@
const DocumentMapType::const_iterator i =
m_documentMap.find(theDocument);
- return i != m_documentMap.end() ? i->second->getXercesDocument() :
DOM_Document();
+ return i != m_documentMap.end() ? (*i).second->getXercesDocument() :
DOM_Document();
}
@@ -516,7 +516,9 @@
theParser->setDoValidation(m_useValidation);
- theParser->setDoNamespaces(m_doNamespaces);
+ // $$$ ToDo: For the time being, we cannot process namespaces
+ // with SAX due to the age of Xerces' SAX interfaces.
+// theParser->setDoNamespaces(m_doNamespaces);
theParser->setExitOnFirstFatalError(m_exitOnFirstFatalError);
1.2 +28 -0
xml-xalan/c/src/XercesParserLiaison/XercesProcessingInstructionBridge.cpp
Index: XercesProcessingInstructionBridge.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesProcessingInstructionBridge.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesProcessingInstructionBridge.cpp 2000/04/11 14:39:30 1.1
+++ XercesProcessingInstructionBridge.cpp 2000/08/10 18:41:39 1.2
@@ -58,6 +58,10 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include "XercesDOMException.hpp"
#include "XercesDocumentBridge.hpp"
@@ -313,6 +317,30 @@
{
throw XercesDOMException(theException);
}
+}
+
+
+
+bool
+XercesProcessingInstructionBridge::isIndexed() const
+{
+ return m_navigator.getOwnerDocument()->isIndexed();
+}
+
+
+
+unsigned long
+XercesProcessingInstructionBridge::getIndex() const
+{
+ return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesProcessingInstructionBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
}
1.2 +9 -0
xml-xalan/c/src/XercesParserLiaison/XercesProcessingInstructionBridge.hpp
Index: XercesProcessingInstructionBridge.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesProcessingInstructionBridge.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesProcessingInstructionBridge.hpp 2000/04/11 14:39:30 1.1
+++ XercesProcessingInstructionBridge.hpp 2000/08/10 18:41:39 1.2
@@ -425,6 +425,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
//@}
// These interfaces are inherited from XalanProcessingInstruction...
1.2 +36 -0 xml-xalan/c/src/XercesParserLiaison/XercesTextBridge.cpp
Index: XercesTextBridge.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesTextBridge.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesTextBridge.cpp 2000/04/11 14:39:30 1.1
+++ XercesTextBridge.cpp 2000/08/10 18:41:39 1.2
@@ -62,6 +62,10 @@
+#include <DOMSupport/DOMServices.hpp>
+
+
+
#include "XercesBridgeNavigator.hpp"
#include "XercesDOMException.hpp"
#include "XercesDocumentBridge.hpp"
@@ -324,6 +328,30 @@
+bool
+XercesTextBridge::isIndexed() const
+{
+ return m_navigator.getOwnerDocument()->isIndexed();
+}
+
+
+
+unsigned long
+XercesTextBridge::getIndex() const
+{
+ return m_navigator.getIndex();
+}
+
+
+
+XalanDOMString
+XercesTextBridge::getXSLTData() const
+{
+ return DOMServices::getNodeData(*this);
+}
+
+
+
XalanDOMString
XercesTextBridge::getData() const
{
@@ -428,4 +456,12 @@
XercesTextBridge::splitText(unsigned int offset)
{
return m_navigator.splitText(m_xercesNode, offset);
+}
+
+
+
+bool
+XercesTextBridge::isIgnorableWhitespace() const
+{
+ return isWhiteSpace(m_xercesNode.getData());
}
1.2 +13 -0 xml-xalan/c/src/XercesParserLiaison/XercesTextBridge.hpp
Index: XercesTextBridge.hpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesTextBridge.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XercesTextBridge.hpp 2000/04/11 14:39:30 1.1
+++ XercesTextBridge.hpp 2000/08/10 18:41:39 1.2
@@ -422,6 +422,15 @@
virtual void
setPrefix(const XalanDOMString& prefix);
+ virtual bool
+ isIndexed() const;
+
+ virtual unsigned long
+ getIndex() const;
+
+ virtual XalanDOMString
+ getXSLTData() const;
+
//@}
// These interfaces are inherited from XalanCDATASection...
@@ -579,6 +588,10 @@
splitText(unsigned int offset);
//@}
+
+ virtual bool
+ isIgnorableWhitespace() const;
+
private:
// Not implemented...
1.4 +46 -59
xml-xalan/c/src/XercesParserLiaison/XercesToXalanNodeMap.cpp
Index: XercesToXalanNodeMap.cpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesToXalanNodeMap.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- XercesToXalanNodeMap.cpp 2000/07/21 19:27:44 1.3
+++ XercesToXalanNodeMap.cpp 2000/08/10 18:41:39 1.4
@@ -60,6 +60,7 @@
#include <algorithm>
#include <cassert>
+#include <functional>
@@ -74,8 +75,7 @@
XercesToXalanNodeMap::XercesToXalanNodeMap() :
m_xalanMap(),
- m_xercesMap(),
- m_counter(0)
+ m_xercesMap()
{
}
@@ -90,40 +90,18 @@
void
XercesToXalanNodeMap::addAssociation(
const DOM_Node& theXercesNode,
- XalanNode* theXalanNode,
- bool fAssignIndex)
+ XalanNode* theXalanNode)
{
- // Space the indices, just in case nodes are
- // added. With any luck, we may not need to
- // reindex the nodes.
- const unsigned long theIncrement = 5;
-
NodeImpl* const theImpl =
XercesDOM_NodeHack::getImpl(theXercesNode);
m_xercesMap.insert(XercesNodeMapType::value_type(theImpl,
theXalanNode));
+ // Keeping two-way indexes is very memory consumptive, and we don't
+ // need it now...
+#if defined(XERCES_PARSER_LIASON_FAST_TWO_WAY_MAPPING)
try
{
- // Unindexed nodes are assigned an index of 0.
- unsigned long theIndex = 0;
-
- // Have we been told to assign an index?
- if (fAssignIndex == true)
- {
- // Never index attribute nodes or their childern...
- if (theXalanNode->getNodeType() !=
XalanNode::ATTRIBUTE_NODE)
- {
- const XalanNode* const theParent =
- theXalanNode->getParentNode();
-
- if (theParent == 0 || theParent->getNodeType()
!= XalanNode::ATTRIBUTE_NODE)
- {
- theIndex = m_counter += theIncrement;
- }
- }
- }
-
- m_xalanMap.insert(XalanNodeMapType::value_type(theXalanNode,
XalanNodeMapEntryType(theImpl, theIndex)));
+ m_xalanMap.insert(XalanNodeMapType::value_type(theXalanNode,
theImpl));
}
catch(...)
{
@@ -131,6 +109,7 @@
throw;
}
+#endif
}
@@ -140,47 +119,55 @@
{
m_xalanMap.clear();
m_xercesMap.clear();
-
- m_counter = 0;
}
+
+#if !defined(XERCES_PARSER_LIASON_FAST_TWO_WAY_MAPPING)
-bool
-XercesToXalanNodeMap::isNodeAfter(
- const XalanNode* theFirstXalanNode,
- const XalanNode* theSecondXalanNode) const
+// I should be able to make this out of a
+// bunch of compose<> and select2nd<> adapters...
+
+class NameMapEqualsFunctor
{
- assert(theFirstXalanNode != 0);
- assert(theSecondXalanNode != 0);
- assert(theFirstXalanNode->getOwnerDocument() ==
theSecondXalanNode->getOwnerDocument());
+public:
+
+ NameMapEqualsFunctor(const XalanNode* theXalanNode) :
+ m_value(theXalanNode)
+ {
+ }
+
+ bool
+ operator()(const XercesToXalanNodeMap::XercesNodeMapType::value_type&
thePair) const
+ {
+ return m_value == thePair.second;
+ }
+
+private:
+
+ const XalanNode* m_value;
+};
+
- bool fResult = false;
- const XalanNodeMapType::const_iterator i =
- m_xalanMap.find(theFirstXalanNode);
+NodeImpl*
+XercesToXalanNodeMap::getNodeImpl(const XalanNode* theXalanNode) const
+{
+ using std::find_if;
+
+ const XercesNodeMapType::const_iterator i =
+ find_if(m_xercesMap.begin(),
+ m_xercesMap.end(),
+ NameMapEqualsFunctor(theXalanNode));
- if (i == m_xalanMap.end())
+ if (i != m_xercesMap.end())
{
- throw
XalanDOMException(XalanDOMException::HIERARCHY_REQUEST_ERR);
+ return (*i).first;
}
else
{
- const XalanNodeMapType::const_iterator j =
- m_xalanMap.find(theSecondXalanNode);
-
- if (i == m_xalanMap.end())
- {
- throw
XalanDOMException(XalanDOMException::HIERARCHY_REQUEST_ERR);
- }
- else
- {
- if (i->second.m_index > j->second.m_index)
- {
- fResult = true;
- }
- }
+ return 0;
}
-
- return fResult;
}
+
+#endif
1.4 +19 -32
xml-xalan/c/src/XercesParserLiaison/XercesToXalanNodeMap.hpp
Index: XercesToXalanNodeMap.hpp
===================================================================
RCS file:
/home/cvs/xml-xalan/c/src/XercesParserLiaison/XercesToXalanNodeMap.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- XercesToXalanNodeMap.hpp 2000/05/11 19:04:31 1.3
+++ XercesToXalanNodeMap.hpp 2000/08/10 18:41:39 1.4
@@ -91,8 +91,7 @@
void
addAssociation(
const DOM_Node& theXercesNode,
- XalanNode* theXalanNode,
- bool fAssignIndex);
+ XalanNode* theXalanNode);
void
clear();
@@ -104,7 +103,7 @@
}
XalanNode*
- getNode(const NodeImpl* theXercesNodeImpl) const
+ getNode(NodeImpl* theXercesNodeImpl) const
{
const XercesNodeMapType::const_iterator i =
m_xercesMap.find(theXercesNodeImpl);
@@ -115,7 +114,7 @@
}
else
{
- return i->second;
+ return (*i).second;
}
}
@@ -125,6 +124,8 @@
return XercesDOM_NodeHack(getNodeImpl(theXalanNode));
}
+#if defined(XERCES_PARSER_LIASON_FAST_TWO_WAY_MAPPING)
+
NodeImpl*
getNodeImpl(const XalanNode* theXalanNode) const
{
@@ -137,51 +138,37 @@
}
else
{
- return i->second.m_xercesNode;
+ return (*i).second;
}
}
+#else
+
NodeImpl*
+ getNodeImpl(const XalanNode* theXalanNode) const;
+
+#endif
+
+ NodeImpl*
getNodeImpl(const DOM_Node& theXercesNode) const
{
return XercesDOM_NodeHack::getImpl(theXercesNode);
}
- bool
- isNodeAfter(
- const XalanNode* theFirstXercesNode,
- const XalanNode* theSecondXercesNode) const;
-
-private:
-
- struct XalanNodeMapEntryType
- {
- XalanNodeMapEntryType(
- NodeImpl* theXercesNode = 0,
- unsigned long theIndex = 0) :
- m_xercesNode(theXercesNode),
- m_index(theIndex)
- {
- }
-
- NodeImpl* m_xercesNode;
- unsigned long m_index;
- };
-
#if defined(XALAN_NO_NAMESPACES)
- typedef map<const XalanNode*, XalanNodeMapEntryType>
XalanNodeMapType;
+ typedef map<XalanNode*, NodeImpl*, less<XalanNode*> >
XalanNodeMapType;
- typedef map<const NodeImpl*, XalanNode*>
XercesNodeMapType;
+ typedef map<NodeImpl*, XalanNode*, less<NodeImpl*> >
XercesNodeMapType;
#else
- typedef std::map<const XalanNode*, XalanNodeMapEntryType>
XalanNodeMapType;
+ typedef std::map<XalanNode*, NodeImpl*> XalanNodeMapType;
- typedef std::map<const NodeImpl*, XalanNode*>
XercesNodeMapType;
+ typedef std::map<NodeImpl*, XalanNode*> XercesNodeMapType;
#endif
+private:
+
XalanNodeMapType m_xalanMap;
XercesNodeMapType m_xercesMap;
-
- unsigned long m_counter;
};
