| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * $Id: DOMProcessingInstructionImpl.cpp 568078 2007-08-21 11:43:25Z amassari $ |
| */ |
| |
| #include "DOMProcessingInstructionImpl.hpp" |
| #include "DOMDocumentImpl.hpp" |
| #include "DOMNodeImpl.hpp" |
| #include "DOMStringPool.hpp" |
| #include "DOMRangeImpl.hpp" |
| |
| #include <xercesc/dom/DOMException.hpp> |
| #include <xercesc/dom/DOMNode.hpp> |
| |
| XERCES_CPP_NAMESPACE_BEGIN |
| |
| DOMProcessingInstructionImpl::DOMProcessingInstructionImpl(DOMDocument *ownerDoc, |
| const XMLCh *targt, |
| const XMLCh *dat) |
| : fNode(ownerDoc), fCharacterData(ownerDoc, dat), fBaseURI(0) |
| { |
| fNode.setIsLeafNode(true); |
| this->fTarget = ((DOMDocumentImpl *)ownerDoc)->cloneString(targt); |
| } |
| |
| |
| DOMProcessingInstructionImpl::DOMProcessingInstructionImpl( |
| const DOMProcessingInstructionImpl &other, |
| bool /*deep*/) |
| : DOMProcessingInstruction(other), |
| fNode(other.fNode), |
| fChild(other.fChild), |
| fCharacterData(other.fCharacterData), |
| fTarget(other.fTarget), |
| fBaseURI(other.fBaseURI) |
| { |
| fNode.setIsLeafNode(true); |
| } |
| |
| |
| DOMProcessingInstructionImpl::~DOMProcessingInstructionImpl() |
| { |
| } |
| |
| |
| DOMNode *DOMProcessingInstructionImpl::cloneNode(bool deep) const |
| { |
| DOMNode* newNode = new (getOwnerDocument(), DOMDocumentImpl::PROCESSING_INSTRUCTION_OBJECT) DOMProcessingInstructionImpl(*this, deep); |
| fNode.callUserDataHandlers(DOMUserDataHandler::NODE_CLONED, this, newNode); |
| return newNode; |
| } |
| |
| |
| const XMLCh * DOMProcessingInstructionImpl::getNodeName() const |
| { |
| return fTarget; |
| } |
| |
| |
| short DOMProcessingInstructionImpl::getNodeType() const { |
| return DOMNode::PROCESSING_INSTRUCTION_NODE; |
| } |
| |
| |
| /** A PI's "target" states what processor channel the PI's data |
| should be directed to. It is defined differently in HTML and XML. |
| |
| In XML, a PI's "target" is the first (whitespace-delimited) token |
| following the "<?" token that begins the PI. |
| |
| In HTML, target is always 0. |
| |
| Note that getNodeName is aliased to getTarget. |
| */ |
| const XMLCh * DOMProcessingInstructionImpl::getTarget() const |
| { |
| return fTarget; |
| } |
| |
| |
| void DOMProcessingInstructionImpl::release() |
| { |
| if (fNode.isOwned() && !fNode.isToBeReleased()) |
| throw DOMException(DOMException::INVALID_ACCESS_ERR,0, GetDOMNodeMemoryManager); |
| |
| DOMDocumentImpl* doc = (DOMDocumentImpl*) getOwnerDocument(); |
| if (doc) { |
| fNode.callUserDataHandlers(DOMUserDataHandler::NODE_DELETED, 0, 0); |
| fCharacterData.releaseBuffer(); |
| doc->release(this, DOMDocumentImpl::PROCESSING_INSTRUCTION_OBJECT); |
| } |
| else { |
| // shouldn't reach here |
| throw DOMException(DOMException::INVALID_ACCESS_ERR,0, GetDOMNodeMemoryManager); |
| } |
| } |
| |
| void DOMProcessingInstructionImpl::setBaseURI(const XMLCh* baseURI) { |
| this->fBaseURI = ((DOMDocumentImpl *)getOwnerDocument())->cloneString(baseURI); |
| } |
| |
| const XMLCh* DOMProcessingInstructionImpl::getBaseURI() const |
| { |
| return fBaseURI? fBaseURI : fNode.fOwnerNode->getBaseURI(); |
| } |
| |
| // Non standard extension for the range to work |
| DOMProcessingInstruction *DOMProcessingInstructionImpl::splitText(XMLSize_t offset) |
| { |
| if (fNode.isReadOnly()) |
| { |
| throw DOMException( |
| DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNodeMemoryManager); |
| } |
| XMLSize_t len = fCharacterData.fDataBuf->getLen(); |
| if (offset > len) |
| throw DOMException(DOMException::INDEX_SIZE_ERR, 0, GetDOMNodeMemoryManager); |
| |
| DOMProcessingInstruction *newText = |
| getOwnerDocument()->createProcessingInstruction(fTarget, |
| this->substringData(offset, len - offset)); |
| |
| DOMNode *parent = getParentNode(); |
| if (parent != 0) |
| parent->insertBefore(newText, getNextSibling()); |
| |
| fCharacterData.fDataBuf->chop(offset); |
| |
| if (this->getOwnerDocument() != 0) { |
| Ranges* ranges = ((DOMDocumentImpl *)this->getOwnerDocument())->getRanges(); |
| if (ranges != 0) { |
| XMLSize_t sz = ranges->size(); |
| if (sz != 0) { |
| for (XMLSize_t i =0; i<sz; i++) { |
| ranges->elementAt(i)->updateSplitInfo( this, newText, offset); |
| } |
| } |
| } |
| } |
| |
| return newText; |
| } |
| |
| // |
| // Delegation stubs for inherited functions |
| // |
| DOMNode* DOMProcessingInstructionImpl::appendChild(DOMNode *newChild) {return fNode.appendChild (newChild); } |
| DOMNamedNodeMap* DOMProcessingInstructionImpl::getAttributes() const {return fNode.getAttributes (); } |
| DOMNodeList* DOMProcessingInstructionImpl::getChildNodes() const {return fNode.getChildNodes (); } |
| DOMNode* DOMProcessingInstructionImpl::getFirstChild() const {return fNode.getFirstChild (); } |
| DOMNode* DOMProcessingInstructionImpl::getLastChild() const {return fNode.getLastChild (); } |
| const XMLCh* DOMProcessingInstructionImpl::getLocalName() const {return fNode.getLocalName (); } |
| const XMLCh* DOMProcessingInstructionImpl::getNamespaceURI() const {return fNode.getNamespaceURI (); } |
| DOMNode* DOMProcessingInstructionImpl::getNextSibling() const {return fChild.getNextSibling (); } |
| const XMLCh* DOMProcessingInstructionImpl::getNodeValue() const {return fCharacterData.getNodeValue (); } |
| DOMDocument* DOMProcessingInstructionImpl::getOwnerDocument() const {return fNode.getOwnerDocument (); } |
| const XMLCh* DOMProcessingInstructionImpl::getPrefix() const {return fNode.getPrefix (); } |
| DOMNode* DOMProcessingInstructionImpl::getParentNode() const {return fChild.getParentNode (this); } |
| DOMNode* DOMProcessingInstructionImpl::getPreviousSibling() const {return fChild.getPreviousSibling (this); } |
| bool DOMProcessingInstructionImpl::hasChildNodes() const {return fNode.hasChildNodes (); } |
| DOMNode* DOMProcessingInstructionImpl::insertBefore(DOMNode *newChild, DOMNode *refChild) |
| {return fNode.insertBefore (newChild, refChild); } |
| void DOMProcessingInstructionImpl::normalize() {fNode.normalize (); } |
| DOMNode* DOMProcessingInstructionImpl::removeChild(DOMNode *oldChild) {return fNode.removeChild (oldChild); } |
| DOMNode* DOMProcessingInstructionImpl::replaceChild(DOMNode *newChild, DOMNode *oldChild) |
| {return fNode.replaceChild (newChild, oldChild); } |
| bool DOMProcessingInstructionImpl::isSupported(const XMLCh *feature, const XMLCh *version) const |
| {return fNode.isSupported (feature, version); } |
| void DOMProcessingInstructionImpl::setPrefix(const XMLCh *prefix) {fNode.setPrefix(prefix); } |
| bool DOMProcessingInstructionImpl::hasAttributes() const {return fNode.hasAttributes(); } |
| bool DOMProcessingInstructionImpl::isSameNode(const DOMNode* other) const {return fNode.isSameNode(other); } |
| bool DOMProcessingInstructionImpl::isEqualNode(const DOMNode* arg) const {return fNode.isEqualNode(arg); } |
| void* DOMProcessingInstructionImpl::setUserData(const XMLCh* key, void* data, DOMUserDataHandler* handler) |
| {return fNode.setUserData(key, data, handler); } |
| void* DOMProcessingInstructionImpl::getUserData(const XMLCh* key) const {return fNode.getUserData(key); } |
| short DOMProcessingInstructionImpl::compareTreePosition(const DOMNode* other) const {return fNode.compareTreePosition(other); } |
| const XMLCh* DOMProcessingInstructionImpl::getTextContent() const {return fNode.getTextContent(); } |
| void DOMProcessingInstructionImpl::setTextContent(const XMLCh* textContent){fNode.setTextContent(textContent); } |
| const XMLCh* DOMProcessingInstructionImpl::lookupNamespacePrefix(const XMLCh* namespaceURI, bool useDefault) const {return fNode.lookupNamespacePrefix(namespaceURI, useDefault); } |
| bool DOMProcessingInstructionImpl::isDefaultNamespace(const XMLCh* namespaceURI) const {return fNode.isDefaultNamespace(namespaceURI); } |
| const XMLCh* DOMProcessingInstructionImpl::lookupNamespaceURI(const XMLCh* prefix) const {return fNode.lookupNamespaceURI(prefix); } |
| DOMNode* DOMProcessingInstructionImpl::getInterface(const XMLCh* feature) {return fNode.getInterface(feature); } |
| |
| // |
| // Delegation of CharacerData functions. |
| // |
| |
| |
| const XMLCh* DOMProcessingInstructionImpl::getData() const {return fCharacterData.getData();} |
| void DOMProcessingInstructionImpl::deleteData(XMLSize_t offset, XMLSize_t count) |
| {fCharacterData.deleteData(this, offset, count);} |
| const XMLCh* DOMProcessingInstructionImpl::substringData(XMLSize_t offset, XMLSize_t count) const |
| {return fCharacterData.substringData(this, offset, count);} |
| void DOMProcessingInstructionImpl::setData(const XMLCh *data) {fCharacterData.setData(this, data);} |
| void DOMProcessingInstructionImpl::setNodeValue(const XMLCh *nodeValue) {fCharacterData.setNodeValue (this, nodeValue); } |
| |
| |
| XERCES_CPP_NAMESPACE_END |
| |
