自学教程：C++ DOMException函数代码示例

voidAttr::setPrefix(String * prefix)  throw(DOMException){  if (isReadOnly())    throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);  // +++FIXME more checks  unicode::StringBuffer buf(prefix);  buf += ":";  buf += localName;  name = buf.internString();}

DOMNode *DOMAttrMapImpl::setNamedItem(DOMNode *arg){    if (arg->getNodeType() != DOMNode::ATTRIBUTE_NODE)        throw DOMException(DOMException::HIERARCHY_REQUEST_ERR, 0, GetDOMNamedNodeMapMemoryManager);    DOMDocument *doc = fOwnerNode->getOwnerDocument();    DOMNodeImpl *argImpl = castToNodeImpl(arg);    if(argImpl->getOwnerDocument() != doc)        throw DOMException(DOMException::WRONG_DOCUMENT_ERR, 0, GetDOMNamedNodeMapMemoryManager);    if (this->readOnly())        throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNamedNodeMapMemoryManager);    if ((arg->getNodeType() == DOMNode::ATTRIBUTE_NODE) && argImpl->isOwned() && (argImpl->fOwnerNode != fOwnerNode))        throw DOMException(DOMException::INUSE_ATTRIBUTE_ERR,0, GetDOMNamedNodeMapMemoryManager);    argImpl->fOwnerNode = fOwnerNode;    argImpl->isOwned(true);    int i=findNamePoint(arg->getNodeName());    DOMNode * previous=0;    if(i>=0)    {        previous = fNodes->elementAt(i);        fNodes->setElementAt(arg,i);    }    else    {        i=-1-i; // Insert point (may be end of list)        if(0==fNodes)        {            fNodes=new (doc) DOMNodeVector(doc);        }        fNodes->insertElementAt(arg,i);    }    if (previous != 0) {        castToNodeImpl(previous)->fOwnerNode = fOwnerNode->getOwnerDocument();        castToNodeImpl(previous)->isOwned(false);    }    return previous;}

Node *DocumentType::insertBefore(Node * newChild, Node * refChild)  throw(DOMException){  NodeType type = newChild->getNodeType();  if ((type != Node::ELEMENT_NODE) &&      (type != Node::COMMENT_NODE))    throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);  ParentNode::insertBefore(newChild, refChild);  if (type == Node::ELEMENT_NODE)    elements->setNamedItemNS(newChild);  return newChild;}

Event* Document::createEvent(const XMLString& eventType) const{	if (eventType == MutationEvent::DOMSubtreeModified          ||	    eventType == MutationEvent::DOMNodeInserted             ||		eventType == MutationEvent::DOMNodeRemoved              ||		eventType == MutationEvent::DOMNodeRemovedFromDocument  ||		eventType == MutationEvent::DOMNodeInsertedIntoDocument ||		eventType == MutationEvent::DOMAttrModified             ||		eventType == MutationEvent::DOMCharacterDataModified)	{		return new MutationEvent(const_cast<Document*>(this), eventType);	}	throw DOMException(DOMException::NOT_SUPPORTED_ERR);}

void CharacterData::deleteData(unsigned long offset, unsigned long count){	if (offset >= _data.length())		throw DOMException(DOMException::INDEX_SIZE_ERR);	if (events())	{		XMLString oldData = _data;		_data.replace(offset, count, EMPTY_STRING);		dispatchCharacterDataModified(oldData, _data);	}	else		_data.replace(offset, count, EMPTY_STRING);}

void DOMElementNSImpl::setName(const XMLCh *namespaceURI,                               const XMLCh *qualifiedName){    DOMDocumentImpl* ownerDoc = (DOMDocumentImpl *) fParent.fOwnerDocument;    this->fName = ownerDoc->getPooledString(qualifiedName);    int index = DOMDocumentImpl::indexofQualifiedName(qualifiedName);    if (index < 0)        throw DOMException(DOMException::NAMESPACE_ERR, 0, GetDOMNodeMemoryManager);    if (index == 0)    {        //qualifiedName contains no ':'        //        fPrefix = 0;        fLocalName = fName;    }    else    {	//0 < index < this->name.length()-1        //        fPrefix = ownerDoc->getPooledNString(qualifiedName, index);        fLocalName = ownerDoc->getPooledString(fName+index+1);        // Before we carry on, we should check if the prefix or localName are valid XMLName        if (!ownerDoc->isXMLName(fPrefix) || !ownerDoc->isXMLName(fLocalName))          throw DOMException(DOMException::NAMESPACE_ERR, 0, GetDOMNodeMemoryManager);    }    // DOM Level 3: namespace URI is never empty string.    //    const XMLCh * URI = DOMNodeImpl::mapPrefix (      fPrefix,      (!namespaceURI || !*namespaceURI) ? 0 : namespaceURI,      DOMNode::ELEMENT_NODE);    fNamespaceURI = (URI == 0) ? 0 : ownerDoc->getPooledString(URI);}

// Non standard extension for the range to workDOMProcessingInstruction *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);    DOMDocumentImpl *doc = (DOMDocumentImpl *)getOwnerDocument();    DOMProcessingInstruction *newText =      doc->createProcessingInstruction(        fTarget, this->substringData(offset, len - offset));    DOMNode *parent = getParentNode();    if (parent != 0)        parent->insertBefore(newText, getNextSibling());    fCharacterData.fDataBuf->chop(offset);    if (doc != 0) {        Ranges* ranges = doc->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;}

// removeNamedItemNS() - Remove the named item, and return it.//                      The caller can release the//                      returned item if it's not used//                      we can't do it here because the caller would//                      never see the returned node.DOMNode *DOMNamedNodeMapImpl::removeNamedItemNS(const XMLCh *namespaceURI,                                                 const XMLCh *localName){    if (this->readOnly())        throw DOMException(        DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNamedNodeMapMemoryManager);    // the map is indexed using the full name of nodes; to search given a namespace and a local name    // we have to do a linear search    for (int index = 0; index < MAP_SIZE; index++) {        if(fBuckets[index]==0)            continue;        int i = 0;        int size = fBuckets[index]->size();        for (i = 0; i < size; ++i) {            DOMNode *n=fBuckets[index]->elementAt(i);            const XMLCh * nNamespaceURI = n->getNamespaceURI();            const XMLCh * nLocalName = n->getLocalName();            if (!XMLString::equals(nNamespaceURI, namespaceURI))    //URI not match                continue;            else {                if (XMLString::equals(localName, nLocalName)                    ||                    (nLocalName == 0 && XMLString::equals(localName, n->getNodeName()))) {                    fBuckets[index]->removeElementAt(i);                    castToNodeImpl(n)->fOwnerNode = fOwnerNode->getOwnerDocument();                    castToNodeImpl(n)->isOwned(false);                    return n;                }            }        }    }    throw DOMException(DOMException::NOT_FOUND_ERR, 0, GetDOMNamedNodeMapMemoryManager);    return 0;}

 AttributeP Document::createAttributeNS(DOMString* nsUri,      DOMString* nsPrefix,      DOMString* localName,     DOMString* value ) {   Element* ownerElement = NULL;      if(_stateful) {      if(_currentElement) {       ownerElement = _currentElement;     }     else {       throw DOMException("createAttributeNS: found an attrNode without any owner element");     }   }   return new Attribute( localName, value, nsUri, nsPrefix, ownerElement, this); }

void CSSPrimitiveValue::setFloatValue( unsigned short unitType, float floatValue ){    if(!impl) return;    int exceptioncode = 0;    ((CSSPrimitiveValueImpl *)impl)->setFloatValue( unitType, floatValue, exceptioncode );#if KHTML_NO_EXCEPTIONS    if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )	{ _exceptioncode =  exceptioncode - CSSException::_EXCEPTION_OFFSET; return; }    if ( exceptioncode )	{ _exceptioncode =  exceptioncode ; return; }#else    if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )	throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET );    if ( exceptioncode )	throw DOMException( exceptioncode );#endif}

void DOMCharacterDataImpl::setNodeValue(const DOMNode *node, const XMLCh *value){    if (castToNodeImpl(node)->isReadOnly())        throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMCharacterDataImplMemoryManager);    fDataBuf->set(value);    if (node->getOwnerDocument() != 0) {        Ranges* ranges = ((DOMDocumentImpl *)node->getOwnerDocument())->getRanges();        if (ranges != 0) {            XMLSize_t sz = ranges->size();            if (sz != 0) {                for (XMLSize_t i =0; i<sz; i++) {                    ranges->elementAt(i)->receiveReplacedText((DOMNode*)node);                }            }        }    }}

voidAttr::setOwnerElement(Element * e){  if (e == null) {    if (ownerNode != null) {      ownerNode = getOwnerDocument();      isOwned(false);      isSpecified(true);      isId(false);    }  }  else {    if (isOwned())      throw DOMException(DOMException::INUSE_ATTRIBUTE_ERR);    ownerNode = e;    isOwned(true);    setId();  }}

void NodeAppender::appendChild(Node* newChild){	poco_check_ptr (newChild);	poco_assert (_pLast == 0 || _pLast->_pNext == 0);	if (static_cast<AbstractNode*>(newChild)->_pOwner != _pParent->_pOwner)		throw DOMException(DOMException::WRONG_DOCUMENT_ERR);			if (newChild->nodeType() == Node::DOCUMENT_FRAGMENT_NODE)	{		AbstractContainerNode* pFrag = static_cast<AbstractContainerNode*>(newChild);		AbstractNode* pChild = pFrag->_pFirstChild;		if (pChild)		{			if (_pLast)				_pLast->_pNext = pChild;			else				_pParent->_pFirstChild = pChild;			while (pChild)			{				_pLast = pChild;				pChild->_pParent = _pParent;				pChild = pChild->_pNext;			}			pFrag->_pFirstChild = 0;		}	}	else	{		AbstractNode* pAN = static_cast<AbstractNode*>(newChild);		pAN->duplicate();		if (pAN->_pParent) 			pAN->_pParent->removeChild(pAN);		pAN->_pParent = _pParent;		if (_pLast)			_pLast->_pNext = pAN;		else			_pParent->_pFirstChild = pAN;		_pLast = pAN;	}}

DOMNode* DOMNodeIteratorImpl::nextNode () {	if (fDetached)		throw DOMException(DOMException::INVALID_STATE_ERR, 0, GetDOMNodeIteratorMemoryManager);    // if root is 0 there is no next node->    if (!fRoot)			return 0;    DOMNode* aNextNode = fCurrentNode;    bool accepted = false; // the next node has not been accepted.    while (!accepted) {        // if last direction is not forward, repeat node->        if (!fForward && (aNextNode != 0)) {            //System.out.println("nextNode():!fForward:"+fCurrentNode.getNodeName());            aNextNode = fCurrentNode;        } else {        // else get the next node via depth-first            aNextNode = nextNode(aNextNode, true);        }        fForward = true; //REVIST: should direction be set forward before 0 check?        // nothing in the list. return 0.        if (!aNextNode) return 0;        // does node pass the filters and whatToShow?        accepted = acceptNode(aNextNode);        if (accepted) {            // if so, then the node is the current node->            fCurrentNode = aNextNode;            return fCurrentNode;        }    }    // no nodes, or no accepted nodes.    return 0;}

const XMLCh * DOMCharacterDataImpl::substringData(const DOMNode *node, XMLSize_t offset,                                           XMLSize_t count) const{    // Note: the C++ XMLCh * operation throws the correct DOMExceptions    //       when parameter values are bad.    //    XMLSize_t len = fDataBuf->getLen();    if (offset > len)        throw DOMException(DOMException::INDEX_SIZE_ERR, 0, GetDOMCharacterDataImplMemoryManager);    DOMDocumentImpl *doc = (DOMDocumentImpl *)node->getOwnerDocument();    XMLCh* newString;    XMLCh temp[4096];    if (len >= 4095)      newString = (XMLCh*) doc->getMemoryManager()->allocate        (            (len + 1) * sizeof(XMLCh)        );//new XMLCh[len+1];    else        newString = temp;    XMLString::copyNString(newString, fDataBuf->getRawBuffer()+offset, count);    newString[count] = chNull;    const XMLCh* retString = doc->getPooledString(newString);    if (len >= 4095)      doc->getMemoryManager()->deallocate(newString);//delete[] newString;    return retString;}

Attr* Element::removeAttributeNode(Attr* oldAttr){	poco_check_ptr (oldAttr);	if (_pOwner->events()) 		dispatchAttrModified(oldAttr, MutationEvent::REMOVAL, oldAttr->getValue(), EMPTY_STRING);	if (oldAttr != _pFirstAttr)	{		Attr* pCur = _pFirstAttr;		while (pCur->_pNext != oldAttr) pCur = static_cast<Attr*>(pCur->_pNext);		if (pCur)		{			pCur->_pNext = static_cast<Attr*>(pCur->_pNext->_pNext);		}		else throw DOMException(DOMException::NOT_FOUND_ERR);	}	else _pFirstAttr = static_cast<Attr*>(_pFirstAttr->_pNext);	oldAttr->_pNext   = 0;	oldAttr->_pParent = 0;	oldAttr->autoRelease();	return oldAttr;}

void DOMNodeImpl::setPrefix(const XMLCh *){    throw DOMException(DOMException::NAMESPACE_ERR, 0, GetDOMNodeMemoryManager);}