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

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

词法分析

开发平台：

Visual C++

DocumentImpl.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-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) 1999, 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: DocumentImpl.cpp,v 1.8 2003/05/22 02:26:50 knoaman Exp $
  59.  */
  61. //
  62. // file DocumentImpl.cpp
  63. //
  65. #include "DocumentImpl.hpp"
  66. #include "DOM_DOMException.hpp"
  67. #include "DOM_Node.hpp"
  69. #include "DocumentTypeImpl.hpp"
  70. #include "ElementImpl.hpp"
  71. #include "ElementNSImpl.hpp"
  72. #include "AttrImpl.hpp"
  73. #include "AttrNSImpl.hpp"
  74. #include "CDATASectionImpl.hpp"
  75. #include "CommentImpl.hpp"
  76. #include "DocumentFragmentImpl.hpp"
  77. #include "EntityImpl.hpp"
  78. #include "EntityReferenceImpl.hpp"
  79. #include "NotationImpl.hpp"
  80. #include "ProcessingInstructionImpl.hpp"
  81. #include "TextImpl.hpp"
  82. #include "DOM_DOMImplementation.hpp"
  83. #include "DeepNodeListImpl.hpp"
  84. #include "NamedNodeMapImpl.hpp"
  85. #include "DStringPool.hpp"
  86. #include <xercesc/internal/XMLReader.hpp>
  87. #include "TreeWalkerImpl.hpp"
  88. #include "NodeIteratorImpl.hpp"
  89. #include "NodeIDMap.hpp"
  90. #include "DOM_Document.hpp"
  91. #include <xercesc/util/HashPtr.hpp>
  92. #include "RangeImpl.hpp"
  93. #include "DOM_Document.hpp"
  95. XERCES_CPP_NAMESPACE_BEGIN
  98. static DOMString *nam = 0;  // will be lazily initialized to "#document"
  99. static XMLRegisterCleanup namCleanup;
  101. DocumentImpl::DocumentImpl(MemoryManager* const manager)
  102.     : ParentNode(this)
  103.     , docType(0)
  104.     , docElement(0)
  105.     , namePool(0)
  106.     , fNodeIDMap(0)
  107.     , iterators(0)
  108.     , treeWalkers(0)
  109.     , userData(0)
  110.     , ranges(0)
  111.     , fChanges(0)
  112.     , errorChecking(true)
  113.     , fMemoryManager(manager)
  114. {
  115.     namePool    = new (fMemoryManager) DStringPool(257, fMemoryManager);
  116. };
  119. //DOM Level 2
  120. DocumentImpl::DocumentImpl(const DOMString &fNamespaceURI,
  121.                            const DOMString &qualifiedName,
  122.                            DocumentTypeImpl *doctype,
  123.                            MemoryManager* const manager)
  124.     : ParentNode(this)
  125.     , docType(0)
  126.     , docElement(0)
  127.     , namePool(0)
  128.     , fNodeIDMap(0)
  129.     , iterators(0)
  130.     , treeWalkers(0)
  131.     , userData(0)
  132.     , ranges(0)
  133.     , fChanges(0)
  134.     , errorChecking(true)
  135.     , fMemoryManager(manager)
  136. {
  137. setDocumentType(doctype);
  138.     namePool    = new (fMemoryManager) DStringPool(257, fMemoryManager);
  139.     appendChild(createElementNS(fNamespaceURI, qualifiedName));  //root element
  140. }
  142. void DocumentImpl::setDocumentType(DocumentTypeImpl *doctype)
  143. {
  144. if (!doctype)
  145. return;
  147. if (doctype->getOwnerDocument() != null)
  148.         throw DOM_DOMException( //one doctype can belong to only one DocumentImpl
  149.         DOM_DOMException::WRONG_DOCUMENT_ERR, null);
  151.     doctype->setOwnerDocument(this);
  152.     doctype->getEntities()->ownerNode->setOwnerDocument(this);
  153.     doctype->getNotations()->ownerNode->setOwnerDocument(this);
  154.     doctype -> referenced();         // Warning, tricky!  An external (DOM_Node) reference
  155.                                      //  to a node normally bumps the reference count to its
  156.                                      //  document also.  But this could not happen when the
  157.                                      //  user created the DOM_DocumentType because there was
  158.                                      //  no document yet.  Now we have the document, and
  159.                                      //  the docs ref count must be got back in sync.
  162. appendChild(doctype);
  164. }
  166. DocumentImpl::~DocumentImpl()
  167. {
  168.     if (iterators != 0L) {
  169.         // The data in the vector is pointers owned by smart pointers, and will be cleaned up when they go away.
  170.         delete iterators;
  171.     }
  173.     if (treeWalkers != 0L) {
  174.         // The data in the vector is pointers owned by smart pointers, and will be cleaned up when they go away.
  175.         delete treeWalkers;
  176.     }
  178.     if (ranges != 0L) {
  179.         delete ranges;
  180.         ranges = 0;
  181.     }
  183.     if (userData) {
  184.         // make sure we won't access userData any further
  185.         hasUserData(false);
  186.         delete userData;
  187.     }
  189.     delete namePool;
  190.     // Do not delete docType and docElement pointers here.
  191.     //  These are also normal child nodes of the document,
  192.     //  and refcounting will take them out in the usual way.
  194.     delete fNodeIDMap;
  195. };
  198. NodeImpl *DocumentImpl::cloneNode(bool deep) {
  200.     // clone the node itself
  201.     DocumentImpl *newdoc = new (fMemoryManager) DocumentImpl(fMemoryManager);
  203.     // then the children by _importing_ them
  204.     if (deep) {
  205.         for (ChildNode *n = firstChild; n != null; n = n->nextSibling) {
  206.             newdoc->appendChild(newdoc->importNode(n, true));
  207. }
  208.     }
  209.     newdoc->setErrorChecking(errorChecking);
  210.     return newdoc;
  211. };
  214. DOMString DocumentImpl::getNodeName() {
  215.     return DStringPool::getStaticString("#document"
  216.                                        , &nam
  217.                                        , reinitDocumentImpl
  218.                                        , namCleanup);
  219. }
  222. short DocumentImpl::getNodeType() {
  223.     return DOM_Node::DOCUMENT_NODE;
  224. };
  227. // even though ownerDocument refers to this in this implementation
  228. // the DOM Level 2 spec says it must be null, so make it appear so
  229. DocumentImpl * DocumentImpl::getOwnerDocument() {
  230.     return null;
  231. }
  234. bool DocumentImpl::isDocumentImpl() {
  235.     return true;
  236. };
  239. AttrImpl *DocumentImpl::createAttribute(const DOMString &nam)
  240. {
  241.     if (errorChecking && !isXMLName(nam)) {
  242.         throw DOM_DOMException(DOM_DOMException::INVALID_CHARACTER_ERR,null);
  243.     }
  244.     return new (fMemoryManager) AttrImpl(this,nam);
  245. };
  249. CDATASectionImpl *DocumentImpl::createCDATASection(const DOMString &data) {
  250.     return new (fMemoryManager) CDATASectionImpl(this,data);
  251. };
  255. CommentImpl *DocumentImpl::createComment(const DOMString &data)
  256. {
  257.     return new (fMemoryManager) CommentImpl(this,data);
  258. };
  262. DocumentFragmentImpl *DocumentImpl::createDocumentFragment()
  263. {
  264.     return new (fMemoryManager) DocumentFragmentImpl(this);
  265. };
  269. DocumentTypeImpl *DocumentImpl::createDocumentType(const DOMString &nam)
  270. {
  271.     if (errorChecking && !isXMLName(nam)) {
  272.         throw DOM_DOMException(DOM_DOMException::INVALID_CHARACTER_ERR, null);
  273.     }
  274.     return new (fMemoryManager) DocumentTypeImpl(this, nam);
  275. };
  279. DocumentTypeImpl *
  280.     DocumentImpl::createDocumentType(const DOMString &qualifiedName,
  281.                                      const DOMString &publicId,
  282.                                      const DOMString &systemId)
  283. {
  284.     if (errorChecking && !isXMLName(qualifiedName)) {
  285.         throw DOM_DOMException(DOM_DOMException::INVALID_CHARACTER_ERR, null);
  286.     }
  287.     return new (fMemoryManager) DocumentTypeImpl(this, qualifiedName, publicId, systemId);
  288. };
  292. ElementImpl *DocumentImpl::createElement(const DOMString &tagName)
  293. {
  294.     if (errorChecking && !isXMLName(tagName)) {
  295.         throw DOM_DOMException(DOM_DOMException::INVALID_CHARACTER_ERR,null);
  296.     }
  297.     DOMString pooledTagName = this->namePool->getPooledString(tagName);
  298.     return new (fMemoryManager) ElementImpl(this,pooledTagName);
  299. };
  302. ElementImpl *DocumentImpl::createElement(const XMLCh *tagName)
  303. {
  304.     DOMString pooledTagName = this->namePool->getPooledString(tagName);
  305.     return new (fMemoryManager) ElementImpl(this,pooledTagName);
  306. };
  311. EntityImpl *DocumentImpl::createEntity(const DOMString &nam)
  312. {
  313.     if (errorChecking && !isXMLName(nam)) {
  314.         throw DOM_DOMException(DOM_DOMException::INVALID_CHARACTER_ERR, null);
  315.     }
  316.     return new (fMemoryManager) EntityImpl(this, nam);
  317. };
  321. EntityReferenceImpl *DocumentImpl::createEntityReference(const DOMString &nam)
  322. {
  323.     if (errorChecking && !isXMLName(nam)) {
  324.         throw DOM_DOMException(DOM_DOMException::INVALID_CHARACTER_ERR, null);
  325.     }
  326.     return new (fMemoryManager) EntityReferenceImpl(this, nam);
  327. };
  331. NotationImpl *DocumentImpl::createNotation(const DOMString &nam)
  332. {
  333.     if (errorChecking && !isXMLName(nam)) {
  334.         throw DOM_DOMException(DOM_DOMException::INVALID_CHARACTER_ERR, null);
  335.     }
  336.     return new (fMemoryManager) NotationImpl(this, nam);
  337. };
  341. ProcessingInstructionImpl *DocumentImpl::createProcessingInstruction(
  342.                                           const DOMString &target, const DOMString &data)
  343. {
  344.     if (errorChecking && !isXMLName(target)) {
  345.         throw DOM_DOMException(DOM_DOMException::INVALID_CHARACTER_ERR,null);
  346.     }
  347.     return new (fMemoryManager) ProcessingInstructionImpl(this,target,data);
  348. };
  353. TextImpl *DocumentImpl::createTextNode(const DOMString &data)
  354. {
  355.     return new (fMemoryManager) TextImpl(this,data);
  356. };
  359. NodeIteratorImpl* DocumentImpl::createNodeIterator (DOM_Node root,
  360.                                                     unsigned long whatToShow,
  361.                                                     DOM_NodeFilter* filter,
  362.                                                     bool entityReferenceExpansion,
  363.                                                     MemoryManager* const manager)
  364. {
  365. // Create the node iterator implementation object.
  366. // Add it to the vector of iterators that must be synchronized when a node is deleted.
  367. // The vector of iterators is kept in the "owner document" if there is one. If there isn't one, I assume that root is the
  368. // owner document.
  370.     NodeIteratorImpl* iter = new (manager) NodeIteratorImpl(root, whatToShow, filter, entityReferenceExpansion);
  371.     DOM_Document doc = root.getOwnerDocument();
  372.     DocumentImpl* impl;
  374.     if (! doc.isNull()) {
  375.         impl = (DocumentImpl *) doc.fImpl;
  376.     }
  377.     else
  378.         impl = (DocumentImpl *) root.fImpl;
  380.     if (impl->iterators == 0L) {
  381.         impl->iterators = new (manager) NodeIterators(1, false, manager);
  382.         impl->iterators->addElement(iter);
  383.     }
  385.     return iter;
  386. }
  389. TreeWalkerImpl* DocumentImpl::createTreeWalker (DOM_Node root, unsigned long whatToShow,
  390.                                                 DOM_NodeFilter* filter,
  391.                                                 bool entityReferenceExpansion,
  392.                                                 MemoryManager* const manager)
  393. {
  394. // See notes for createNodeIterator...
  396.     TreeWalkerImpl* twi = new (manager) TreeWalkerImpl(root, whatToShow, filter, entityReferenceExpansion);
  397.     DOM_Document doc = root.getOwnerDocument();
  398.     DocumentImpl* impl;
  400.     if (! doc.isNull()) {
  401.         impl = (DocumentImpl *) doc.fImpl;
  402.     }
  403.     else
  404.         impl = (DocumentImpl *) root.fImpl;
  406.     if (impl->treeWalkers == 0L) {
  407.         impl->treeWalkers = new (manager) TreeWalkers(1, false, manager);
  408.         impl->treeWalkers->addElement(twi);
  409.     }
  411.     return twi;
  412. }
  417. DocumentTypeImpl *DocumentImpl::getDoctype()
  418. {
  419.     return docType;
  420. };
  424. ElementImpl *DocumentImpl::getDocumentElement()
  425. {
  426.     return docElement;
  427. };
  431. DeepNodeListImpl *DocumentImpl::getElementsByTagName(const DOMString &tagname)
  432. {
  433.     return new (fMemoryManager) DeepNodeListImpl(this,tagname);
  434. };
  438. NodeImpl *DocumentImpl::insertBefore(NodeImpl *newChild, NodeImpl *refChild)
  439. {
  440.     // Only one such child permitted
  441.     if (errorChecking &&
  442.         ((newChild->isElementImpl() && docElement!=null) ||
  443.          (newChild->isDocumentTypeImpl() && docType!=null))) {
  444.         throw DOM_DOMException(DOM_DOMException::HIERARCHY_REQUEST_ERR,null);
  445.     }
  446.     ParentNode::insertBefore(newChild,refChild);
  448.     // If insert succeeded, cache the kid appropriately
  449.     if(newChild->isElementImpl())
  450.         docElement=(ElementImpl *)newChild;
  451.     else if(newChild->isDocumentTypeImpl())
  452.         docType=(DocumentTypeImpl *)newChild;
  454.     return newChild;
  455. };
  459. bool DocumentImpl::isXMLName(const DOMString &s)
  460. {
  461.     return XMLChar1_0::isValidName(s.rawBuffer(),s.length());
  462. };
  465. //  referenced().   Override this function here in class DocumentImpl because
  466. //                  we don't want the action taken in NodeImpl, which is
  467. //                  to add a reference to the node's owning document.
  468. //
  469. void DocumentImpl::referenced()
  470. {
  471.     // Intentionally empty.
  472. };
  476. NodeImpl *DocumentImpl::removeChild(NodeImpl *oldChild)
  477. {
  478.     ParentNode::removeChild(oldChild);
  480.     // If remove succeeded, un-cache the kid appropriately
  481.     if(oldChild->isElementImpl())
  482.         docElement=null;
  483.     else if(oldChild->isDocumentTypeImpl())
  484.         docType=null;
  486.     return oldChild;
  487. };
  490. //
  491. //    unreferenced()  will be called whenever the refernce count on
  492. //          this document goes from 1 to 0.  In all cases, when this
  493. //          happens to a document node (which is the case here), it
  494. //          is time to actually delete the document.
  495. //
  496. //          See also NodeImpl::referenced() and unreferenced(), which
  497. //          update document node ref counts based on references coming
  498. //          or going to nodes owned by the document.
  499. //
  500. void DocumentImpl::unreferenced()
  501. {
  502.     deleteIf(this);
  503. };
  506. //Introduced in DOM Level 2
  508. NodeImpl *DocumentImpl::importNode(NodeImpl *source, bool deep)
  509. {
  510.     NodeImpl *newnode=null;
  511.     bool oldErrorCheckingFlag = errorChecking;
  513.     switch (source->getNodeType())
  514.     {
  515.         case DOM_Node::ELEMENT_NODE :
  516.         {
  517.             ElementImpl *newelement;
  518.             if (source->getLocalName() == null)
  519.                 newelement = createElement(source->getNodeName());
  520.             else
  521.                 newelement = createElementNS(source->getNamespaceURI(),
  522.                                              source->getNodeName());
  523.             NamedNodeMapImpl *srcattr=source->getAttributes();
  524.             if (srcattr!=null)
  525.                 for(unsigned int i=0;i<srcattr->getLength();++i)
  526.                 {
  527.                     AttrImpl *attr = (AttrImpl *) srcattr->item(i);
  528.                     AttrImpl * pOldAttr = null;
  529.                     if (attr -> getSpecified())
  530.                     { // not a default attribute
  531.                         AttrImpl *nattr = (AttrImpl *) importNode(attr, true);
  532.                         if (attr -> getLocalName() == null)
  533.                             pOldAttr = newelement->setAttributeNode(nattr);
  534.                         else
  535.                             pOldAttr = newelement->setAttributeNodeNS(nattr);
  537.                         if (pOldAttr)
  538.                         {
  539.                             if (pOldAttr->nodeRefCount == 0)
  540.                                 NodeImpl::deleteIf(pOldAttr);
  541.                         }
  542.                     }
  543.                 }
  545.             newnode=newelement;
  546.         }
  547.         break;
  548.     case DOM_Node::ATTRIBUTE_NODE :
  549.         {
  550.             if (source->getLocalName() == null)
  551.                 newnode = createAttribute(source->getNodeName());
  552.             else
  553.                 newnode = createAttributeNS(source->getNamespaceURI(),
  554.                                         source->getNodeName());
  555.         // if source is an AttrImpl from this very same implementation
  556.         // avoid creating the child nodes if possible
  557. //        if (source instanceof AttrImpl) {
  558.             AttrImpl *attr = (AttrImpl *) source;
  559.             if (attr->hasStringValue()) {
  560.                 AttrImpl *newattr = (AttrImpl *) newnode;
  561.                 newattr->setValue(attr->getValue());
  562.                 deep = false;
  563.             }
  564.             else {
  565.                 deep = true;
  566.             }
  567. //        }
  568. //        else {
  569. //            // Kids carry value
  570. //            deep = true;
  571. //        }
  572.         }
  573.         break;
  574.     case DOM_Node::TEXT_NODE :
  575.         newnode = createTextNode(source->getNodeValue());
  576.         break;
  577.     case DOM_Node::CDATA_SECTION_NODE :
  578.         newnode = createCDATASection(source->getNodeValue());
  579.         break;
  580.     case DOM_Node::ENTITY_REFERENCE_NODE :
  581.         {
  582.             EntityReferenceImpl* newentityRef = createEntityReference(source->getNodeName());
  583.             newnode=newentityRef;
  584.             errorChecking = false;
  585.             newentityRef->setReadOnly(false, true); //allow deep import temporarily
  586.         }
  587.         break;
  588.     case DOM_Node::ENTITY_NODE :
  589.         {
  590.             EntityImpl *srcentity=(EntityImpl *)source;
  591.             EntityImpl *newentity = createEntity(source->getNodeName());
  592.             newentity->setPublicId(srcentity->getPublicId());
  593.             newentity->setSystemId(srcentity->getSystemId());
  594.             newentity->setNotationName(srcentity->getNotationName());
  595.             // Kids carry additional value
  596.             newnode=newentity;
  597.             newentity->setReadOnly(false, true);// allow deep import temporarily
  598.         }
  599.         break;
  600.     case DOM_Node::PROCESSING_INSTRUCTION_NODE :
  601.         newnode = createProcessingInstruction(source->getNodeName(),
  602.                                               source->getNodeValue());
  603.         break;
  604.     case DOM_Node::COMMENT_NODE :
  605.         newnode = createComment(source->getNodeValue());
  606.         break;
  607.     case DOM_Node::DOCUMENT_TYPE_NODE :
  608.         {
  609.             DocumentTypeImpl *srcdoctype = (DocumentTypeImpl *)source;
  610.             DocumentTypeImpl *newdoctype = (DocumentTypeImpl *)
  611.                 createDocumentType(srcdoctype->getNodeName(),
  612.                                    srcdoctype->getPublicId(),
  613.                                    srcdoctype->getSystemId());
  614.             // Values are on NamedNodeMaps
  615.             NamedNodeMapImpl *smap = srcdoctype->getEntities();
  616.             NamedNodeMapImpl *tmap = newdoctype->getEntities();
  617.             if(smap != null) {
  618.                 for(unsigned int i = 0; i < smap->getLength(); i++) {
  619.                     tmap->setNamedItem(importNode(smap->item(i), true));
  620.                 }
  621.             }
  622.             smap = srcdoctype->getNotations();
  623.             tmap = newdoctype->getNotations();
  624.             if (smap != null) {
  625.                 for(unsigned int i = 0; i < smap->getLength(); i++) {
  626.                     tmap->setNamedItem(importNode(smap->item(i), true));
  627.                 }
  628.             }
  629.             // NOTE: At this time, the DOM definition of DocumentType
  630.             // doesn't cover Elements and their Attributes. domimpl's
  631.             // extentions in that area will not be preserved, even if
  632.             // copying from domimpl to domimpl. We could special-case
  633.             // that here. Arguably we should. Consider. ?????
  634.             newnode = newdoctype;
  635.         }
  636.         break;
  637.     case DOM_Node::DOCUMENT_FRAGMENT_NODE :
  638.         newnode = createDocumentFragment();
  639.         // No name, kids carry value
  640.         break;
  641.     case DOM_Node::NOTATION_NODE :
  642.         {
  643.             NotationImpl *srcnotation=(NotationImpl *)source;
  644.             NotationImpl *newnotation = createNotation(source->getNodeName());
  645.             newnotation->setPublicId(srcnotation->getPublicId());
  646.             newnotation->setSystemId(srcnotation->getSystemId());
  647.             // Kids carry additional value
  648.             newnode=newnotation;
  649.             // No name, no value
  650.             break;
  651.         }
  653.     case DOM_Node::DOCUMENT_NODE : // Document can't be child of Document
  654.     default:                       // Unknown node type
  655.         throw DOM_DOMException(DOM_DOMException::NOT_SUPPORTED_ERR, null);
  656.     }
  658.     // If deep, replicate and attach the kids.
  659.     if (deep)
  660.         for (NodeImpl *srckid = source->getFirstChild();
  661.              srckid != null;
  662.              srckid = srckid->getNextSibling()) {
  663.             newnode->appendChild(importNode(srckid, true));
  664.         }
  665.     if (newnode->getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE
  666.         || newnode->getNodeType() == DOM_Node::ENTITY_NODE) {
  667.          ((EntityReferenceImpl*)newnode)->setReadOnly(true, true);
  668.          errorChecking = oldErrorCheckingFlag;
  669.     }
  671.     return newnode;
  672. };
  675. ElementImpl *DocumentImpl::createElementNS(const DOMString &fNamespaceURI,
  676. const DOMString &qualifiedName)
  677. {
  678.     if (errorChecking && !isXMLName(qualifiedName)) {
  679.         throw DOM_DOMException(DOM_DOMException::INVALID_CHARACTER_ERR,null);
  680.     }
  681.     //DOMString pooledTagName = this->namePool->getPooledString(qualifiedName);
  682.     return new (fMemoryManager) ElementNSImpl(this, fNamespaceURI, qualifiedName);
  683. }
  686. AttrImpl *DocumentImpl::createAttributeNS(const DOMString &fNamespaceURI,
  687. const DOMString &qualifiedName)
  688. {
  689.     if (!isXMLName(qualifiedName)) {
  690.         throw DOM_DOMException(DOM_DOMException::INVALID_CHARACTER_ERR,null);
  691.     }
  692.     return new (fMemoryManager) AttrNSImpl(this, fNamespaceURI, qualifiedName);
  693. }
  696. DeepNodeListImpl *DocumentImpl::getElementsByTagNameNS(const DOMString &fNamespaceURI,
  697. const DOMString &fLocalName)
  698. {
  699.     return new (fMemoryManager) DeepNodeListImpl(this, fNamespaceURI, fLocalName);
  700. }
  703. ElementImpl *DocumentImpl::getElementById(const DOMString &elementId)
  704. {
  705.     if (fNodeIDMap == 0)
  706.         return null;
  708.     AttrImpl *theAttr = fNodeIDMap->find(elementId);
  709.     if (theAttr == null)
  710.     return null;
  712.     return theAttr->getOwnerElement();
  713. }
  716. //Return the index > 0 of ':' in the given qualified name qName="prefix:localName".
  717. //Return 0 if there is no ':', or -1 if qName is malformed such as ":abcd".
  718. int DocumentImpl::indexofQualifiedName(const DOMString & qName)
  719. {
  720.     //Check if s = prefix:localName, name or malformed
  721.     const XMLCh *qNameP = qName.rawBuffer();
  722.     int qNameLen = qName.length(); //note: qName[qNameLen] may not be 0
  723.     int index = -1, count = 0;
  724.     for (int i = 0; i < qNameLen; ++i)
  725. if (*qNameP++ == chColon) {
  726.     index = i;
  727.     ++count; //number of ':' found
  728. }
  729.     if (qNameLen == 0 || count > 1 || index == 0 || index == qNameLen-1)
  730.         return -1;
  731.     return count == 0 ? 0 : index;
  732. }
  735. XMLDeclImpl* DocumentImpl::createXMLDecl(const DOMString& version, const DOMString& encoding, const DOMString& standalone)
  736. {
  737.     return new (fMemoryManager) XMLDeclImpl(this, version, encoding, standalone);
  738. }
  740. RangeImpl* DocumentImpl::createRange()
  741. {
  743.     RangeImpl* range = new (fMemoryManager) RangeImpl(DOM_Document(this));
  745.     if (ranges == 0L) {
  746.         ranges = new (fMemoryManager) RangeImpls(1, false, fMemoryManager);
  747.     }
  748.     ranges->addElement(range);
  749.     return range;
  750. }
  752. RangeImpls* DocumentImpl::getRanges()
  753. {
  754.     return ranges;
  755. }
  757. void DocumentImpl::removeRange(RangeImpl* range)
  758. {
  759.     if (ranges != null) {
  760.         unsigned int sz = ranges->size();
  761.         if (sz !=0) {
  762.             for (unsigned int i =0; i<sz; i++) {
  763.                 if (ranges->elementAt(i) == range) {
  764.                     ranges->removeElementAt(i);
  765.                     delete range;
  766.                     break;
  767.                 }
  768.             }
  769.         }
  770.     }
  771. }
  773. /** Uses the kidOK lookup table to check whether the proposed
  774.     tree structure is legal.
  776.     ????? It feels like there must be a more efficient solution,
  777.     but for the life of me I can't think what it would be.
  778. */
  779. bool DocumentImpl::isKidOK(NodeImpl *parent, NodeImpl *child)
  780. {
  781.       static int kidOK[14];
  783.       if (kidOK[DOM_Node::DOCUMENT_NODE] == 0)
  784.       {
  785.           kidOK[DOM_Node::DOCUMENT_NODE] =
  786.               1 << DOM_Node::ELEMENT_NODE |
  787.               1 << DOM_Node::PROCESSING_INSTRUCTION_NODE |
  788.               1 << DOM_Node::COMMENT_NODE |
  789.               1 << DOM_Node::DOCUMENT_TYPE_NODE |
  790.               1 << DOM_Node::XML_DECL_NODE;
  792.           kidOK[DOM_Node::DOCUMENT_FRAGMENT_NODE] =
  793.               kidOK[DOM_Node::ENTITY_NODE] =
  794.               kidOK[DOM_Node::ENTITY_REFERENCE_NODE] =
  795.               kidOK[DOM_Node::ELEMENT_NODE] =
  796.               1 << DOM_Node::ELEMENT_NODE |
  797.               1 << DOM_Node::PROCESSING_INSTRUCTION_NODE |
  798.               1 << DOM_Node::COMMENT_NODE |
  799.               1 << DOM_Node::TEXT_NODE |
  800.               1 << DOM_Node::CDATA_SECTION_NODE |
  801.               1 << DOM_Node::ENTITY_REFERENCE_NODE |
  802.               1 << DOM_Node::XML_DECL_NODE;
  804.           kidOK[DOM_Node::ATTRIBUTE_NODE] =
  805.               1 << DOM_Node::TEXT_NODE |
  806.               1 << DOM_Node::ENTITY_REFERENCE_NODE;
  808.           kidOK[DOM_Node::PROCESSING_INSTRUCTION_NODE] =
  809.               kidOK[DOM_Node::COMMENT_NODE] =
  810.               kidOK[DOM_Node::TEXT_NODE] =
  811.               kidOK[DOM_Node::CDATA_SECTION_NODE] =
  812.               kidOK[DOM_Node::NOTATION_NODE] =
  813.               0;
  814.       };
  815.       int p=parent->getNodeType();
  816.       int ch = child->getNodeType();
  817.       return (kidOK[p] & 1<<ch) != 0;
  818. }
  820. void DocumentImpl::setUserData(NodeImpl* n, void* data)
  821. {
  822. if (!userData && data)
  823. userData = new (fMemoryManager) RefHashTableOf<void>
  824.         (
  825.             29
  826.             , false
  827.             , new (fMemoryManager) HashPtr()
  828.             , fMemoryManager
  829.         );
  830. if (!data && userData)
  831. userData->removeKey((void*)n);
  832. else
  833. userData->put((void*)n,data);
  834. }
  836. void* DocumentImpl::getUserData(NodeImpl* n)
  837. {
  838. if (userData)
  839. return userData->get((void*)n);
  840. else
  841. return null;
  842. }
  844. void* DocumentImpl::getUserData()
  845. {
  846. return (hasUserData()) ? getUserData(this) : null;
  847. }
  849. void DocumentImpl::setUserData(void* val)
  850. {
  851. setUserData(this, val);
  852. if (val)
  853. hasUserData(true);
  854. else
  855. hasUserData(false);
  856. };
  858. /**
  859.  * Denotes that this node has changed.
  860.  */
  861. void DocumentImpl::changed() {
  862.     fChanges++;
  863. }
  865. /**
  866.  * Returns the number of changes to this node.
  867.  */
  868. int DocumentImpl::changes() {
  869.     return fChanges;
  870. }
  872. // -----------------------------------------------------------------------
  873. //  Notification that lazy data has been deleted
  874. // -----------------------------------------------------------------------
  875. void DocumentImpl::reinitDocumentImpl() {
  876. delete nam;
  877. nam = 0;
  878. }
  880. XERCES_CPP_NAMESPACE_END