bool LayerImporter::removeGeoNodes(DOMNode* pNode) const { if (NULL != pNode) { if (XMLString::equals(pNode->getNodeName(), X("geoVertices")) || XMLString::equals(pNode->getNodeName(), X("geoBox"))) { DOMNode* pParentNode = pNode->getParentNode(); if (NULL != pParentNode) { pParentNode->removeChild(pNode); } } else if (pNode->hasChildNodes()) { DOMNodeList* pChildren = pNode->getChildNodes(); for (unsigned int i = 0; i < pChildren->getLength(); ++i) { DOMNode* pChildNode = pChildren->item(i); removeGeoNodes(pChildNode); } } } return true; }
void XercesUpdateFactory::completeDeletions(DynamicContext *context) { // e. Finally, for each node marked for deletion by one of the update primitives listed above, let $N be the node that is marked // for deletion, and let $P be its parent node. The following actions are applied: // i. The parent property of $N is set to empty. // ii. If $N is an attribute node, the attributes property of $P is modified to remove $N. // iii. If $N is a non-attribute node, the children property of $P is modified to remove $N. // iv. If $N is an element, attribute, or text node, and $P is an element node, then upd:removeType($P) is invoked. for(DOMNodeSet::iterator i = forDeletion_.begin(); i != forDeletion_.end(); ++i) { DOMNode *domnode = *i; if(domnode->getNodeType() == DOMNode::ATTRIBUTE_NODE) { DOMAttr *attr = (DOMAttr*)domnode; DOMElement *owner = attr->getOwnerElement(); if(owner != 0) { owner->removeAttributeNode(attr); removeType(owner); } } else { DOMNode *parent = domnode->getParentNode(); if(parent != 0) { parent->removeChild(domnode); if(domnode->getNodeType() == DOMNode::ELEMENT_NODE || domnode->getNodeType() == DOMNode::TEXT_NODE || domnode->getNodeType() == DOMNode::CDATA_SECTION_NODE) { removeType(parent); } } } } }
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; } }
void Triggerconf::deleteConfigElement (string module, string submodule, string configname) { if (! existsConfigElement (module, submodule, configname)) return; DOMNode* currentSubmodule = selectSubmodule (module, submodule); if (currentSubmodule == NULL) return; DOMNode* currentConfigElement = selectConfigElement (module, submodule, configname); if (currentConfigElement == NULL) return; currentSubmodule->removeChild (currentConfigElement); currentConfigElement = NULL; resetError (); }
void Triggerconf::deleteSubmodule (string module, string submodule) { if (! existsSubmodule (module, submodule)) return; DOMNode* currentModule = selectModule (module); if (currentModule == NULL) return; DOMNode* currentSubmodule = selectSubmodule (module, submodule); if (currentSubmodule == NULL) return; currentModule->removeChild (currentSubmodule); currentSubmodule = NULL; resetError (); }
void DOMNodeImpl::setTextContent(const XMLCh* textContent){ DOMNode *thisNode = castToNode(this); switch (thisNode->getNodeType()) { case DOMNode::ELEMENT_NODE: case DOMNode::ENTITY_NODE: case DOMNode::ENTITY_REFERENCE_NODE: case DOMNode::DOCUMENT_FRAGMENT_NODE: { if (isReadOnly()) throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNodeMemoryManager); // Remove all childs DOMNode* current = thisNode->getFirstChild(); while (current != NULL) { thisNode->removeChild(current); current = thisNode->getFirstChild(); } if (textContent != NULL) { // Add textnode containing data current = ((DOMDocumentImpl*)thisNode->getOwnerDocument())->createTextNode(textContent); thisNode->appendChild(current); } } break; case DOMNode::ATTRIBUTE_NODE: case DOMNode::TEXT_NODE: case DOMNode::CDATA_SECTION_NODE: case DOMNode::COMMENT_NODE: case DOMNode::PROCESSING_INSTRUCTION_NODE: if (isReadOnly()) throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNodeMemoryManager); thisNode->setNodeValue(textContent); break; case DOMNode::DOCUMENT_NODE: case DOMNode::DOCUMENT_TYPE_NODE: case DOMNode::NOTATION_NODE: break; default: throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0, GetDOMNodeMemoryManager); } }
// --------------------------------------------------------------------------- // This method assumes that currentNode is an xinclude element and parses // it accordingly, acting on what it finds. // --------------------------------------------------------------------------- bool XIncludeUtils::doDOMNodeXInclude(DOMNode *xincludeNode, DOMDocument *parsedDocument, XMLEntityHandler* entityResolver){ bool modifiedNode = false; /* the relevant attributes to look for */ const XMLCh *href = NULL; const XMLCh *parse = NULL; const XMLCh *xpointer = NULL; const XMLCh *encoding = NULL; const XMLCh *accept = NULL; const XMLCh *acceptlanguage = NULL; DOMNode *includeParent = xincludeNode->getParentNode(); if(xincludeNode->hasAttributes()) { /* get all the attributes of the node */ DOMNamedNodeMap *pAttributes = xincludeNode->getAttributes(); XMLSize_t nSize = pAttributes->getLength(); for(XMLSize_t i=0;i<nSize;++i) { DOMAttr *pAttributeNode = (DOMAttr*) pAttributes->item(i); const XMLCh *attrName = pAttributeNode->getName(); /* check each attribute against the potential useful names */ if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeHREFAttrName)){ href = pAttributeNode->getValue(); } else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeParseAttrName)){ parse = pAttributeNode->getValue(); } else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeXPointerAttrName)){ xpointer = pAttributeNode->getValue(); } else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeEncodingAttrName)){ encoding = pAttributeNode->getValue(); } else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeAcceptAttrName)){ accept = pAttributeNode->getValue(); } else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeAcceptLanguageAttrName)){ acceptlanguage = pAttributeNode->getValue(); } else { /* if any other attribute is in the xi namespace, it's an error */ const XMLCh *attrNamespaceURI = pAttributeNode->getNamespaceURI(); if (attrNamespaceURI && XMLString::equals(attrNamespaceURI, XIncludeUtils::fgXIIIncludeNamespaceURI)){ } else { /* ignore - any other attribute is allowed according to spec, and must be ignored */ } } } } // 3.1 xi:include Element // The children property of the xi:include element may include a single xi:fallback element; // the appearance of more than one xi:fallback element, an xi:include element, // or any other element from the XInclude namespace is a fatal error. DOMNode *child; DOMElement *fallback = NULL; for (child = xincludeNode->getFirstChild(); child != 0; child=child->getNextSibling()){ if(child->getNodeType()!=DOMNode::ELEMENT_NODE) continue; if ( isXIFallbackDOMNode(child) ){ if (fallback != NULL){ /* fatal error - there are more than one fallback children */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeMultipleFallbackElems, parsedDocument->getDocumentURI(), parsedDocument->getDocumentURI()); return false; } fallback = (DOMElement*)child; } else if(isXIIncludeDOMNode(child) || XMLString::equals(child->getNamespaceURI(), XIncludeUtils::fgXIIIncludeNamespaceURI)) { /* fatal error - an xi element different from xi:fallback is a child of xi:include */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeDisallowedChild, child->getNodeName(), parsedDocument->getDocumentURI()); return false; } } if (href == NULL){ /* this is an unrecoverable error until we have xpointer support - if there is an xpointer, the current document is assumed however, there is no xpointer support yet */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeNoHref, NULL, parsedDocument->getDocumentURI()); return false; } /* set up the accept and accept-language values */ if (accept != NULL){ } if (parse == NULL){ /* use the default, as specified */ parse = XIncludeUtils::fgXIIncludeParseAttrXMLValue; } if (xpointer != NULL){ /* not supported yet */ /* Note that finding an xpointer attr along with parse="text" is a Fatal Error * - http://www.w3.org/TR/xinclude/#include-location */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeXPointerNotSupported, NULL, href); return false; } /* set up the href according to what has gone before */ XIncludeLocation hrefLoc(href); XIncludeLocation relativeLocation(href); const XMLCh *includeBase = xincludeNode->getBaseURI(); if (includeBase != NULL){ hrefLoc.prependPath(includeBase); } if (getBaseAttrValue(xincludeNode) != NULL){ relativeLocation.prependPath(getBaseAttrValue(xincludeNode)); } /* Take the relevant action - we need to retrieve the target as a whole before we can know if it was successful or not, therefore the do* methods do not modify the parsedDocument. Swapping the results in is left to the caller (i.e. here) */ DOMText *includedText = NULL; DOMDocument *includedDoc = NULL; if (XMLString::equals(parse, XIncludeUtils::fgXIIncludeParseAttrXMLValue)){ /* including a XML element */ includedDoc = doXIncludeXMLFileDOM(hrefLoc.getLocation(), relativeLocation.getLocation(), xincludeNode, parsedDocument, entityResolver); } else if (XMLString::equals(parse, XIncludeUtils::fgXIIncludeParseAttrTextValue)){ /* including a text value */ includedText = doXIncludeTEXTFileDOM(hrefLoc.getLocation(), relativeLocation.getLocation(), encoding, xincludeNode, parsedDocument, entityResolver); } else { /* invalid parse attribute value - fatal error according to the specification */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeInvalidParseVal, parse, parsedDocument->getDocumentURI()); return false; } RefVectorOf<DOMNode> delayedProcessing(12,false); if (includedDoc == NULL && includedText == NULL){ /* there was an error - this is now a resource error let's see if there is a fallback */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeIncludeFailedResourceError, hrefLoc.getLocation(), parsedDocument->getDocumentURI()); if (includeParent == NULL){ includeParent = parsedDocument; } // we could be getting errors trying to insert elements at the root of the document, so we should use replaceChild; // in order to handle multiple nodes, add them to a document fragment and use that to replace the original node if (fallback){ /* baseURI fixups - see http://www.w3.org/TR/xinclude/#base for details. */ XMLUri parentURI(includeParent->getBaseURI()); XMLUri includedURI(fallback->getBaseURI()); if (fallback->hasChildNodes()){ DOMDocumentFragment* frag = parsedDocument->createDocumentFragment(); DOMNode *child = fallback->getFirstChild(); /* add the content of the fallback element, and remove the fallback elem itself */ for ( ; child != NULL ; child=child->getNextSibling()){ if (child->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE){ continue; } DOMNode *newNode = parsedDocument->importNode(child, true); /* if the paths differ we need to add a base attribute */ if (newNode->getNodeType()==DOMNode::ELEMENT_NODE && !XMLString::equals(parentURI.getPath(), includedURI.getPath())){ if (getBaseAttrValue(newNode) == NULL){ /* need to calculate the proper path difference to get the relativePath */ ((DOMElement*)newNode)->setAttribute(fgXIBaseAttrName, getBaseAttrValue(fallback->getParentNode())); } else { /* the included node has base of its own which takes precedence */ XIncludeLocation xil(getBaseAttrValue(newNode)); if (getBaseAttrValue(fallback->getParentNode()) != NULL){ /* prepend any specific base modification of the xinclude node */ xil.prependPath(getBaseAttrValue(fallback->getParentNode())); } ((DOMElement*)newNode)->setAttribute(fgXIBaseAttrName, xil.getLocation()); } } DOMNode *newChild = frag->appendChild(newNode); // don't process the node now, wait until it is placed in the final position delayedProcessing.addElement(newChild); //parseDOMNodeDoingXInclude(newChild, parsedDocument, entityResolver); } includeParent->replaceChild(frag, xincludeNode); frag->release(); for(XMLSize_t i=0;i<delayedProcessing.size();i++) { DOMNode* childNode=delayedProcessing.elementAt(i); parseDOMNodeDoingXInclude(childNode, parsedDocument, entityResolver); } modifiedNode = true; } else { /* empty fallback element - simply remove it! */ includeParent->removeChild(xincludeNode); modifiedNode = true; } } else { XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeIncludeFailedNoFallback, parsedDocument->getDocumentURI(), parsedDocument->getDocumentURI()); return false; } } else { if (includedDoc){ /* record the successful include while we process the children */ addDocumentURIToCurrentInclusionHistoryStack(hrefLoc.getLocation()); DOMDocumentFragment* frag = parsedDocument->createDocumentFragment(); /* need to import the document prolog here */ DOMNode *child = includedDoc->getFirstChild(); for (; child != NULL; child = child->getNextSibling()) { if (child->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE) continue; // check for NOTATION or ENTITY clash if(child->getNodeType()==DOMNode::ELEMENT_NODE && includedDoc->getDoctype()!=NULL) { DOMNamedNodeMap *pAttributes = child->getAttributes(); XMLSize_t nSize = pAttributes->getLength(); for(XMLSize_t i=0;i<nSize;++i) { DOMAttr *pAttributeNode = (DOMAttr*) pAttributes->item(i); const DOMTypeInfo * typeInfo=pAttributeNode->getSchemaTypeInfo(); if(typeInfo && XMLString::equals(typeInfo->getTypeNamespace(), XMLUni::fgInfosetURIName)) { if(XMLString::equals(typeInfo->getTypeName(), XMLUni::fgNotationString)) { const XMLCh* notationName=pAttributeNode->getNodeValue(); DOMNotation* notat=(DOMNotation*)includedDoc->getDoctype()->getNotations()->getNamedItem(notationName); // ensure we have a DTD if(parsedDocument->getDoctype()==NULL) parsedDocument->insertBefore(parsedDocument->createDocumentType(parsedDocument->getDocumentElement()->getNodeName(), NULL,NULL), parsedDocument->getFirstChild()); DOMNotation* myNotation=(DOMNotation*)parsedDocument->getDoctype()->getNotations()->getNamedItem(notationName); if(myNotation==NULL) { // it's missing, add it parsedDocument->getDoctype()->getNotations()->setNamedItem(parsedDocument->importNode(notat, true)); } else if(XMLString::equals(myNotation->getPublicId(), notat->getPublicId()) && XMLString::equals(myNotation->getSystemId(), notat->getSystemId()) && XMLString::equals(myNotation->getBaseURI(), notat->getBaseURI())) { // it's duplicate, ignore it } else { // it's a conflict, report it XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeConflictingNotation, notationName, parsedDocument->getDocumentURI()); } } else if(XMLString::equals(typeInfo->getTypeName(), XMLUni::fgEntityString)) { const XMLCh* entityName=pAttributeNode->getNodeValue(); DOMEntity* ent=(DOMEntity*)includedDoc->getDoctype()->getEntities()->getNamedItem(entityName); // ensure we have a DTD if(parsedDocument->getDoctype()==NULL) parsedDocument->insertBefore(parsedDocument->createDocumentType(parsedDocument->getDocumentElement()->getNodeName(), NULL,NULL), parsedDocument->getFirstChild()); DOMEntity* myEnt=(DOMEntity*)parsedDocument->getDoctype()->getEntities()->getNamedItem(entityName); if(myEnt==NULL) { // it's missing, add it parsedDocument->getDoctype()->getEntities()->setNamedItem(parsedDocument->importNode(ent, true)); } else if(XMLString::equals(myEnt->getPublicId(), ent->getPublicId()) && XMLString::equals(myEnt->getSystemId(), ent->getSystemId()) && XMLString::equals(myEnt->getBaseURI(), ent->getBaseURI())) { // it's duplicate, ignore it } else { // it's a conflict, report it XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeConflictingEntity, entityName, parsedDocument->getDocumentURI()); } } } } } DOMNode *newNode = parsedDocument->importNode(child, true); DOMNode *newChild = frag->appendChild(newNode); // don't process the node now, wait until it is placed in the final position delayedProcessing.addElement(newChild); //parseDOMNodeDoingXInclude(newChild, parsedDocument, entityResolver); } includeParent->replaceChild(frag, xincludeNode); frag->release(); for(XMLSize_t i=0;i<delayedProcessing.size();i++) { DOMNode* childNode=delayedProcessing.elementAt(i); parseDOMNodeDoingXInclude(childNode, parsedDocument, entityResolver); } popFromCurrentInclusionHistoryStack(NULL); modifiedNode = true; } else if (includedText){ includeParent->replaceChild(includedText, xincludeNode); modifiedNode = true; } } if (includedDoc) includedDoc->release(); return modifiedNode; }
void DeltaApplyEngine::ApplyOperation(DOMNode *operationNode) { vddprintf(("ApplyOperation\n")); XMLCh dStr[2]; XMLCh iStr[2]; XMLCh uStr[2]; XMLCh adStr[3]; XMLCh aiStr[3]; XMLCh auStr[3]; XMLCh renameRootStr[11]; XMLString::transcode("d", dStr, 1); XMLString::transcode("i", iStr, 1); XMLString::transcode("u", uStr, 1); XMLString::transcode("ad", adStr, 2); XMLString::transcode("ai", aiStr, 2); XMLString::transcode("au", auStr, 2); XMLString::transcode("renameRoot", renameRootStr, 10); XMLCh tempStr[6]; if (XMLString::equals(operationNode->getLocalName(), dStr)) { vddprintf((" d(elete)\n")); bool move = false ; XMLString::transcode("move", tempStr, 5); DOMNode* moveAttr = operationNode->getAttributes()->getNamedItem(tempStr) ; XMLString::transcode("yes", tempStr, 5); if ((moveAttr!=NULL) && (XMLString::equals(moveAttr->getNodeValue(),tempStr))) { move = true; } XMLString::transcode("xm", tempStr, 5); char *xidmapStr = XMLString::transcode(operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue()); if (move) { XidMap_Parser parse(xidmapStr) ; XID_t myXid = parse.getRootXID(); Subtree_MoveFrom( myXid ); } else { Subtree_Delete(xidmapStr) ; } XMLString::release(&xidmapStr); } else if (XMLString::equals(operationNode->getLocalName(),iStr)) { vddprintf((" i(nsert)\n")); bool move = false ; XMLString::transcode("move", tempStr, 5); DOMNode* moveAttr = operationNode->getAttributes()->getNamedItem(tempStr) ; XMLString::transcode("yes", tempStr, 5); if ( (moveAttr!=NULL) && (XMLString::equals( moveAttr->getNodeValue(), tempStr ))) { move = true; } XMLString::transcode("pos", tempStr, 5); DOMNode *n = operationNode->getAttributes()->getNamedItem(tempStr); int position = XyInt(n->getNodeValue()); XMLString::transcode("par", tempStr, 5); n = operationNode->getAttributes()->getNamedItem(tempStr); XID_t parentXID = (XID_t)(int)XyInt(n->getNodeValue()); XMLString::transcode("xm", tempStr, 5); char *xidmapStr = XMLString::transcode(operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue()); if (move) { XidMap_Parser parse(xidmapStr) ; XID_t myXid = parse.getRootXID(); Subtree_MoveTo( myXid, parentXID, position ); } else { DOMNode* insertRoot ; // get data to insert if (operationNode->hasChildNodes()) insertRoot = operationNode->getFirstChild() ; else THROW_AWAY(("insert operator element contains no data")); Subtree_Insert( insertRoot, parentXID, position, xidmapStr ) ; } XMLString::release(&xidmapStr); } else if (XMLString::equals(operationNode->getLocalName(), uStr)) { vddprintf((" u(pdate)\n")); XMLString::transcode("oldxm", tempStr, 5); char *xidmapStr = XMLString::transcode(operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue()); XidMap_Parser parse(xidmapStr) ; XID_t nodeXID = parse.getRootXID(); TextNode_Update( nodeXID, operationNode); XMLString::release(&xidmapStr); } else if (XMLString::equals(operationNode->getLocalName(), adStr)) { vddprintf((" a(ttribute) d(elete)\n")); XMLString::transcode("xid", tempStr, 5); XID_t nodeXID = (XID_t)(int)XyInt(operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue()); XMLString::transcode("a", tempStr, 5); const XMLCh* attr = operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue() ; Attribute_Delete( nodeXID, attr ); } else if (XMLString::equals(operationNode->getLocalName(), aiStr)) { vddprintf((" a(ttribute) i(nsert)\n")); XMLString::transcode("xid", tempStr, 5); XID_t nodeXID = (XID_t)(int)XyInt(operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue()); XMLString::transcode("a", tempStr, 5); const XMLCh* attr = operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue() ; XMLString::transcode("v", tempStr, 5); const XMLCh* value = operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue() ; Attribute_Insert( nodeXID, attr, value ); } else if (XMLString::equals(operationNode->getLocalName(), auStr)) { vddprintf((" a(ttribute) u(pdate)\n")); XMLString::transcode("xid", tempStr, 5); XID_t nodeXID = (XID_t)(int)XyInt(operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue()); XMLString::transcode("a", tempStr, 5); const XMLCh* attr = operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue() ; XMLString::transcode("nv", tempStr, 5); const XMLCh* value = operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue() ; Attribute_Update( nodeXID, attr, value ); } else if (XMLString::equals(operationNode->getLocalName(), renameRootStr)) { vddprintf((" renameRoot\n")); DOMNode *root = xiddoc->getDocumentElement(); XID_t rootXID = xiddoc->getXidMap().getXIDbyNode(root); XMLString::transcode("to", tempStr, 5); const XMLCh* newrootName = operationNode->getAttributes()->getNamedItem(tempStr)->getNodeValue() ; DOMElement* newroot = xiddoc->createElement(newrootName); DOMNode* child = root->getFirstChild(); while(child!=NULL) { root->removeChild(child); newroot->appendChild(child); child = root->getFirstChild(); } DOMNamedNodeMap *attributes = root->getAttributes(); for(unsigned int i=0;i<attributes->getLength();i++) { DOMNode *an = attributes->item(i); newroot->setAttribute(an->getNodeName(), an->getNodeValue()); } xiddoc->removeChild(root); xiddoc->getXidMap().removeNode(root); root->release(); xiddoc->appendChild(newroot); xiddoc->getXidMap().registerNode(newroot, rootXID); xiddoc->getXidMap().SetRootElement(newroot); } }