DOMNode *DOMAttrMapImpl::removeNamedItemNS(const XMLCh *namespaceURI, const XMLCh *localName)
{
if (this->readOnly())
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNamedNodeMapMemoryManager);
int i = findNamePoint(namespaceURI, localName);
if (i < 0)
throw DOMException(DOMException::NOT_FOUND_ERR, 0, GetDOMNamedNodeMapMemoryManager);
DOMNode * removed = fNodes -> elementAt(i);
fNodes -> removeElementAt(i); //remove n from nodes
castToNodeImpl(removed)->fOwnerNode = fOwnerNode->getOwnerDocument();
castToNodeImpl(removed)->isOwned(false);
// Replace it if it had a default value
// (DOM spec level 2 - Element Interface)
if (hasDefaults() && (removed != 0))
{
DOMAttrMapImpl* defAttrs = ((DOMElementImpl*)fOwnerNode)->getDefaultAttributes();
DOMAttr* attr = (DOMAttr*)(defAttrs->getNamedItemNS(namespaceURI, localName));
if (attr != 0)
{
DOMAttr* newAttr = (DOMAttr*)attr->cloneNode(true);
setNamedItemNS(newAttr);
}
}
return removed;
}
void DOMAttrMapImpl::cloneContent(const DOMAttrMapImpl *srcmap)
{
if ((srcmap != 0) && (srcmap->fNodes != 0))
{
if (fNodes != 0)
fNodes->reset();
else
{
XMLSize_t size = srcmap->fNodes->size();
if(size > 0) {
DOMDocument *doc = fOwnerNode->getOwnerDocument();
fNodes = new (doc) DOMNodeVector(doc, size);
}
}
for (XMLSize_t i = 0; i < srcmap->fNodes->size(); i++)
{
DOMNode *n = srcmap->fNodes->elementAt(i);
DOMNode *clone = n->cloneNode(true);
castToNodeImpl(clone)->isSpecified(castToNodeImpl(n)->isSpecified());
castToNodeImpl(clone)->fOwnerNode = fOwnerNode;
castToNodeImpl(clone)->isOwned(true);
fNodes->addElement(clone);
}
}
}
//
// removeNamedItem() - Remove the named item, and return it.
// The caller can release the
// returned item if it's not used
// we can't do it here because the caller would
// never see the returned node.
//
DOMNode * DOMNamedNodeMapImpl::removeNamedItem(const XMLCh *name)
{
if (this->readOnly())
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNamedNodeMapMemoryManager);
unsigned int hash=XMLString::hash(name,MAP_SIZE);
if(fBuckets[hash]==0)
throw DOMException(DOMException::NOT_FOUND_ERR, 0, GetDOMNamedNodeMapMemoryManager);
int i = 0;
int size = fBuckets[hash]->size();
for (i = 0; i < size; ++i) {
DOMNode *n=fBuckets[hash]->elementAt(i);
if(XMLString::equals(name,n->getNodeName())) {
fBuckets[hash]->removeElementAt(i);
castToNodeImpl(n)->fOwnerNode = fOwnerNode->getOwnerDocument();
castToNodeImpl(n)->isOwned(false);
return n;
}
}
throw DOMException(DOMException::NOT_FOUND_ERR, 0, GetDOMNamedNodeMapMemoryManager);
return 0;
}
//
// setNamedItem() Put the item into the NamedNodeList by name.
// If an item with the same name already was
// in the list, replace it. Return the old
// item, if there was one.
// Caller is responsible for arranging for
// deletion of the old item if its ref count is
// zero.
//
DOMNode * DOMNamedNodeMapImpl::setNamedItem(DOMNode * arg)
{
DOMDocument *doc = fOwnerNode->getOwnerDocument();
DOMNodeImpl *argImpl = castToNodeImpl(arg);
if(argImpl->getOwnerDocument() != doc)
throw DOMException(DOMException::WRONG_DOCUMENT_ERR,0, GetDOMNamedNodeMapMemoryManager);
if (this->readOnly())
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNamedNodeMapMemoryManager);
if ((arg->getNodeType() == DOMNode::ATTRIBUTE_NODE) && argImpl->isOwned() && (argImpl->fOwnerNode != fOwnerNode))
throw DOMException(DOMException::INUSE_ATTRIBUTE_ERR,0, GetDOMNamedNodeMapMemoryManager);
argImpl->fOwnerNode = fOwnerNode;
argImpl->isOwned(true);
const XMLCh* name=arg->getNodeName();
unsigned int hash=XMLString::hash(name,MAP_SIZE);
if(fBuckets[hash]==0)
fBuckets[hash] = new (doc) DOMNodeVector(doc, 3);
int i = 0;
int size = fBuckets[hash]->size();
for (i = 0; i < size; ++i) {
DOMNode *n=fBuckets[hash]->elementAt(i);
if(XMLString::equals(name,n->getNodeName())) {
fBuckets[hash]->setElementAt(arg,i);
castToNodeImpl(n)->fOwnerNode = fOwnerNode->getOwnerDocument();
castToNodeImpl(n)->isOwned(false);
return n;
}
}
fBuckets[hash]->addElement(arg);
return 0;
}
void DOMDocumentTypeImpl::setSystemId(const XMLCh *value)
{
if ((DOMDocumentImpl *)castToNodeImpl(this)->getOwnerDocument())
fSystemId = ((DOMDocumentImpl *)castToNodeImpl(this)->getOwnerDocument())->cloneString(value);
else {
fSystemId = ((DOMDocumentImpl *)&gDocTypeDocument())->cloneString(value);
}
}
void DOMDocumentTypeImpl::setInternalSubset(const XMLCh *value)
{
if ((DOMDocumentImpl *)castToNodeImpl(this)->getOwnerDocument())
fInternalSubset = ((DOMDocumentImpl *)castToNodeImpl(this)->getOwnerDocument())->cloneString(value);
else {
fInternalSubset = ((DOMDocumentImpl *)&gDocTypeDocument())->cloneString(value);
}
}
DOMNode *DOMDocumentTypeImpl::cloneNode(bool deep) const
{
DOMNode* newNode = 0;
if (castToNodeImpl(this)->getOwnerDocument())
newNode = new (castToNodeImpl(this)->getOwnerDocument(), DOMDocumentImpl::DOCUMENT_TYPE_OBJECT) DOMDocumentTypeImpl(*this, false, deep);
else
newNode = new (&gDocTypeDocument(), DOMDocumentImpl::DOCUMENT_TYPE_OBJECT) DOMDocumentTypeImpl(*this, false, deep);
fNode.callUserDataHandlers(DOMUserDataHandler::NODE_CLONED, this, newNode);
return newNode;
}
void DOMDocumentTypeImpl::setPublicId(const XMLCh *value)
{
// revist. Why shouldn't 0 be assigned like any other value?
if (value == 0)
return;
if ((DOMDocumentImpl *)castToNodeImpl(this)->getOwnerDocument())
fPublicId = ((DOMDocumentImpl *)castToNodeImpl(this)->getOwnerDocument())->cloneString(value);
else {
fPublicId = ((DOMDocumentImpl *)&gDocTypeDocument())->cloneString(value);
}
}
DOMNode* DOMElementImpl::rename(const XMLCh* namespaceURI, const XMLCh* name)
{
DOMDocumentImpl* doc = (DOMDocumentImpl*) fParent.fOwnerDocument;
if (!namespaceURI || !*namespaceURI) {
fName = doc->getPooledString(name);
fAttributes->reconcileDefaultAttributes(getDefaultAttributes());
// and fire user data NODE_RENAMED event
castToNodeImpl(this)->callUserDataHandlers(DOMUserDataHandler::NODE_RENAMED, this, this);
return this;
}
else {
// create a new ElementNS
DOMElementNSImpl* newElem = (DOMElementNSImpl*)doc->createElementNS(namespaceURI, name);
// transfer the userData
doc->transferUserData(castToNodeImpl(this), castToNodeImpl(newElem));
// remove old node from parent if any
DOMNode* parent = getParentNode();
DOMNode* nextSib = getNextSibling();
if (parent) {
parent->removeChild(this);
}
// move children to new node
DOMNode* child = getFirstChild();
while (child) {
removeChild(child);
newElem->appendChild(child);
child = getFirstChild();
}
// insert new node where old one was
if (parent) {
parent->insertBefore(newElem, nextSib);
}
// move specified attributes to new node
newElem->fAttributes->moveSpecifiedAttributes(fAttributes);
// and fire user data NODE_RENAMED event
castToNodeImpl(newElem)->callUserDataHandlers(DOMUserDataHandler::NODE_RENAMED, this, newElem);
return newElem;
}
}
//DOM Level 2
DOMDeepNodeListImpl::DOMDeepNodeListImpl(const DOMNode *rootNode,
const XMLCh *namespaceURI,
const XMLCh *localName)
: fRootNode(rootNode)
, fChanges(0)
, fCurrentNode(0)
, fCurrentIndexPlus1(0)
, fMatchAllURI(false)
, fMatchURIandTagname(true)
{
fTagName = ((DOMDocumentImpl *)(castToNodeImpl(rootNode)->getOwnerDocument()))->getPooledString(localName);
fMatchAll = XMLString::equals(fTagName, kAstr);
fMatchAllURI = XMLString::equals(namespaceURI, kAstr);
fNamespaceURI = ((DOMDocumentImpl *)(castToNodeImpl(rootNode)->getOwnerDocument()))->getPooledString(namespaceURI);
}
/**
* NON-DOM
* set the ownerDocument of this node and its children
*/
void DOMDocumentTypeImpl::setOwnerDocument(DOMDocument *doc) {
if (castToNodeImpl(this)->getOwnerDocument()) {
fNode.setOwnerDocument(doc);
fParent.setOwnerDocument(doc);
}
else {
if (doc) {
DOMDocumentImpl *docImpl = (DOMDocumentImpl *)doc;
fPublicId = docImpl->cloneString(fPublicId);
fSystemId = docImpl->cloneString(fSystemId);
fInternalSubset = docImpl->cloneString(fInternalSubset);
fName = docImpl->getPooledString(fName);
fNode.setOwnerDocument(doc);
fParent.setOwnerDocument(doc);
DOMNamedNodeMapImpl* entitiesTemp = fEntities->cloneMap(this);
DOMNamedNodeMapImpl* notationsTemp = fNotations->cloneMap(this);
DOMNamedNodeMapImpl* elementsTemp = fElements->cloneMap(this);
fEntities = entitiesTemp;
fNotations = notationsTemp;
fElements = elementsTemp;
}
}
}
DOMNode * DOMChildNode::getParentNode(const DOMNode *thisNode) const
{
// if we have an owner, ownerNode is our parent, otherwise it's
// our ownerDocument and we don't have a parent
DOMNodeImpl *thisNodeImpl = castToNodeImpl(thisNode);
return thisNodeImpl->isOwned() ? thisNodeImpl->fOwnerNode : 0;
}
void DOMNodeImpl::setReadOnly(bool readOnl, bool deep)
{
this->isReadOnly(readOnl);
if (deep) {
for (DOMNode *mykid = castToNode(this)->getFirstChild();
mykid != 0;
mykid = mykid->getNextSibling()) {
short kidNodeType = mykid->getNodeType();
switch (kidNodeType) {
case DOMNode::ENTITY_REFERENCE_NODE:
break;
case DOMNode::ELEMENT_NODE:
((DOMElementImpl*) mykid)->setReadOnly(readOnl, true);
break;
case DOMNode::DOCUMENT_TYPE_NODE:
((DOMDocumentTypeImpl*) mykid)->setReadOnly(readOnl, true);
break;
default:
castToNodeImpl(mykid)->setReadOnly(readOnl, true);
break;
}
}
}
}
DOMAttrMapImpl *DOMAttrMapImpl::cloneAttrMap(DOMNode *ownerNode_p)
{
DOMAttrMapImpl *newmap = new (castToNodeImpl(ownerNode_p)->getOwnerDocument()) DOMAttrMapImpl(ownerNode_p);
newmap->cloneContent(this);
// newmap->attrDefaults = this->attrDefaults; // revisit
return newmap;
}
DOMCDATASectionImpl::DOMCDATASectionImpl(const DOMCDATASectionImpl &other, bool /*deep*/)
: DOMCDATASection(other),
fNode(*castToNodeImpl(&other)),
fChild(*castToChildImpl(&other)),
fCharacterData(other.fCharacterData)
{
// revisit. Something nees to make "deep" work.
}
DOMCDATASectionImpl::DOMCDATASectionImpl(const DOMCDATASectionImpl &other, bool)
: fNode(*castToNodeImpl(&other)),
fParent(*castToParentImpl(&other)),
fChild(*castToChildImpl(&other)),
fCharacterData(other.fCharacterData)
{
// revisit. SOmething nees to make "deep" work.
}
void DOMCharacterDataImpl::appendData(const DOMNode *node, const XMLCh *dat)
{
if(castToNodeImpl(node)->isReadOnly())
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMCharacterDataImplMemoryManager);
fDataBuf->append(dat);
}
//
// setNamedItemNS() Put the item into the NamedNodeList by name.
// If an item with the same name already was
// in the list, replace it. Return the old
// item, if there was one.
// Caller is responsible for arranging for
// deletion of the old item if its ref count is
// zero.
//
DOMNode * DOMNamedNodeMapImpl::setNamedItemNS(DOMNode *arg)
{
DOMDocument *doc = fOwnerNode->getOwnerDocument();
DOMNodeImpl *argImpl = castToNodeImpl(arg);
if (argImpl->getOwnerDocument() != doc)
throw DOMException(DOMException::WRONG_DOCUMENT_ERR,0, GetDOMNamedNodeMapMemoryManager);
if (this->readOnly())
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNamedNodeMapMemoryManager);
if (argImpl->isOwned())
throw DOMException(DOMException::INUSE_ATTRIBUTE_ERR,0, GetDOMNamedNodeMapMemoryManager);
argImpl->fOwnerNode = fOwnerNode;
argImpl->isOwned(true);
const XMLCh* namespaceURI=arg->getNamespaceURI();
const XMLCh* localName=arg->getLocalName();
// the map is indexed using the full name of nodes; to search given a namespace and a local name
// we have to do a linear search
for (int index = 0; index < MAP_SIZE; index++) {
if(fBuckets[index]==0)
continue;
int i = 0;
int size = fBuckets[index]->size();
for (i = 0; i < size; ++i) {
DOMNode *n=fBuckets[index]->elementAt(i);
const XMLCh * nNamespaceURI = n->getNamespaceURI();
const XMLCh * nLocalName = n->getLocalName();
if (!XMLString::equals(nNamespaceURI, namespaceURI)) //URI not match
continue;
else {
if (XMLString::equals(localName, nLocalName)
||
(nLocalName == 0 && XMLString::equals(localName, n->getNodeName()))) {
fBuckets[index]->setElementAt(arg,i);
castToNodeImpl(n)->fOwnerNode = fOwnerNode->getOwnerDocument();
castToNodeImpl(n)->isOwned(false);
return n;
}
}
}
}
// if not found, add it using the full name as key
return setNamedItem(arg);
}
DOMNode* DOMAttrImpl::rename(const XMLCh* namespaceURI, const XMLCh* name)
{
DOMElement* el = getOwnerElement();
DOMDocumentImpl* doc = (DOMDocumentImpl*)fParent.fOwnerDocument;
if (el)
el->removeAttributeNode(this);
if (!namespaceURI || !*namespaceURI) {
fName = doc->getPooledString(name);
if (el)
el->setAttributeNode(this);
// and fire user data NODE_RENAMED event
castToNodeImpl(this)->callUserDataHandlers(DOMUserDataHandler::NODE_RENAMED, this, this);
return this;
}
else {
// create a new AttrNS
DOMAttr* newAttr = doc->createAttributeNS(namespaceURI, name);
// transfer the userData
doc->transferUserData(castToNodeImpl(this), castToNodeImpl(newAttr));
// move children to new node
DOMNode* child = getFirstChild();
while (child) {
removeChild(child);
newAttr->appendChild(child);
child = getFirstChild();
}
// reattach attr to element
if (el)
el->setAttributeNodeNS(newAttr);
// and fire user data NODE_RENAMED event
castToNodeImpl(newAttr)->callUserDataHandlers(DOMUserDataHandler::NODE_RENAMED, this, newAttr);
return newAttr;
}
}
DOMNode* DOMElementNSImpl::rename(const XMLCh* namespaceURI, const XMLCh* name)
{
setName(namespaceURI, name);
fAttributes->reconcileDefaultAttributes(getDefaultAttributes());
// and fire user data NODE_RENAMED event
castToNodeImpl(this)->callUserDataHandlers(DOMUserDataHandler::NODE_RENAMED, this, this);
return this;
}
void DOMCharacterDataImpl::replaceData(const DOMNode *node, XMLSize_t offset, XMLSize_t count,
const XMLCh *dat)
{
if (castToNodeImpl(node)->isReadOnly())
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMCharacterDataImplMemoryManager);
deleteData(node, offset, count);
insertData(node, offset, dat);
}
void DOMDocumentTypeImpl::setInternalSubset(const XMLCh *value)
{
DOMDocumentImpl* doc = (DOMDocumentImpl *)castToNodeImpl(this)->getOwnerDocument();
if (doc != 0)
fInternalSubset = doc->cloneString(value);
else {
XMLMutexLock lock(sDocumentMutex);
fInternalSubset = ((DOMDocumentImpl *)sDocument)->cloneString(value);
}
}
bool DOMParentNode::isEqualNode(const DOMNode* arg) const
{
if (arg && castToNodeImpl(this)->isSameNode(arg))
return true;
if (arg && castToNodeImpl(this)->isEqualNode(arg))
{
DOMNode *kid, *argKid;
for (kid = fFirstChild, argKid = arg->getFirstChild();
kid != 0 && argKid != 0;
kid = kid->getNextSibling(), argKid = argKid->getNextSibling())
{
if (!kid->isEqualNode(argKid))
return false;
}
return (kid || argKid) ? false : true;
}
return false;
}
void DOMAttrMapImpl::setReadOnly(bool readOnl, bool deep)
{
// this->fReadOnly=readOnl;
if(deep && fNodes!=0)
{
int sz = fNodes->size();
for (int i=0; i<sz; ++i) {
castToNodeImpl(fNodes->elementAt(i))->setReadOnly(readOnl, deep);
}
}
}
//Non-standard extension
void DOMParentNode::release()
{
DOMNode *kid, *next;
for (kid = fFirstChild; kid != 0; kid = next)
{
next = castToChildImpl(kid)->nextSibling;
// set is Owned false before releasing its child
castToNodeImpl(kid)->isToBeReleased(true);
kid->release();
}
}
DOMNamedNodeMapImpl *DOMNamedNodeMapImpl::cloneMap(DOMNode *ownerNod)
{
DOMDocumentImpl *doc = (DOMDocumentImpl *)(castToNodeImpl(ownerNod)->getOwnerDocument());
DOMNamedNodeMapImpl *newmap = new (doc) DOMNamedNodeMapImpl(ownerNod);
for(int index=0;index<MAP_SIZE;index++)
if (fBuckets[index] != 0) {
XMLSize_t size=fBuckets[index]->size();
newmap->fBuckets[index] = new (doc) DOMNodeVector(doc, size);
for (XMLSize_t i = 0; i < size; ++i) {
DOMNode *s = fBuckets[index]->elementAt(i);
DOMNode *n = s->cloneNode(true);
castToNodeImpl(n)->isSpecified(castToNodeImpl(s)->isSpecified());
castToNodeImpl(n)->fOwnerNode = ownerNod;
castToNodeImpl(n)->isOwned(true);
newmap->fBuckets[index]->addElement(n);
}
}
return newmap;
}
DOMNode * DOMParentNode::appendChildFast(DOMNode *newChild)
{
// This function makes the following assumptions:
//
// - newChild != 0
// - newChild is not read-only
// - newChild is not a document fragment
// - owner documents of this node and newChild are the same
// - appending newChild to this node cannot result in a cycle
// - DOMDocumentImpl::isKidOK (this, newChild) return true (that is,
// appending newChild to this node results in a valid structure)
// - newChild->getParentNode() is 0
// - there are no ranges set for this document
//
// Attach up
castToNodeImpl(newChild)->fOwnerNode = castToNode(this);
castToNodeImpl(newChild)->isOwned(true);
// Attach before and after
// Note: fFirstChild.previousSibling == lastChild!!
if (fFirstChild != 0)
{
DOMNode *lastChild = castToChildImpl(fFirstChild)->previousSibling;
castToChildImpl(lastChild)->nextSibling = newChild;
castToChildImpl(newChild)->previousSibling = lastChild;
castToChildImpl(fFirstChild)->previousSibling = newChild;
}
else
{
// this our first and only child
fFirstChild = newChild;
castToNodeImpl(newChild)->isFirstChild(true);
// castToChildImpl(newChild)->previousSibling = newChild;
DOMChildNode *newChild_ci = castToChildImpl(newChild);
newChild_ci->previousSibling = newChild;
}
return newChild;
}
void DOMNamedNodeMapImpl::setReadOnly(bool readOnl, bool deep)
{
// this->fReadOnly=readOnl;
if(deep) {
for (int index = 0; index < MAP_SIZE; index++) {
if(fBuckets[index]==0)
continue;
int sz = fBuckets[index]->size();
for (int i=0; i<sz; ++i)
castToNodeImpl(fBuckets[index]->elementAt(i))->setReadOnly(readOnl, deep);
}
}
}
DOMNode *DOMAttrMapImpl::setNamedItem(DOMNode *arg)
{
if (arg->getNodeType() != DOMNode::ATTRIBUTE_NODE)
throw DOMException(DOMException::HIERARCHY_REQUEST_ERR, 0, GetDOMNamedNodeMapMemoryManager);
DOMDocument *doc = fOwnerNode->getOwnerDocument();
DOMNodeImpl *argImpl = castToNodeImpl(arg);
if(argImpl->getOwnerDocument() != doc)
throw DOMException(DOMException::WRONG_DOCUMENT_ERR, 0, GetDOMNamedNodeMapMemoryManager);
if (this->readOnly())
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNamedNodeMapMemoryManager);
if ((arg->getNodeType() == DOMNode::ATTRIBUTE_NODE) && argImpl->isOwned() && (argImpl->fOwnerNode != fOwnerNode))
throw DOMException(DOMException::INUSE_ATTRIBUTE_ERR,0, GetDOMNamedNodeMapMemoryManager);
argImpl->fOwnerNode = fOwnerNode;
argImpl->isOwned(true);
int i=findNamePoint(arg->getNodeName());
DOMNode * previous=0;
if(i>=0)
{
previous = fNodes->elementAt(i);
fNodes->setElementAt(arg,i);
}
else
{
i=-1-i; // Insert point (may be end of list)
if(0==fNodes)
{
fNodes=new (doc) DOMNodeVector(doc);
}
fNodes->insertElementAt(arg,i);
}
if (previous != 0) {
castToNodeImpl(previous)->fOwnerNode = fOwnerNode->getOwnerDocument();
castToNodeImpl(previous)->isOwned(false);
}
return previous;
}
const XMLCh* DOMNodeImpl::lookupNamespacePrefix(const XMLCh* const namespaceURI, bool useDefault, DOMElement *el) const {
DOMNode *thisNode = castToNode(this);
const XMLCh* ns = thisNode->getNamespaceURI();
// REVISIT: if no prefix is available is it null or empty string, or
// could be both?
const XMLCh* prefix = thisNode->getPrefix();
if (ns != 0 && XMLString::equals(ns,namespaceURI)) {
if (useDefault || prefix != 0) {
const XMLCh* foundNamespace = el->lookupNamespaceURI(prefix);
if (foundNamespace != 0 && XMLString::equals(foundNamespace, namespaceURI)) {
return prefix;
}
}
}
if (thisNode->hasAttributes()) {
DOMNamedNodeMap *nodeMap = thisNode->getAttributes();
if(nodeMap != 0) {
int length = nodeMap->getLength();
for (int i = 0;i < length;i++) {
DOMNode *attr = nodeMap->item(i);
const XMLCh* attrPrefix = attr->getPrefix();
const XMLCh* value = attr->getNodeValue();
ns = attr->getNamespaceURI();
if (ns != 0 && XMLString::equals(ns, XMLUni::fgXMLNSURIName)) {
// DOM Level 2 nodes
if ((useDefault && XMLString::equals(attr->getNodeName(), XMLUni::fgXMLNSString)) ||
(attrPrefix != 0 && XMLString::equals(attrPrefix, XMLUni::fgXMLNSString)) &&
XMLString::equals(value, namespaceURI)) {
const XMLCh* localname= attr->getLocalName();
const XMLCh* foundNamespace = el->lookupNamespaceURI(localname);
if (foundNamespace != 0 && XMLString::equals(foundNamespace, namespaceURI)) {
return localname;
}
}
}
}
}
}
DOMNode *ancestor = getElementAncestor(thisNode);
if (ancestor != 0) {
return castToNodeImpl(ancestor)->lookupNamespacePrefix(namespaceURI, useDefault, el);
}
return 0;
}
