开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
DOMElementImpl.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：24k
源码类别：

词法分析

开发平台：

Visual C++

DOMElementImpl.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001-2002 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 2001, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Id: DOMElementImpl.cpp,v 1.20 2003/05/16 06:01:50 knoaman Exp $
  59.  */
  61. #include "DOMElementImpl.hpp"
  63. #include <xercesc/dom/DOMAttr.hpp>
  64. #include <xercesc/dom/DOMDocument.hpp>
  65. #include <xercesc/dom/DOMException.hpp>
  66. #include <xercesc/util/XMLUniDefs.hpp>
  67. #include <xercesc/util/XMLUri.hpp>
  69. #include "DOMAttrMapImpl.hpp"
  70. #include "DOMAttrImpl.hpp"
  71. #include "DOMDocumentImpl.hpp"
  72. #include "DOMParentNode.hpp"
  73. #include "DOMStringPool.hpp"
  74. #include "DOMCasts.hpp"
  75. #include "DOMElementNSImpl.hpp"
  76. #include "DOMTypeInfoImpl.hpp"
  78. #include "DOMDeepNodeListImpl.hpp"
  79. #include "DOMDocumentTypeImpl.hpp"
  80. #include "DOMNamedNodeMapImpl.hpp"
  82. XERCES_CPP_NAMESPACE_BEGIN
  85. class DOMAttr;
  87. DOMElementImpl::DOMElementImpl(DOMDocument *ownerDoc, const XMLCh *eName)
  88.     : fNode(ownerDoc), fParent(ownerDoc), fAttributes(0), fDefaultAttributes(0), fSchemaType(0)
  89. {
  90.     DOMDocumentImpl *docImpl = (DOMDocumentImpl *)ownerDoc;
  91.     fName = docImpl->getPooledString(eName);
  92.     setupDefaultAttributes();
  93.     if (!fDefaultAttributes) {
  94.         fDefaultAttributes = new (getOwnerDocument()) DOMAttrMapImpl(this);
  95.         fAttributes = new (getOwnerDocument()) DOMAttrMapImpl(this);
  96.     }
  97.     else {
  98.         fAttributes = new (getOwnerDocument()) DOMAttrMapImpl(this, fDefaultAttributes);
  99.     }
  100. };
  103. DOMElementImpl::DOMElementImpl(const DOMElementImpl &other, bool deep)
  104.     : fNode(other.getOwnerDocument()),
  105.       fParent(other.getOwnerDocument()),
  106.       fSchemaType(other.fSchemaType),
  107.       fAttributes(0),
  108.       fDefaultAttributes(0)
  109. {
  110.     fName = other.fName;
  112.     if (deep)
  113.         fParent.cloneChildren(&other);
  115.     if (other.getAttributes())
  116.     {
  117.         fAttributes = ((DOMAttrMapImpl *)other.getAttributes())->cloneAttrMap(this);
  118.     }
  120.     if (other.getDefaultAttributes())
  121.     {
  122.         fDefaultAttributes = ((DOMAttrMapImpl *)other.getDefaultAttributes())->cloneAttrMap(this);
  123.     }
  125.     if (!fDefaultAttributes)
  126.         setupDefaultAttributes();
  128.     if (!fDefaultAttributes)
  129.         fDefaultAttributes = new (getOwnerDocument()) DOMAttrMapImpl(this);
  131.     if (!fAttributes) {
  132.         if (!fDefaultAttributes) {
  133.             fAttributes = new (getOwnerDocument()) DOMAttrMapImpl(this);
  134.         }
  135.         else {
  136.             fAttributes = new (getOwnerDocument()) DOMAttrMapImpl(this, fDefaultAttributes);
  137.         }
  138.     }
  140. };
  143. DOMElementImpl::~DOMElementImpl()
  144. {
  145. };
  148. DOMNode *DOMElementImpl::cloneNode(bool deep) const
  149. {
  150.     DOMNode* newNode = new (getOwnerDocument(), DOMDocumentImpl::ELEMENT_OBJECT) DOMElementImpl(*this, deep);
  151.     fNode.callUserDataHandlers(DOMUserDataHandler::NODE_CLONED, this, newNode);
  152.     return newNode;
  153. };
  158. const XMLCh * DOMElementImpl::getNodeName() const {
  159.     return fName;
  160. };
  163. short DOMElementImpl::getNodeType() const {
  164.     return DOMNode::ELEMENT_NODE;
  165. };
  168. const XMLCh * DOMElementImpl::getAttribute(const XMLCh *nam) const
  169. {
  170.     static const XMLCh emptyString[]  = {0};
  171.     DOMNode * attr=0;
  173.     attr=fAttributes->getNamedItem(nam);
  175.     const XMLCh *retString = emptyString;
  176.     if (attr != 0)
  177.         retString = attr->getNodeValue();
  179.     return retString;
  180. };
  184. DOMAttr *DOMElementImpl::getAttributeNode(const XMLCh *nam) const
  185. {
  186.     return  (DOMAttr *)fAttributes->getNamedItem(nam);
  187. };
  190. DOMNamedNodeMap *DOMElementImpl::getAttributes() const
  191. {
  192.     DOMElementImpl *ncThis = (DOMElementImpl *)this;   // cast off const
  193.     return ncThis->fAttributes;
  194. };
  198. DOMNodeList *DOMElementImpl::getElementsByTagName(const XMLCh *tagname) const
  199. {
  200.     DOMDocumentImpl *docImpl = (DOMDocumentImpl *)getOwnerDocument();
  201.     return docImpl->getDeepNodeList(this,tagname);
  202. };
  205. const XMLCh * DOMElementImpl::getTagName() const
  206. {
  207.     return fName;
  208. }
  211. void DOMElementImpl::removeAttribute(const XMLCh *nam)
  212. {
  213.     if (fNode.isReadOnly())
  214.         throw DOMException(
  215.              DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  217.     XMLSSize_t i = fAttributes->findNamePoint(nam);
  218.     if (i >= 0)
  219.     {
  220.         DOMNode *att = fAttributes->removeNamedItemAt(i);
  221.         ((DOMAttrImpl *)att)->removeAttrFromIDNodeMap();
  222.         att->release();
  223.     }
  224. };
  228. DOMAttr *DOMElementImpl::removeAttributeNode(DOMAttr *oldAttr)
  229. {
  230.     if (fNode.isReadOnly())
  231.         throw DOMException(
  232.         DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  234.     DOMNode* found = 0;
  236.     // Since there is no removeAttributeNodeNS, check if this oldAttr has NS or not
  237.     const XMLCh* localName = oldAttr->getLocalName();
  238.     XMLSSize_t i = 0;
  239.     if (localName)
  240.         i = fAttributes->findNamePoint(oldAttr->getNamespaceURI(), localName);
  241.     else
  242.         i = fAttributes->findNamePoint(oldAttr->getName());
  244.     if (i >= 0) {
  245.         // If it is in fact the right object, remove it.
  246.         found = fAttributes->item(i);
  247.         if (found == oldAttr) {
  248.             fAttributes->removeNamedItemAt(i);
  249.             ((DOMAttrImpl *)oldAttr)->removeAttrFromIDNodeMap();
  250.         }
  251.         else
  252.             throw DOMException(DOMException::NOT_FOUND_ERR, 0);
  254.     }
  255.     else
  256.         throw DOMException(DOMException::NOT_FOUND_ERR, 0);
  258.    return (DOMAttr *)found;
  259. };
  263. void DOMElementImpl::setAttribute(const XMLCh *nam, const XMLCh *val)
  264. {
  265.     if (fNode.isReadOnly())
  266.         throw DOMException(
  267.         DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  269.     DOMAttr* newAttr = getAttributeNode(nam);
  270.     if (!newAttr)
  271.     {
  272.         newAttr = this->fNode.getOwnerDocument()->createAttribute(nam);
  273.         fAttributes->setNamedItem(newAttr);
  274.     }
  276.     newAttr->setNodeValue(val);
  277. };
  279. void DOMElementImpl::setIdAttribute(const XMLCh* name)
  280. {
  281.     if (fNode.isReadOnly())
  282.         throw DOMException(
  283.         DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  285.     DOMAttr *attr = getAttributeNode(name);
  287.     if (!attr) 
  288.         throw DOMException(DOMException::NOT_FOUND_ERR, 0);
  290.     ((DOMAttrImpl *)attr)->addAttrToIDNodeMap();
  291. };
  293. void DOMElementImpl::setIdAttributeNS(const XMLCh* namespaceURI, const XMLCh* localName) {
  295.     if (fNode.isReadOnly())
  296.         throw DOMException(
  297.         DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  299.     DOMAttr *attr = getAttributeNodeNS(namespaceURI, localName);
  301.     if (!attr) 
  302.         throw DOMException(DOMException::NOT_FOUND_ERR, 0);
  304.     ((DOMAttrImpl *)attr)->addAttrToIDNodeMap();
  306. };
  309. void DOMElementImpl::setIdAttributeNode(const DOMAttr *idAttr) {
  311.     if (fNode.isReadOnly())
  312.         throw DOMException(
  313.         DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  315.     DOMAttr *attr;
  316.     const XMLCh* localName = idAttr->getLocalName();
  317.     if (localName)
  318.         attr = getAttributeNodeNS(idAttr->getNamespaceURI(), idAttr->getLocalName());
  319.     else 
  320.         attr = getAttributeNode(idAttr->getName());
  321.     
  322.     if(!attr) 
  323.         throw DOMException(DOMException::NOT_FOUND_ERR, 0);
  325.     ((DOMAttrImpl *)attr)->addAttrToIDNodeMap();
  326. };
  329. DOMAttr * DOMElementImpl::setAttributeNode(DOMAttr *newAttr)
  330. {
  331.     if (fNode.isReadOnly())
  332.         throw DOMException(
  333.         DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  335.     if (newAttr->getNodeType() != DOMNode::ATTRIBUTE_NODE)
  336.         throw DOMException(DOMException::WRONG_DOCUMENT_ERR, 0);
  337.         // revisit.  Exception doesn't match test.
  339.     // This will throw INUSE if necessary
  340.     DOMAttr *oldAttr = (DOMAttr *) fAttributes->setNamedItem(newAttr);
  342.     return oldAttr;
  343. };
  346. void DOMElementImpl::setNodeValue(const XMLCh *x)
  347. {
  348.     fNode.setNodeValue(x);
  349. };
  353. void DOMElementImpl::setReadOnly(bool readOnl, bool deep)
  354. {
  355.     fNode.setReadOnly(readOnl,deep);
  356.     fAttributes->setReadOnly(readOnl,true);
  357. };
  360. //Introduced in DOM Level 2
  361. const XMLCh * DOMElementImpl::getAttributeNS(const XMLCh *fNamespaceURI,
  362.     const XMLCh *fLocalName) const
  363. {
  364.     DOMAttr * attr=
  365.       (DOMAttr *)(fAttributes->getNamedItemNS(fNamespaceURI, fLocalName));
  366.     return (attr==0) ? XMLUni::fgZeroLenString : attr->getValue();
  367. }
  370. void DOMElementImpl::setAttributeNS(const XMLCh *fNamespaceURI,
  371.     const XMLCh *qualifiedName, const XMLCh *fValue)
  372. {
  373.     if (fNode.isReadOnly())
  374.         throw DOMException(
  375.         DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  377.     DOMAttr* newAttr = getAttributeNodeNS(fNamespaceURI, qualifiedName);
  379.     if (!newAttr)
  380.     {
  381.         newAttr = this->fNode.getOwnerDocument()->createAttributeNS(fNamespaceURI, qualifiedName);
  382.         fAttributes->setNamedItemNS(newAttr);
  383.     }
  385.     newAttr->setNodeValue(fValue);
  386. }
  389. void DOMElementImpl::removeAttributeNS(const XMLCh *fNamespaceURI,
  390.     const XMLCh *fLocalName)
  391. {
  392.     if (fNode.isReadOnly())
  393.         throw DOMException(
  394.         DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  396.     XMLSSize_t i = fAttributes->findNamePoint(fNamespaceURI, fLocalName);
  397.     if (i >= 0)
  398.     {
  399.         DOMNode *att = fAttributes->removeNamedItemAt(i);
  400.         att->release();
  401.     }
  402. }
  405. DOMAttr *DOMElementImpl::getAttributeNodeNS(const XMLCh *fNamespaceURI,
  406.     const XMLCh *fLocalName) const
  407. {
  408.     return (DOMAttr *)fAttributes->getNamedItemNS(fNamespaceURI, fLocalName);
  409. }
  412. DOMAttr *DOMElementImpl::setAttributeNodeNS(DOMAttr *newAttr)
  413. {
  414.     if (fNode.isReadOnly())
  415.         throw DOMException(
  416.             DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  418.     if (newAttr -> getOwnerDocument() != this -> getOwnerDocument())
  419.         throw DOMException(DOMException::WRONG_DOCUMENT_ERR, 0);
  421.     // This will throw INUSE if necessary
  422.     DOMAttr *oldAttr = (DOMAttr *) fAttributes->setNamedItemNS(newAttr);
  424.     return oldAttr;
  425. }
  428. DOMNodeList *DOMElementImpl::getElementsByTagNameNS(const XMLCh *namespaceURI,
  429.     const XMLCh *localName) const
  430. {
  431.     DOMDocumentImpl *docImpl = (DOMDocumentImpl *)getOwnerDocument();;
  432.     return docImpl->getDeepNodeList(this, namespaceURI, localName);
  433. }
  435. bool DOMElementImpl::hasAttributes() const
  436. {
  437.     return (fAttributes != 0 && fAttributes->getLength() != 0);
  438. };
  441. bool DOMElementImpl::hasAttribute(const XMLCh *name) const
  442. {
  443.     return (getAttributeNode(name) != 0);
  444. };
  447. bool DOMElementImpl::hasAttributeNS(const XMLCh *namespaceURI,
  448.     const XMLCh *localName) const
  449. {
  450.     return (getAttributeNodeNS(namespaceURI, localName) != 0);
  451. };
  454. // util functions for default attributes
  455. // returns the default attribute map for this node from the owner document
  456. DOMAttrMapImpl *DOMElementImpl::getDefaultAttributes() const
  457. {
  458.     return fDefaultAttributes;
  459. }
  461. // initially set up the default attribute information based on doctype information
  462. void DOMElementImpl::setupDefaultAttributes()
  463. {
  464.     DOMDocument *tmpdoc = getOwnerDocument();
  465.     if ((fNode.fOwnerNode == 0) || (tmpdoc == 0) || (tmpdoc->getDoctype() == 0))
  466.         return;
  468.     DOMNode *eldef = ((DOMDocumentTypeImpl*)tmpdoc->getDoctype())->getElements()->getNamedItem(getNodeName());
  469.     DOMAttrMapImpl* defAttrs = (eldef == 0) ? 0 : (DOMAttrMapImpl *)(eldef->getAttributes());
  471.     if (defAttrs)
  472.         fDefaultAttributes = new (getOwnerDocument()) DOMAttrMapImpl(this, defAttrs);
  473. }
  475. DOMAttr * DOMElementImpl::setDefaultAttributeNode(DOMAttr *newAttr)
  476. {
  477.     if (fNode.isReadOnly())
  478.         throw DOMException(
  479.         DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  481.     if (newAttr->getNodeType() != DOMNode::ATTRIBUTE_NODE)
  482.         throw DOMException(DOMException::WRONG_DOCUMENT_ERR, 0);
  483.         // revisit.  Exception doesn't match test.
  485.     // This will throw INUSE if necessary
  486.     DOMAttr *oldAttr = (DOMAttr *) fDefaultAttributes->setNamedItem(newAttr);
  487.     fAttributes->hasDefaults(true);
  489.     return oldAttr;
  490. };
  493. DOMAttr *DOMElementImpl::setDefaultAttributeNodeNS(DOMAttr *newAttr)
  494. {
  495.     if (fNode.isReadOnly())
  496.         throw DOMException(
  497.             DOMException::NO_MODIFICATION_ALLOWED_ERR, 0);
  499.     if (newAttr -> getOwnerDocument() != this -> getOwnerDocument())
  500.         throw DOMException(DOMException::WRONG_DOCUMENT_ERR, 0);
  502.     // This will throw INUSE if necessary
  503.     DOMAttr *oldAttr = (DOMAttr *) fDefaultAttributes->setNamedItemNS(newAttr);
  504.     fAttributes->hasDefaults(true);
  506.     return oldAttr;
  507. }
  509. void DOMElementImpl::release()
  510. {
  511.     if (fNode.isOwned() && !fNode.isToBeReleased())
  512.         throw DOMException(DOMException::INVALID_ACCESS_ERR,0);
  514.     DOMDocumentImpl* doc = (DOMDocumentImpl*) getOwnerDocument();
  515.     if (doc) {
  516.         fNode.callUserDataHandlers(DOMUserDataHandler::NODE_DELETED, 0, 0);
  517.         fParent.release();
  518.         doc->release(this, DOMDocumentImpl::ELEMENT_OBJECT);
  519.     }
  520.     else {
  521.         // shouldn't reach here
  522.         throw DOMException(DOMException::INVALID_ACCESS_ERR,0);
  523.     }
  524. }
  526. const XMLCh* DOMElementImpl::getBaseURI() const
  527. {
  528.     const XMLCh* baseURI = fNode.fOwnerNode->getBaseURI();
  529.     if (fAttributes) {
  530.         const XMLCh xmlBaseString[] =
  531.         {
  532.             chLatin_x, chLatin_m, chLatin_l, chColon, chLatin_b, chLatin_a, chLatin_s, chLatin_e, chNull
  533.         };
  534.         DOMNode* attrNode = fAttributes->getNamedItem(xmlBaseString);
  535.         if (attrNode) {
  536.             const XMLCh* uri =  attrNode->getNodeValue();
  537.             if (uri && *uri) {// attribute value is always empty string
  538.                 try {
  539.                     XMLUri temp(baseURI, ((DOMDocumentImpl *)this->getOwnerDocument())->getMemoryManager());
  540.                     XMLUri temp2(&temp, uri, ((DOMDocumentImpl *)this->getOwnerDocument())->getMemoryManager());
  541.                     uri = ((DOMDocumentImpl *)this->getOwnerDocument())->cloneString(temp2.getUriText());
  542.                 }
  543.                 catch (...){
  544.                     // REVISIT: what should happen in this case?
  545.                     return 0;
  546.                 }
  547.                 return uri;
  548.             }
  549.         }
  550.     }
  551.     return baseURI;
  552. }
  556. //
  557. //   Functions inherited from Node
  558. //
  559.            DOMNode*         DOMElementImpl::appendChild(DOMNode *newChild)          {return fParent.appendChild (newChild); };
  560.            DOMNodeList*     DOMElementImpl::getChildNodes() const                   {return fParent.getChildNodes (); };
  561.            DOMNode*         DOMElementImpl::getFirstChild() const                   {return fParent.getFirstChild (); };
  562.            DOMNode*         DOMElementImpl::getLastChild() const                    {return fParent.getLastChild (); };
  563.      const XMLCh*           DOMElementImpl::getLocalName() const                    {return fNode.getLocalName (); };
  564.      const XMLCh*           DOMElementImpl::getNamespaceURI() const                 {return fNode.getNamespaceURI (); };
  565.            DOMNode*         DOMElementImpl::getNextSibling() const                  {return fChild.getNextSibling (); };
  566.      const XMLCh*           DOMElementImpl::getNodeValue() const                    {return fNode.getNodeValue (); };
  567.            DOMDocument*     DOMElementImpl::getOwnerDocument() const                {return fParent.fOwnerDocument; };
  568.      const XMLCh*           DOMElementImpl::getPrefix() const                       {return fNode.getPrefix (); };
  569.            DOMNode*         DOMElementImpl::getParentNode() const                   {return fChild.getParentNode (this); };
  570.            DOMNode*         DOMElementImpl::getPreviousSibling() const              {return fChild.getPreviousSibling (this); };
  571.            bool             DOMElementImpl::hasChildNodes() const                   {return fParent.hasChildNodes (); };
  572.            DOMNode*         DOMElementImpl::insertBefore(DOMNode *newChild, DOMNode *refChild)
  573.                                                                                     {return fParent.insertBefore (newChild, refChild); };
  574.            void             DOMElementImpl::normalize()                             {fParent.normalize (); };
  575.            DOMNode*         DOMElementImpl::removeChild(DOMNode *oldChild)          {return fParent.removeChild (oldChild); };
  576.            DOMNode*         DOMElementImpl::replaceChild(DOMNode *newChild, DOMNode *oldChild)
  577.                                                                                     {return fParent.replaceChild (newChild, oldChild); };
  578.            bool             DOMElementImpl::isSupported(const XMLCh *feature, const XMLCh *version) const
  579.                                                                                     {return fNode.isSupported (feature, version); };
  580.            void             DOMElementImpl::setPrefix(const XMLCh  *prefix)         {fNode.setPrefix(prefix); };
  581.            bool             DOMElementImpl::isSameNode(const DOMNode* other) const  {return fNode.isSameNode(other); };
  582.            void*            DOMElementImpl::setUserData(const XMLCh* key, void* data, DOMUserDataHandler* handler)
  583.                                                                                     {return fNode.setUserData(key, data, handler); };
  584.            void*            DOMElementImpl::getUserData(const XMLCh* key) const     {return fNode.getUserData(key); };
  585.            short            DOMElementImpl::compareTreePosition(const DOMNode* other) const {return fNode.compareTreePosition(other); };
  586.            const XMLCh*     DOMElementImpl::getTextContent() const                  {return fNode.getTextContent(); };
  587.            void             DOMElementImpl::setTextContent(const XMLCh* textContent){fNode.setTextContent(textContent); };
  588.            const XMLCh*     DOMElementImpl::lookupNamespacePrefix(const XMLCh* namespaceURI, bool useDefault) const  {return fNode.lookupNamespacePrefix(namespaceURI, useDefault); };
  589.            bool             DOMElementImpl::isDefaultNamespace(const XMLCh* namespaceURI) const {return fNode.isDefaultNamespace(namespaceURI); };
  590.            const XMLCh*     DOMElementImpl::lookupNamespaceURI(const XMLCh* prefix) const  {return fNode.lookupNamespaceURI(prefix); };
  591.            DOMNode*         DOMElementImpl::getInterface(const XMLCh* feature)      {return fNode.getInterface(feature); };
  595. bool DOMElementImpl::isEqualNode(const DOMNode* arg) const
  596. {
  597.     if (isSameNode(arg)) {
  598.         return true;
  599.     }
  601.     if (!fNode.isEqualNode(arg)) {
  602.         return false;
  603.     }
  605.     bool hasAttrs = hasAttributes();
  607.     if (hasAttrs != arg->hasAttributes()) {
  608.         return false;
  609.     }
  611.     if (hasAttrs) {
  612.         DOMNamedNodeMap* map1 = getAttributes();
  613.         DOMNamedNodeMap* map2 = arg->getAttributes();
  615.         XMLSize_t len = map1->getLength();
  616.         if (len != map2->getLength()) {
  617.             return false;
  618.         }
  619.         for (XMLSize_t i = 0; i < len; i++) {
  620.             DOMNode* n1 = map1->item(i);
  621.             if (!n1->getLocalName()) { // DOM Level 1 Node
  622.                 DOMNode* n2 = map2->getNamedItem(n1->getNodeName());
  623.                 if (!n2 || !n1->isEqualNode(n2)) {
  624.                     return false;
  625.                 }
  626.             }
  627.             else {
  628.                 DOMNode* n2 = map2->getNamedItemNS(n1->getNamespaceURI(),
  629.                                               n1->getLocalName());
  630.                 if (!n2 || !n1->isEqualNode(n2)) {
  631.                     return false;
  632.                 }
  633.             }
  634.         }
  635.     }
  637.     return fParent.isEqualNode(arg);
  638. };
  640. DOMNode* DOMElementImpl::rename(const XMLCh* namespaceURI, const XMLCh* name)
  641. {
  642.     DOMDocumentImpl* doc = (DOMDocumentImpl*) getOwnerDocument();
  644.     if (!namespaceURI || !*namespaceURI) {
  645.         fName = doc->getPooledString(name);
  646.         fAttributes->reconcileDefaultAttributes(getDefaultAttributes());
  648.         return this;
  649.     }
  650.     else {
  652.         // create a new ElementNS
  653.         DOMElementNSImpl* newElem = (DOMElementNSImpl*)doc->createElementNS(namespaceURI, name);
  655.         // transfer the userData
  656.         doc->transferUserData(castToNodeImpl(this), castToNodeImpl(newElem));
  658.         // remove old node from parent if any
  659.         DOMNode* parent = getParentNode();
  660.         DOMNode* nextSib = getNextSibling();
  661.         if (parent) {
  662.             parent->removeChild(this);
  663.         }
  665.         // move children to new node
  666.         DOMNode* child = getFirstChild();
  667.         while (child) {
  668.             removeChild(child);
  669.             newElem->appendChild(child);
  670.             child = getFirstChild();
  671.         }
  673.         // insert new node where old one was
  674.         if (parent) {
  675.             parent->insertBefore(newElem, nextSib);
  676.         }
  678.         // move specified attributes to new node
  679.         newElem->fAttributes->moveSpecifiedAttributes(fAttributes);
  681.         // and fire user data NODE_RENAMED event
  682.         castToNodeImpl(newElem)->callUserDataHandlers(DOMUserDataHandler::NODE_RENAMED, this, newElem);
  684.         return newElem;
  685.     }
  686. }
  688. const DOMTypeInfo *DOMElementImpl::getTypeInfo() const
  689. {
  690.     if(!fSchemaType) 
  691.         ((DOMElementImpl *)(this))->fSchemaType = new (getOwnerDocument()) DOMTypeInfoImpl(0, 0, (DOMDocumentImpl *)getOwnerDocument());
  692.     return fSchemaType;
  693. }
  696. void DOMElementImpl::setTypeInfo(const XMLCh* typeName, const XMLCh* typeURI) 
  697. {
  698.     fSchemaType = new (getOwnerDocument()) DOMTypeInfoImpl(typeName, typeURI, (DOMDocumentImpl *)getOwnerDocument());
  699. }
  701. XERCES_CPP_NAMESPACE_END