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); } }
void Importer::addEdgeToScene (xercesc::DOMNode* edgeNode, Scene* scene) { XMLCh* vertex_ch = XMLString::transcode("vertex"); std::vector<int> edge; for (XMLSize_t i = 0; i < edgeNode->getChildNodes()->getLength(); ++i ) { DOMNode* node = edgeNode->getChildNodes()->item(i); // Nodo <vertex>? if ((node->getNodeType() == DOMNode::ELEMENT_NODE) && XMLString::equals(node->getNodeName(), vertex_ch)) edge.push_back(atoi(XMLString::transcode (node->getFirstChild()->getNodeValue()))); } // Recuperar los vértices a partir de su index, // para generar y añadir el arco. GraphVertex *v1 = scene->getGraph()->getVertex(edge[0]); GraphVertex *v2 = scene->getGraph()->getVertex(edge[1]); if (v1 && v2) { scene->getGraph()->addEdge(v1, v2); } XMLString::release(&vertex_ch); }
string CXmlConfig::getValue(DOMNode* parentNode, const string& itemName) { string strValue; string strName; DOMNode* firstChildNode = NULL; charArrayToString(parentNode->getNodeName(), strName); if (strName == itemName) { firstChildNode = parentNode->getFirstChild(); if (firstChildNode != NULL) charArrayToString(firstChildNode->getNodeValue(), strValue); return strValue; } DOMNodeList* nodeList = parentNode->getChildNodes(); for (unsigned int i = 0; i < nodeList->getLength(); ++i) { DOMNode* nodeTemp = nodeList->item(i); if (nodeTemp->getNodeType() == DOMNode::ELEMENT_NODE) { charArrayToString(nodeTemp->getNodeName(), strName); if (strName == itemName) { firstChildNode = nodeTemp->getFirstChild(); if (firstChildNode != NULL) charArrayToString(firstChildNode->getNodeValue(), strValue); break; } } } return strValue; }
// 解析TMS返回xml bool CTMSSensor::ParseXmlFromTMS(std::string &retXml,int &nRet) { XercesDOMParser *ptrParser = new XercesDOMParser; ptrParser->setValidationScheme( XercesDOMParser::Val_Never ); ptrParser->setDoNamespaces( true ); ptrParser->setDoSchema( false ); ptrParser->setLoadExternalDTD( false ); InputSource* ptrInputsource = new MemBufInputSource((XMLByte*)retXml.c_str(), retXml.size(), "bufId"); try { ptrParser->parse(*ptrInputsource); DOMDocument* ptrDoc = ptrParser->getDocument(); // 读取ret节点 DOMNodeList *ptrNodeList = ptrDoc->getElementsByTagName(C2X("ret")); if(ptrNodeList == NULL) { LOGIDFMT(ULOG_ERROR,ERROR_PARSE_MONITORSTATE_XML,"ParseXmlFromTMS:ret"); return false; } else { if(ptrNodeList->getLength() == 0) { LOGIDFMT(ULOG_ERROR,ERROR_PARSE_MONITORSTATE_XML,"ParseXmlFromTMS:ret"); return false; } DOMNode* ptrNode = ptrNodeList->item(0); char* pstate = XMLString::transcode(ptrNode->getFirstChild()->getNodeValue()); std::string str_state = pstate; if(!str_state.empty()) { nRet = atoi(str_state.c_str()); } XMLString::release(&pstate); //LOGINFFMT("%s,%s\n",str_name.c_str(),str_state.c_str()); } } catch( XMLException& e ) { char* message = XMLString::transcode( e.getMessage() ); XMLString::release( &message ); LOGIDFMT(ULOG_ERROR,ERROR_PARSE_MONITORSTATE_XML,message); delete ptrParser; ptrInputsource = NULL; delete ptrInputsource; ptrParser = NULL; } delete ptrParser; delete ptrInputsource; ptrInputsource = NULL; ptrParser = NULL; return true; }
bool FrameLabelObjectImp::fromXml(DOMNode* pDocument, unsigned int version) { if (pDocument == NULL || Service<SessionManager>()->isSessionLoading() == false) { return false; } if (!TextObjectImp::fromXml(pDocument, version)) { return false; } DOMElement* pElement = static_cast<DOMElement*> (pDocument); if (pElement != NULL) { // Set the autoMode setting (which will also call setLocked) setAutoMode(StringUtilities::fromXmlString<bool>(A(pElement->getAttribute(X("autoMode"))))); // If the object is not currently locked, load all frames if (getLocked() == false) { for (DOMNode* pChild = pDocument->getFirstChild(); pChild != NULL; pChild = pChild->getNextSibling()) { if (XMLString::equals(pChild->getNodeName(), X("Animations"))) { vector<Animation*> animations; for (DOMNode* pGrandchild = pChild->getFirstChild(); pGrandchild != NULL; pGrandchild = pGrandchild->getNextSibling()) { if (XMLString::equals(pGrandchild->getNodeName(), X("Animation"))) { pElement = dynamic_cast<DOMElement*>(pGrandchild); if (pElement != NULL) { string id(A(pElement->getAttribute(X("id")))); if (id.empty() != true) { Animation* pAnim = dynamic_cast<Animation*>(Service<SessionManager>()->getSessionItem(id)); if (pAnim != NULL) { animations.push_back(pAnim); } } } } } setAnimations(animations); } } } } return true; }
/*! \brief It fills the member of the _nbPDMLPacket structure that is in charge of the packet dump. This function extracts the value of the given node, it transforms it into an ascii buffer (appropriately located into the m_asciiBuffer buffer), and updates the appropriate pointer to it. This function updates also the pointer into the m_asciiBuffer buffer in order to point to the first free location in this buffer. \param PDMLDocument The DOMDocument associated to the current PDML packet. \param TmpBuffer: pointer to the CAsciiBuffer class, which manages an ascii temporary buffer in which the content of the XML node has to be stored. The XML content will be stored in binary. \param ErrBuf: user-allocated buffer (of length 'ErrBufSize') that will keep an error message (if one). This buffer will always be NULL terminated. \param ErrBufSize: size of the previous buffer. \return nbSUCCESS if everything is fine, nbFAILURE if some error occurred. In case of errors, the error message will be returned in the ErrBuf parameter. */ int CPDMLReader::FormatDumpItem(DOMDocument *PDMLDocument, CAsciiBuffer *TmpBuffer, char *ErrBuf, int ErrBufSize) { XMLCh TempBuffer[NETPDL_MAX_STRING + 1]; const XMLCh *TempPtr; char* AsciiBufPtr; DOMNodeList *DumpList; DOMNode *DumpItem; DOMNode *DumpValue; // Let's initialize this member, just in case m_packetSummary.PacketDump= NULL; XMLString::transcode(PDML_DUMP, TempBuffer, NETPDL_MAX_STRING); // Now, let's get the raw packet dump DumpList= PDMLDocument->getElementsByTagName(TempBuffer); if (DumpList == NULL) return nbSUCCESS; // Let's check if the PDML fragment contains also the packet dump. If not, let's return. DumpItem= DumpList->item(0); if (DumpItem == NULL) return nbSUCCESS; DumpValue= DumpItem->getFirstChild(); if (DumpValue == NULL) return nbSUCCESS; TempPtr= DumpValue->getNodeValue(); // If the XML element contains that attribute, transform it in ascii and return it to the caller if (TempPtr && (*TempPtr) ) { AsciiBufPtr= TmpBuffer->TranscodeAndStore( (wchar_t *)(XMLCh *) TempPtr); if (AsciiBufPtr == NULL) { errorsnprintf(__FILE__, __FUNCTION__, __LINE__, ErrBuf, ErrBufSize, "%s", TmpBuffer->GetLastError() ); return nbFAILURE; } // Since we're tranforming an ascii buffer into a bin buffer (which is half the previous one) // there's no problem of buffer overflow. ConvertHexDumpAsciiToHexDumpBin(AsciiBufPtr, (unsigned char *) AsciiBufPtr, strlen(AsciiBufPtr) + 1); m_packetSummary.PacketDump= (unsigned char *) AsciiBufPtr; } else // otherwise, append 'NULL' m_packetSummary.PacketDump= NULL; return nbSUCCESS; }
float Importer::getValueFromTag (xercesc::DOMNode* node, const XMLCh *tag) { for (XMLSize_t i = 0; i < node->getChildNodes()->getLength(); ++i ) { DOMNode* aux = node->getChildNodes()->item(i); if (aux->getNodeType() == DOMNode::ELEMENT_NODE && XMLString::equals(aux->getNodeName(), tag)) return atof(XMLString::transcode(aux->getFirstChild()->getNodeValue())); } return 0.0; }
bool ConfigurationFileHandler::getSubAlgorithm(std::string algorithm, std::string subalgorithm, std::string* result){ #ifdef BRICS_XERCES_ENABLE if (errorsOccured) { return false; } DOMNode* current = NULL; DOMNode* attributeNode = NULL; XMLCh* algorithmName = XMLString::transcode(algorithm.c_str()); XMLCh* subAlgorithmName = XMLString::transcode(subalgorithm.c_str()); XMLCh* implementationString = XMLString::transcode("implementation"); bool subAlgorithmFound = false; DOMDocument* doc = parser->getDocument(); DOMNodeList* root = doc->getElementsByTagName(algorithmName); if (root->getLength() > 1) { LOG(WARNING) << "More than one " << algorithm << " found, taking the first one"; } else if(root->getLength() < 1) { LOG(WARNING) << "No algorithm called " << algorithm << " found."; return false; //TODO release resouces } current = root->item(0); //search in children notes for (current = current->getFirstChild()->getNextSibling(); current!=NULL; current = current->getNextSibling()) { string nodeName = XMLString::transcode(current->getNodeName()); if (nodeName.compare(subalgorithm) == 0) { DOMNamedNodeMap* attributesList = current->getAttributes(); attributeNode = attributesList->getNamedItem(implementationString); if (attributeNode != 0) { *result = XMLString::transcode(attributeNode->getNodeValue()); subAlgorithmFound = true; break; //take only first found } } } XMLString::release(&algorithmName); XMLString::release(&subAlgorithmName); XMLString::release(&implementationString); return subAlgorithmFound; #else return false; #endif }
void AcsAlarmTestCase::verifyDescriptorElement(DOMDocument * doc) { // Verify the descriptor element DOMNodeList * descriptorNodes = doc->getElementsByTagName(DESCRIPTOR_TAG_NAME); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; no descriptor element found", (NULL != descriptorNodes && descriptorNodes->getLength() == 1)); // check value of descriptor DOMNode * descriptorElementNode = descriptorNodes->item(0); DOMNode * descriptorTextNode = descriptorElementNode->getFirstChild(); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; descriptor value is not present or null", (NULL != descriptorTextNode)); const XMLCh * descriptorNodeValue = descriptorTextNode->getNodeValue(); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of descriptor is not correct", (NULL != descriptorNodeValue && XMLString::equals(descriptorNodeValue, DESCRIPTOR_VALUE_XMLCH))); }
void ColladaObject::ReadRootNode(const DOMNode* node) { _ASSERTE(node != NULL); DOMNode* currentNode = node->getFirstChild(); while( currentNode != NULL ) { #if _DEBUG // デバッグ時に名前をチェックする為に const XMLCh* name = currentNode->getNodeName(); #endif if( IsElementNode( currentNode ) ) { if( Is_COLLADA_NodeName( currentNode ) ) // COLLADA要素が見つかった場合 { currentNode = currentNode->getFirstChild(); // 子ノードを処理する continue; } else if( Is_asset_NodeName( currentNode ) ) // asset要素が見つかった場合 { _ASSERTE(elemAsset == NULL); // 必ず1つ存在するのでこの時点ではNULL elemAsset = new AssetElement(); elemAsset->ReadNode( currentNode ); } else if( Is_library_NodeName( currentNode ) ) // library要素が見つかった場合 { LibraryElement* elemLibrary = CreateLibraryElement( currentNode ); if( elemLibrary != NULL ) { elemLibrary->ReadNode( currentNode ); vecElemLibrary.push_back( elemLibrary ); } } else if( Is_scene_NodeName( currentNode ) ) // scene要素が見つかった場合 { _ASSERTE(elemScene == NULL); // 0または1つ存在するのでこの時点ではNULL elemScene = new SceneElement(); elemScene->ReadNode( currentNode ); } } currentNode = currentNode->getNextSibling(); // 次の要素を処理する } }
void DomSerializer::GetString(const char* key, CStdString& value, bool required) { // Find the right node DOMNode* stringNode = FindElementByName(m_node, CStdString(key)); if(stringNode) { // Now, the string associated to element should be the first child (text element) DOMNode* textNode = stringNode->getFirstChild(); if (textNode && textNode->getNodeType() == DOMNode::TEXT_NODE) { value = XMLStringToLocal(textNode->getNodeValue()); } } else if (required) { throw(CStdString("DomSerializer::GetString: required parameter missing:") + key); } }
bool ArcObjectImp::fromXml(DOMNode* pDocument, unsigned int version) { if (pDocument == NULL) { return false; } bool bSuccess = false; // Load the ellipse properties first to ensure that it has a valid bounding box when loading the arc properties DOMNode* pObjectNode = NULL; for (pObjectNode = pDocument->getFirstChild(); pObjectNode != NULL; pObjectNode = pObjectNode->getNextSibling()) { if (XMLString::equals(pObjectNode->getNodeName(), X("objects"))) { DOMNode* pEllipseNode = NULL; for (pEllipseNode = pObjectNode->getFirstChild(); pEllipseNode != NULL; pEllipseNode = pEllipseNode->getNextSibling()) { if (XMLString::equals(pEllipseNode->getNodeName(), X("Graphic"))) { DOMElement* pElement(static_cast<DOMElement*> (pEllipseNode)); string type(A(pElement->getAttribute(X("type")))); GraphicObjectType objectType = StringUtilities::fromXmlString<GraphicObjectType>(type); if (objectType == ELLIPSE_OBJECT) { bSuccess = mpEllipse->fromXml(pEllipseNode, version); break; } } } } } if (bSuccess == true) { bSuccess = FilledObjectImp::fromXml(pDocument, version); } return bSuccess; }
bool ScaleBarObjectImp::fromXml(DOMNode* pDocument, unsigned int version) { if (pDocument == NULL) { return false; } bool bSuccess = FilledObjectImp::fromXml(pDocument, version); if (bSuccess == true) { mpGroup->removeAllObjects(true); DOMNode* pObjectNode = pDocument->getFirstChild(); while (pObjectNode != NULL) { if (XMLString::equals(pObjectNode->getNodeName(), X("objects"))) { DOMNode* pGroupNode = pObjectNode->getFirstChild(); while (pGroupNode != NULL) { if (XMLString::equals(pGroupNode->getNodeName(), X("Graphic"))) { DOMElement* pElement(static_cast<DOMElement*> (pGroupNode)); string type(A(pElement->getAttribute(X("type")))); GraphicObjectType objectType = StringUtilities::fromXmlString<GraphicObjectType>(type); if (objectType == GROUP_OBJECT) { bSuccess = mpGroup->fromXml(pGroupNode, version); break; } } pGroupNode = pGroupNode->getNextSibling(); } } pObjectNode = pObjectNode->getNextSibling(); } } return bSuccess; }
void XercesUpdateFactory::applyInsertAsFirst(const PendingUpdate &update, DynamicContext *context) { const XercesNodeImpl *nodeImpl = (const XercesNodeImpl*)update.getTarget()->getInterface(Item::gXQilla); DOMNode *domnode = const_cast<DOMNode*>(nodeImpl->getDOMNode()); DOMNode *firstChild = domnode->getFirstChild(); DOMDocument *doc = const_cast<DOMDocument*>(XPath2Utils::getOwnerDoc(domnode)); bool untyped = nodeImpl->dmNodeKind() == Node::element_string && XPath2Utils::equals(nodeImpl->getTypeName(), DocumentCache::g_szUntyped) && XPath2Utils::equals(nodeImpl->getTypeURI(), SchemaSymbols::fgURI_SCHEMAFORSCHEMA); bool containsElementOrText = false; Result children = update.getValue(); Item::Ptr item; while((item = children->next(context)).notNull()) { const XercesNodeImpl *childImpl = (const XercesNodeImpl*)item->getInterface(Item::gXQilla); DOMNode *newChild = importNodeFix(doc, const_cast<DOMNode*>(childImpl->getDOMNode()), /*deep*/true); if(childImpl->dmNodeKind() == Node::element_string || childImpl->dmNodeKind() == Node::text_string) { containsElementOrText = true; } // If the type-name property of $target is xs:untyped, then upd:setToUntyped() is invoked on each // element or attribute node in $content. if(!untyped) setTypes(newChild, childImpl->getDOMNode()); // For each node in $content, the parent property is set to parent($target). // The children property of $target is modified to add the nodes in $content just before $target, // preserving their order. domnode->insertBefore(newChild, firstChild); } // If at least one of the nodes in $content is an element or text node, upd:removeType($target) is invoked. if(containsElementOrText) { removeType(domnode); } addToPutSet(update.getTarget(), &update, context); }
list<string> ClsSettingsReader::getListLastFiles() { #ifdef DEBUG_CLSSETTINGSREADER cout << "ClsSettingsReader::getListLastFiles()" << endl; #endif list<string> lstLFO; if(iSysSettingReaderState != PARSER_BUFFER_PARSED){ ClsSettingsReaderException clsSettingsReaderException(ClsSettingsReaderException::BUFFER_NOT_PARSED); throw clsSettingsReaderException; } DOMNodeList* dnlstTemp = ddocIqrSetting->getElementsByTagName(XMLString::transcode(ClsTagLibrary::lastFilesOpen())); DOMNode* dnTemp=NULL; if ( dnlstTemp->getLength() == 1){ dnTemp = dnlstTemp->item(0); } else if ( dnlstTemp->getLength() < 1) { ClsSettingsReaderException clsSettingsReaderException(ClsSettingsReaderException::ENTITY_NOT_FOUND); throw clsSettingsReaderException; } DOMNodeList* dnlstFiles = dnTemp->getChildNodes(); unsigned int ii = 0; while( ii< dnlstFiles->getLength()){ DOMNode* dnTempTemp = dnlstFiles->item(ii); if(dnTempTemp->getNodeType() == 1){ DOMNode* dnValue = dnTempTemp->getFirstChild(); if(dnValue!=NULL){ string strValue = XMLString::transcode(dnValue->getNodeValue()); lstLFO.push_back(strValue); } } ii++; } return lstLFO; };
void DeltaApplyEngine::Subtree_Insert( DOMNode *insertSubtreeRoot, XID_t parentXID, int position, const char *xidmapStr ) { vddprintf(( " insert xidmap=%s at (parent=%d, pos=%d)\n", xidmapStr, (int)parentXID, position)); DOMNode* contentNode = xiddoc->importNode( insertSubtreeRoot, true ); DOMNode* parentNode = xiddoc->getXidMap().getNodeWithXID( parentXID ); if (parentNode==NULL) THROW_AWAY(("parent node with XID=%d not found",(int)parentXID)); int actual_pos = 1 ; if ((position!=1)&&(!parentNode->hasChildNodes())) THROW_AWAY(("parent has no children but position is %d",position)); DOMNode* brother = parentNode->getFirstChild(); while (actual_pos < position) { brother = brother->getNextSibling(); actual_pos++; if ((brother==NULL)&&(actual_pos<position)) THROW_AWAY(("parent has %d children but position is %d",actual_pos-1, position)); } // Add node to the tree if (brother==NULL) parentNode->appendChild( contentNode ); else parentNode->insertBefore( contentNode, brother ); xiddoc->getXidMap().mapSubtree( xidmapStr, contentNode ); }
void DomSerializer::GetList(const char* key, std::list<ObjectRef>& value, Object& model, bool required) { // Find the node corresponding to the object list wanting to be populated DOMNode* listNode = FindElementByName(m_node, CStdString(key)); // Create a new serializer and affect it to this object if (listNode) { // Iterate over the nodes ##### DOMNode* node = listNode->getFirstChild(); while(node) { // Create a new object instance ObjectRef newObject = model.NewInstance(); try { DomSerializer serializer(newObject.get()); serializer.DeSerialize(node); value.push_back(newObject); } catch (CStdString& e) { // For now, do not interrupt the deserialization process. // in the future, we might let this exception go through if the node has been // recognized to bear the proper tag name ; } node = node->getNextSibling(); } } else if (required) { throw(CStdString("DomSerializer::GetList: required node missing:") + key); } }
const XMLCh* DOMNodeImpl::getTextContent(XMLCh* pzBuffer, unsigned int& rnBufferLength) const { unsigned int nRemainingBuffer = rnBufferLength; rnBufferLength = 0; if (pzBuffer) *pzBuffer = 0; 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: { DOMNode* current = thisNode->getFirstChild(); while (current != NULL) { if (current->getNodeType() != DOMNode::COMMENT_NODE && current->getNodeType() != DOMNode::PROCESSING_INSTRUCTION_NODE) { if (pzBuffer) { unsigned int nContentLength = nRemainingBuffer; castToNodeImpl(current)->getTextContent(pzBuffer + rnBufferLength, nContentLength); rnBufferLength += nContentLength; nRemainingBuffer -= nContentLength; } else { unsigned int nContentLength = 0; castToNodeImpl(current)->getTextContent(NULL, nContentLength); rnBufferLength += nContentLength; } } current = current->getNextSibling(); } } break; case DOMNode::ATTRIBUTE_NODE: case DOMNode::TEXT_NODE: case DOMNode::CDATA_SECTION_NODE: case DOMNode::COMMENT_NODE: case DOMNode::PROCESSING_INSTRUCTION_NODE: { const XMLCh* pzValue = thisNode->getNodeValue(); unsigned int nStrLen = XMLString::stringLen(pzValue); if (pzBuffer) { unsigned int nContentLength = (nRemainingBuffer >= nStrLen) ? nStrLen : nRemainingBuffer; XMLString::copyNString(pzBuffer + rnBufferLength, pzValue, nContentLength); rnBufferLength += nContentLength; nRemainingBuffer -= nContentLength; } else { rnBufferLength += nStrLen; } } break; /*** DOCUMENT_NODE DOCUMENT_TYPE_NODE NOTATION_NODE ***/ default: break; } return pzBuffer; }
void spep::AttributeProcessor::processAttributeStatements( AttributeStatementPointerList &attributeStatements, spep::PrincipalSession &principalSession ) { // Loop through all the AttributeStatement elements in the list. AttributeStatementPointerList::iterator attributeStatementIterator; for( attributeStatementIterator = attributeStatements.begin(); attributeStatementIterator != attributeStatements.end(); ++attributeStatementIterator ) { saml2::assertion::AttributeStatementType *attributeStatement = *attributeStatementIterator; // Loop through the attributes in the statement. saml2::assertion::AttributeStatementType::Attribute_iterator attributeIterator; for( attributeIterator = attributeStatement->Attribute().begin(); attributeIterator != attributeStatement->Attribute().end(); ++attributeIterator ) { UnicodeString attributeNameText( UnicodeStringConversion::toUnicodeString( attributeIterator->Name().c_str() ) ); std::map<UnicodeString,UnicodeString>::iterator renameIterator = this->_attributeRenameMap.find( attributeNameText ); if( renameIterator != this->_attributeRenameMap.end() ) { _localLogger.debug() << "Found rename for attribute " << UnicodeStringConversion::toString(attributeNameText) << "... renaming to " << UnicodeStringConversion::toString( renameIterator->second ); attributeNameText = renameIterator->second; } // This will either a) create an empty list, or b) let us append to the existing list of values std::vector<UnicodeString>& attributeValueList = principalSession.getAttributeMap()[attributeNameText]; _localLogger.debug() << "Current attribute: " << UnicodeStringConversion::toString( attributeNameText ) << ". " << attributeValueList.size() << " value(s) already populated."; // Loop through the attribute values. saml2::assertion::AttributeType::AttributeValue_iterator attributeValueIterator; for( attributeValueIterator = attributeIterator->AttributeValue().begin(); attributeValueIterator != attributeIterator->AttributeValue().end(); ++attributeValueIterator ) { // Add the attribute value into the list. DOMNode *attributeValueNode = attributeValueIterator->_node(); if( attributeValueNode->getNodeType() == DOMNode::ELEMENT_NODE ) { DOMNode *attributeValueChildNode = attributeValueNode->getFirstChild(); while( attributeValueChildNode != NULL ) { if( attributeValueChildNode->getNodeType() == DOMNode::TEXT_NODE ) { DOMText *attributeValueTextNode = static_cast<DOMText*>(attributeValueChildNode); UnicodeString attributeValueText( UnicodeStringConversion::toUnicodeString( attributeValueTextNode->getData() ) ); _localLogger.debug() << "Adding value: " << UnicodeStringConversion::toString( attributeNameText ) << " = " << UnicodeStringConversion::toString( attributeValueText ); attributeValueList.push_back( attributeValueText ); break; } else { attributeValueChildNode = attributeValueChildNode->getNextSibling(); } } } } _localLogger.debug() << "Finished processing attributes for " << UnicodeStringConversion::toString( attributeNameText ) << ". " << attributeValueList.size() << " attributes in value list now."; } } }
DOMNode* DeltaReverse( DOMNode *deltaElement, DOMDocument *reversedDoc ) { vddprintf((" reversing time-version header\n")); DOMNode* reversedElement = reversedDoc->importNode( deltaElement, false ); //DOMString from = deltaElement.getAttributes().getNamedItem("from").getNodeValue() ; //DOMString to = deltaElement.getAttributes().getNamedItem("to" ).getNodeValue() ; const XMLCh* from = deltaElement->getAttributes()->getNamedItem(XMLString::transcode("from"))->getNodeValue() ; const XMLCh* to = deltaElement->getAttributes()->getNamedItem(XMLString::transcode("to"))->getNodeValue() ; reversedElement->getAttributes()->getNamedItem(XMLString::transcode("to"))->setNodeValue( from ); reversedElement->getAttributes()->getNamedItem(XMLString::transcode("from"))->setNodeValue( to ); DOMNode* fromXidMap = deltaElement->getAttributes()->getNamedItem(XMLString::transcode("fromXidMap")); DOMNode* toXidMap = deltaElement->getAttributes()->getNamedItem(XMLString::transcode("toXidMap")); if (fromXidMap!=NULL) { //DOMString from = fromXidMap.getNodeValue(); reversedElement->getAttributes()->getNamedItem(XMLString::transcode("toXidMap"))->setNodeValue( fromXidMap->getNodeValue() ); } if (toXidMap!=NULL) { //DOMString to = toXidMap.getNodeValue(); reversedElement->getAttributes()->getNamedItem(XMLString::transcode("fromXidMap"))->setNodeValue( toXidMap->getNodeValue() ); } // No chanhges in the delta -> ok if (!deltaElement->hasChildNodes()) return( reversedElement ); // Input : read Elementary Operation DOMNode* child = deltaElement->getFirstChild() ; // Output : precedent will be used to write Elementary Operation in reverse order DOMNode* precedent = NULL; // =NULL by default while (child != NULL) { if (child->getNodeType()!=DOMNode::ELEMENT_NODE) THROW_AWAY(("Bad type (%d) for Delta Operation Node", (int)child->getNodeType())); DOMElement* operationNode = (DOMElement*) child ; XyLatinStr operation(child->getLocalName()); // Reverse DELETE into INSERT if (strcmp(operation, "d")==0) { vddprintf((" reversing delete into insert\n")); DOMElement* iElement = reversedDoc->createElementNS(XYDIFF_XYDELTA_NS, XMLString::transcode("xy:i")) ; CopyAttr(iElement, operationNode, XMLString::transcode("par"), true); CopyAttr(iElement, operationNode, XMLString::transcode("pos"), true); CopyAttr(iElement, operationNode, XMLString::transcode("xm"), true); CopyAttr(iElement, operationNode, XMLString::transcode("move"), false); CopyAttr(iElement, operationNode, XMLString::transcode("update"), false); CopyContent(iElement, operationNode); reversedElement->insertBefore( iElement, precedent ) ; precedent = iElement ; } // Reverse INSERT into DELETE else if (strcmp(operation, "i")==0) { vddprintf((" reversing insert into delete\n")); DOMElement *iElement = reversedDoc->createElementNS(XYDIFF_XYDELTA_NS, XMLString::transcode("xy:d")) ; CopyAttr(iElement, operationNode, XMLString::transcode("par"), true); CopyAttr(iElement, operationNode, XMLString::transcode("pos"), true); CopyAttr(iElement, operationNode, XMLString::transcode("xm"), true); CopyAttr(iElement, operationNode, XMLString::transcode("move"), false); CopyAttr(iElement, operationNode, XMLString::transcode("update"), false); CopyContent(iElement, operationNode); reversedElement->insertBefore( iElement, precedent ) ; precedent = iElement ; } // Attribute Update else if (strcmp(operation, "au")==0) { vddprintf((" reversing attribute update\n")); //DOMString xidElem = operationNode.getAttributes().getNamedItem("xid").getNodeValue(); //DOMString attrName = operationNode.getAttributes().getNamedItem("a").getNodeValue(); //DOMString oldValue = operationNode.getAttributes().getNamedItem("ov").getNodeValue(); //DOMString newValue = operationNode.getAttributes().getNamedItem("nv").getNodeValue(); const XMLCh* xidElem = operationNode->getAttributes()->getNamedItem(XMLString::transcode("xid"))->getNodeValue(); const XMLCh* attrName = operationNode->getAttributes()->getNamedItem(XMLString::transcode("a"))->getNodeValue(); const XMLCh* oldValue = operationNode->getAttributes()->getNamedItem(XMLString::transcode("ov"))->getNodeValue(); const XMLCh* newValue = operationNode->getAttributes()->getNamedItem(XMLString::transcode("nv"))->getNodeValue(); DOMElement* auElement = reversedDoc->createElementNS(XYDIFF_XYDELTA_NS, XMLString::transcode("xy:au")); auElement->setAttribute(XMLString::transcode("xid"), xidElem); auElement->setAttribute(XMLString::transcode("a"), attrName); auElement->setAttribute(XMLString::transcode("nv"), oldValue); auElement->setAttribute(XMLString::transcode("ov"), newValue); reversedElement->insertBefore(auElement, precedent); precedent = auElement ; } // Attribute Delete else if (strcmp(operation, "ad")==0) { vddprintf((" reversing attribute insert into attribute delete\n")); //DOMString xidElem = operationNode.getAttributes().getNamedItem("xid").getNodeValue(); //DOMString attrName = operationNode.getAttributes().getNamedItem("a").getNodeValue(); //DOMString attrVal = operationNode.getAttributes().getNamedItem("v").getNodeValue(); const XMLCh* xidElem = operationNode->getAttributes()->getNamedItem(XMLString::transcode("xid"))->getNodeValue(); const XMLCh* attrName = operationNode->getAttributes()->getNamedItem(XMLString::transcode("a"))->getNodeValue(); const XMLCh* attrVal = operationNode->getAttributes()->getNamedItem(XMLString::transcode("v"))->getNodeValue(); DOMElement* aiElement = reversedDoc->createElementNS(XYDIFF_XYDELTA_NS, XMLString::transcode("xy:ai")); aiElement->setAttribute(XMLString::transcode("xid"), xidElem); aiElement->setAttribute(XMLString::transcode("a"), attrName); aiElement->setAttribute(XMLString::transcode("v"), attrVal); reversedElement->insertBefore(aiElement, precedent); precedent = aiElement ; } // Attribute Insert else if (strcmp(operation, "ai")==0) { vddprintf((" reversing attribute delete into attribute insert\n")); //DOMString xidElem = operationNode.getAttributes().getNamedItem("xid").getNodeValue(); //DOMString attrName = operationNode.getAttributes().getNamedItem("a").getNodeValue(); //DOMString attrVal = operationNode.getAttributes().getNamedItem("v").getNodeValue(); const XMLCh* xidElem = operationNode->getAttributes()->getNamedItem(XMLString::transcode("xid"))->getNodeValue(); const XMLCh* attrName = operationNode->getAttributes()->getNamedItem(XMLString::transcode("a"))->getNodeValue(); const XMLCh* attrVal = operationNode->getAttributes()->getNamedItem(XMLString::transcode("v"))->getNodeValue(); DOMElement* adElement = reversedDoc->createElementNS(XYDIFF_XYDELTA_NS, XMLString::transcode("xy:ad")); adElement->setAttribute(XMLString::transcode("xid"), xidElem); adElement->setAttribute(XMLString::transcode("a"), attrName); adElement->setAttribute(XMLString::transcode("v"), attrVal); reversedElement->insertBefore(adElement, precedent); precedent = adElement ; } // Reverse UPDATE to UPDATE else if (strcmp(operation, "u")==0) { vddprintf((" reversing update\n")); DOMNode* oldValue = child->getFirstChild() ; if ( oldValue==NULL ) throw ReverseUpdateException("<update> has no child!"); DOMNode* newValue = oldValue->getNextSibling() ; if ( newValue==NULL ) throw ReverseUpdateException("<update> has only one child!"); //DOMString xid= child.getAttributes().getNamedItem("xid").getNodeValue() ; const XMLCh* xid= child->getAttributes()->getNamedItem(XMLString::transcode("xid"))->getNodeValue() ; DOMElement *uElement = reversedDoc->createElementNS(XYDIFF_XYDELTA_NS, XMLString::transcode("xy:u")) ; uElement->setAttribute(XMLString::transcode("xid"), xid); DOMElement* uOld = reversedDoc->createElementNS(XYDIFF_XYDELTA_NS, XMLString::transcode("xy:ov")); DOMNode* uOldText = reversedDoc->importNode( newValue->getFirstChild(), true ); uOld->appendChild( uOldText ); DOMElement* uNew = reversedDoc->createElementNS(XYDIFF_XYDELTA_NS, XMLString::transcode("xy:nv")); DOMNode* uNewText = reversedDoc->importNode( oldValue->getFirstChild(), true ); uNew->appendChild( uNewText ); uElement->appendChild( uOld ) ; uElement->appendChild( uNew ) ; reversedElement->insertBefore( uElement, precedent ) ; precedent = uElement ; } else if (strcmp(operation, "renameRoot")==0) { vddprintf((" reversing renameRoot operation\n")); const XMLCh* rFrom = operationNode->getAttributes()->getNamedItem(XMLString::transcode("from"))->getNodeValue(); const XMLCh* rTo = operationNode->getAttributes()->getNamedItem(XMLString::transcode("to"))->getNodeValue(); DOMElement *rrElement = reversedDoc->createElementNS(XYDIFF_XYDELTA_NS, XMLString::transcode("xy:renameRoot")); rrElement->setAttribute(XMLString::transcode("from"), rTo); rrElement->setAttribute(XMLString::transcode("to"), rFrom); reversedElement->insertBefore(rrElement, precedent); precedent = rrElement ; } else { throw DeltaReverseException("Invalid Data", "main", "Unknown operation <" + std::string(operation) + ">") ; } child = child->getNextSibling(); } return ( reversedElement ) ; }
static void ProcessMETRIC(DOMNode *node, Analysis::Args& args, Prof::Metric::Mgr& mMgr) { static XMLCh* FILE = XMLString::transcode("FILE"); static XMLCh* COMPUTE = XMLString::transcode("COMPUTE"); static XMLCh* NAMEATTR = XMLString::transcode("name"); static XMLCh* DISPLAYATTR = XMLString::transcode("display"); static XMLCh* PERCENTATTR = XMLString::transcode("percent"); //static XMLCh* PROPAGATEATTR = XMLString::transcode("propagate"); static XMLCh* DISPLAYNAMEATTR = XMLString::transcode("displayName"); static XMLCh* SORTBYATTR = XMLString::transcode("sortBy"); // get metric attributes string metricNm = getAttr(node, NAMEATTR); string metricDispNm = getAttr(node, DISPLAYNAMEATTR); bool metricDoDisp = (getAttr(node, DISPLAYATTR) == "true"); bool metricDoPercent = (getAttr(node,PERCENTATTR) == "true"); bool metricDoSortBy = (getAttr(node,SORTBYATTR) == "true"); if (metricNm.empty()) { ConfigParser_Throw("METRIC: Invalid name: '" << metricNm << "'."); } else if (mMgr.metric(metricNm) != NULL) { ConfigParser_Throw("METRIC: Metric name '" << metricNm << "' was previously defined."); } if (metricDispNm.empty()) { ConfigParser_Throw("METRIC: Invalid displayName: '" << metricDispNm << "'."); } DIAG_DevMsgIf(DBG, "CONFIG: " << "METRIC: name=" << metricNm << " display=" << ((metricDoDisp) ? "true" : "false") << " doPercent=" << ((metricDoPercent) ? "true" : "false") << " sortBy=" << ((metricDoSortBy) ? "true" : "false") << " metricDispNm=" << metricDispNm); // should have exactly one child DOMNode* metricImpl = node->getFirstChild(); for ( ; metricImpl != NULL; metricImpl = metricImpl->getNextSibling()) { if (metricImpl->getNodeType() == DOMNode::TEXT_NODE) { // DTD ensures this can't contain anything but white space continue; } else if (metricImpl->getNodeType() == DOMNode::COMMENT_NODE) { continue; } const XMLCh* metricType = metricImpl->getNodeName(); if (XMLString::equals(metricType, FILE)) { ProcessFILE(metricImpl, args, mMgr, metricNm, metricDoDisp, metricDoPercent, metricDoSortBy, metricDispNm); } else if (XMLString::equals(metricType,COMPUTE)) { //bool propagateComputed = false; // tallent // (getAttr(metricImpl, PROPAGATEATTR) == "computed"); DOMNode* child = metricImpl->getFirstChild(); for (; child != NULL; child = child->getNextSibling()) { if (child->getNodeType() == DOMNode::TEXT_NODE) { // DTD ensures this can't contain anything but white space continue; } else if (child->getNodeType() == DOMNode::COMMENT_NODE) { continue; } using namespace Prof; Metric::AExpr* expr = makeMathMLExpr(metricNm.c_str(), child, mMgr); mMgr.insert(new Metric::DerivedDesc(metricNm, metricNm, expr, metricDoDisp, metricDoSortBy, metricDoPercent, false/*isPercent*/)); } } else { ConfigParser_Throw("Unexpected METRIC type '" << XMLString::transcode(metricType) << "'."); } } }
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); } }
void DSIGSignedInfo::load(void) { if (mp_signedInfoNode == 0) { // Attempt to load an empty signature element throw XSECException(XSECException::LoadEmptySignedInfo); } if (!strEquals(getDSIGLocalName(mp_signedInfoNode), "SignedInfo")) { throw XSECException(XSECException::LoadNonSignedInfo); } DOMNode * tmpSI = mp_signedInfoNode->getFirstChild(); // Check for CanonicalizationMethod while (tmpSI != 0 && (tmpSI->getNodeType() != DOMNode::ELEMENT_NODE)) // Skip text and comments tmpSI = tmpSI->getNextSibling(); if (tmpSI == 0 || !strEquals(getDSIGLocalName(tmpSI), "CanonicalizationMethod")) { throw XSECException(XSECException::ExpectedDSIGChildNotFound, "Expected <CanonicalizationMethod> as first child of <SignedInfo>"); } // Determine what the canonicalization method is DOMNamedNodeMap *tmpAtts = tmpSI->getAttributes(); DOMNode *algorithm = tmpAtts->getNamedItem(DSIGConstants::s_unicodeStrAlgorithm); if (algorithm == 0) { throw XSECException(XSECException::ExpectedDSIGChildNotFound, "Expected Algorithm attribute in <CanonicalizationMethod>"); } safeBuffer tmpSB; tmpSB << (*mp_formatter << algorithm->getNodeValue()); if (tmpSB.sbStrcmp(URI_ID_C14N_NOC) == 0) { m_canonicalizationMethod = CANON_C14N_NOC; } else if (tmpSB.sbStrcmp(URI_ID_C14N_COM) == 0) { m_canonicalizationMethod = CANON_C14N_COM; } else throw XSECException(XSECException::UnknownCanonicalization); // Now load the SignatureMethod tmpSI = tmpSI->getNextSibling(); while (tmpSI != 0 && (tmpSI->getNodeType() != DOMNode::ELEMENT_NODE)) // Skip text and comments tmpSI = tmpSI->getNextSibling(); if (tmpSI == 0 || !strEquals(getDSIGLocalName(tmpSI), "SignatureMethod")) { throw XSECException(XSECException::ExpectedDSIGChildNotFound, "Expected <SignatureMethod> as child of <SignedInfo>"); } // Determine the algorithms used to sign this document tmpAtts = tmpSI->getAttributes(); algorithm = tmpAtts->getNamedItem(DSIGConstants::s_unicodeStrAlgorithm); if (algorithm == 0) { throw XSECException(XSECException::ExpectedDSIGChildNotFound, "Expected Algorithm attribute in <SignatureMethod>"); } tmpSB << (*mp_formatter << algorithm->getNodeValue()); if (tmpSB.sbStrcmp(URI_ID_DSA_SHA1) == 0) { m_signatureMethod = SIGNATURE_DSA; m_hashMethod = HASH_SHA1; } else if (tmpSB.sbStrcmp(URI_ID_RSA_SHA1) == 0) { m_signatureMethod = SIGNATURE_RSA; m_hashMethod = HASH_SHA1; } else if (tmpSB.sbStrcmp(URI_ID_HMAC_SHA1) == 0) { m_signatureMethod = SIGNATURE_HMAC; m_hashMethod = HASH_SHA1; // Check to see if there is a maximum output value DOMNode *tmpSOV = tmpSI->getFirstChild(); while (tmpSOV != NULL && tmpSOV->getNodeType() != DOMNode::ELEMENT_NODE && !strEquals(getDSIGLocalName(tmpSOV), "HMACOutputLength")) tmpSOV = tmpSOV->getNextSibling(); if (tmpSOV != NULL) { // Have a max output value! tmpSOV = tmpSOV->getFirstChild(); while (tmpSOV != NULL && tmpSOV->getNodeType() != DOMNode::TEXT_NODE) tmpSOV = tmpSOV->getNextSibling(); if (tmpSOV != NULL) { safeBuffer val; val << (*mp_formatter << tmpSOV->getNodeValue()); m_HMACOutputLength = atoi((char *) val.rawBuffer()); } } } else throw XSECException(XSECException::UnknownSignatureAlgorithm); // Now look at references.... tmpSI = tmpSI->getNextSibling(); // Run through the rest of the elements until done while (tmpSI != 0 && (tmpSI->getNodeType() != DOMNode::ELEMENT_NODE)) // Skip text and comments tmpSI = tmpSI->getNextSibling(); if (tmpSI != NULL) { // Have an element node - should be a reference, so let's load the list mp_referenceList = DSIGReference::loadReferenceListFromXML(mp_parentSignature, tmpSI); } }
XERCES_CPP_NAMESPACE_USE #define ARRAY_SIZE(ARY) ( (int)(sizeof(ARY)/sizeof(ARY[0])) ) #ifdef CONF_DUMP #define ENABLE_DUMP #define ENABLE_DUMP1 #endif #include "ParserDump.h" void JointParser::parse(DOMNode &target, Eval &eval) { char *name = XMLUtils::getAttribute(target, "name"); DUMP1(("name %s\n", name)); m_transform.push(); DOMNode *p = target.getFirstChild(); while (p) { char *s = XMLString::transcode(p->getNodeName()); // printf("%s\n", s); if (strcmp(s, "type") == 0) { char *type = XMLUtils::parseJointType(*p); DUMP1(("type=\"%s\"\n", type)); Joint *j = 0; if (strcmp(type, "fixed") == 0) { j = new FixedJoint(name); } else if (strcmp(type, "ball") == 0) { j = new BallJoint(name); } else if (strcmp(type, "hinge") == 0) { j = new HingeJoint(name, Vector3d(0, 1, 0)); } if (j) { m_joint = j; } XMLString::release(&type); /* } else if (strcmp(s, "limitOrientation") == 0) { double *v = XMLUtils::parseLimitOrientation(*p); if (m_joint) { delete m_joint; } m_joint = new HingeJoint(name, Vector3d(v[0], v[1], v[2])); */ } else if (strcmp(s, "translation") == 0) { double * values = XMLUtils::parseTranslation(*p, eval); DUMP1(("translation (%f, %f, %f)\n", values[0], values[1], values[2])); m_transform.curr().push(Vector3d(values[0], values[1], values[2])); } else if (strcmp(s, "rotation") == 0) { double *values = XMLUtils::parseRotation(*p); DUMP1(("rotation (%f, %f, %f, %f)\n", values[0], values[1], values[2], values[3])); Rotation rot; rot.setAxisAndAngle(values[0], values[1], values[2], values[3]); m_transform.curr().push(rot); } else if (strcmp(s, "axis") == 0) { double *values = XMLUtils::parseAxis(*p); DUMP1(("axis (%f, %f, %f)\n", values[0], values[1], values[2])); if (m_joint) { if (m_joint->type() == Joint::TYPE_HINGE) { HingeJoint *hinge = static_cast<HingeJoint*>(m_joint); hinge->setAxis(values[0], values[1], values[2]); } else { DUMP1(("not hinge type joint. axis ingored\n")); } } else { DUMP1(("no joint type")); } } else if (strcmp(s, "children") == 0) { DUMP1(("JOINT TRANSFORM TEST \n")); TRANSFORM_TEST(m_transform.curr()); parseChildren(*p, eval); } p = p->getNextSibling(); XMLString::release(&s); } { Transform &t = m_transform.curr(); const Vector3d &v = t.translation(); if (m_joint) { m_f.addJoint(m_joint); DUMP(("Joint : (%f, %f, %f)\n", v.x(), v.y(), v.z())); m_joint->setAnchor(v.x(), v.y(), v.z()); } } m_transform.pop(); char *strs[] = { name,}; for (int i=0; i<ARRAY_SIZE(strs); i++) { char *p = strs[i]; XMLString::release(&p); } }
int main(int argc, char **argv) { XSECCryptoKey * key = NULL; DSIGKeyInfoX509 * keyInfoX509 = NULL; OpenSSLCryptoX509 * certs[128]; int certCount = 0; int paramCount; bool clearKeyInfo = false; // Initialise the XML system try { XMLPlatformUtils::Initialize(); #ifndef XSEC_NO_XALAN XPathEvaluator::initialize(); XalanTransformer::initialize(); #endif XSECPlatformUtils::Initialise(); } catch (const XMLException &e) { cerr << "Error during initialisation of Xerces" << endl; cerr << "Error Message = : " << e.getMessage() << endl; } // Initialise OpenSSL ERR_load_crypto_strings(); BIO * bio_err; if ((bio_err=BIO_new(BIO_s_file())) != NULL) BIO_set_fp(bio_err,stderr,BIO_NOCLOSE|BIO_FP_TEXT); if (argc < 2) { printUsage(); exit (1); } paramCount = 1; while (paramCount < argc - 1) { // Run through all parameters if (stricmp(argv[paramCount], "--dsakey") == 0 || stricmp(argv[paramCount], "-d") == 0 || stricmp(argv[paramCount], "--rsakey") == 0 || stricmp(argv[paramCount], "-r") == 0) { // DSA or RSA Key if (paramCount + 3 >= argc) { printUsage(); exit (1); } if (key != 0) { cerr << "\nError loading RSA or DSA key - another key already loaded\n\n"; printUsage(); exit(1); } // Load the signing key // For now just read a particular file BIO * bioKey; if ((bioKey = BIO_new(BIO_s_file())) == NULL) { cerr << "Error opening private key file\n\n"; exit (1); } if (BIO_read_filename(bioKey, argv[paramCount + 1]) <= 0) { cerr << "Error opening private key file\n\n"; exit (1); } EVP_PKEY * pkey; pkey = PEM_read_bio_PrivateKey(bioKey,NULL,NULL,argv[paramCount + 2]); if (pkey == NULL) { cerr << "Error loading private key\n\n"; ERR_print_errors(bio_err); exit (1); } if (stricmp(argv[paramCount], "--dsakey") == 0 || stricmp(argv[paramCount], "-d") == 0) { // Check type is correct if (pkey->type != EVP_PKEY_DSA) { cerr << "DSA Key requested, but OpenSSL loaded something else\n"; exit (1); } // Create the XSEC OpenSSL interface key = new OpenSSLCryptoKeyDSA(pkey); } else { if (pkey->type != EVP_PKEY_RSA) { cerr << "RSA Key requested, but OpenSSL loaded something else\n"; exit (1); } key = new OpenSSLCryptoKeyRSA(pkey); } EVP_PKEY_free(pkey); BIO_free(bioKey); paramCount += 3; } /* argv[1] = "dsa/rsa" */ else if (stricmp(argv[paramCount], "--x509cert") == 0 || stricmp(argv[paramCount], "-x") == 0) { // X509Data keyInfo if (paramCount + 2 >= argc) { printUsage(); exit (1); } // Load the signing key // For now just read a particular file BIO * bioX509; if ((bioX509 = BIO_new(BIO_s_file())) == NULL) { cerr << "Error opening file\n\n"; exit (1); } if (BIO_read_filename(bioX509, argv[paramCount + 1]) <= 0) { cerr << "Error opening X509 Certificate " << argv[paramCount + 1] << "\n\n"; exit (1); } X509 * x ; x = PEM_read_bio_X509_AUX(bioX509,NULL,NULL,NULL); if (x == NULL) { cerr << "Error loading certificate key\n\n"; ERR_print_errors(bio_err); exit (1); } // Create the XSEC OpenSSL interface - used only to translate to Base64 certs[certCount++] = new OpenSSLCryptoX509(x); X509_free(x); BIO_free(bioX509); paramCount += 2; } /* argv[1] = "--x509cert" */ else if (stricmp(argv[paramCount], "--hmackey") == 0 || stricmp(argv[paramCount], "-h") == 0) { OpenSSLCryptoKeyHMAC * hmacKey = new OpenSSLCryptoKeyHMAC(); hmacKey->setKey((unsigned char *) argv[paramCount + 1], strlen(argv[paramCount + 1])); key = hmacKey; paramCount += 2; } else if (stricmp(argv[paramCount], "--clearkeys") == 0 || stricmp(argv[paramCount], "-c") == 0) { clearKeyInfo = true; paramCount += 1; } else { printUsage(); exit(1); } } // Create and set up the parser XercesDOMParser * parser = new XercesDOMParser; parser->setDoNamespaces(true); parser->setCreateEntityReferenceNodes(true); // Now parse out file bool errorsOccured = false; int errorCount = 0; try { parser->parse(argv[argc - 1]); errorCount = parser->getErrorCount(); if (errorCount > 0) errorsOccured = true; } catch (const XMLException& e) { cerr << "An error occured during parsing\n Message: " << e.getMessage() << endl; errorsOccured = true; } catch (const DOMException& e) { cerr << "A DOM error occured during parsing\n DOMException code: " << e.code << endl; errorsOccured = true; } if (errorsOccured) { cout << "Errors during parse" << endl; exit (1); } /* Now that we have the parsed file, get the DOM document and start looking at it */ DOMNode *doc; // The document that we parsed doc = parser->getDocument(); DOMDocument *theDOM = parser->getDocument(); // Find the signature node DOMNode *sigNode = findDSIGNode(doc, "Signature"); // Create the signature checker if (sigNode == 0) { cerr << "Could not find <Signature> node in " << argv[argc-1] << endl; exit(1); } XSECProvider prov; DSIGSignature * sig = prov.newSignatureFromDOM(theDOM, sigNode); int i; try { sig->load(); if (clearKeyInfo == true) sig->clearKeyInfo(); if (key != NULL) sig->setSigningKey(key); sig->sign(); // Add any KeyInfo elements if (certCount > 0) { // Have some certificates - see if there is already an X509 list DSIGKeyInfoList * kiList = sig->getKeyInfoList(); int kiSize = kiList->getSize(); for (i = 0; i < kiSize; ++i) { if (kiList->item(i)->getKeyInfoType() == DSIGKeyInfo::KEYINFO_X509) { keyInfoX509 = (DSIGKeyInfoX509 *) kiList->item(i); break; } } if (keyInfoX509 == 0) { // Not found - need to create keyInfoX509 = sig->appendX509Data(); } for (i = 0; i < certCount; ++i) { keyInfoX509->appendX509Certificate(certs[i]->getDEREncodingSB().rawCharBuffer()); } } /* certCount > 0 */ } catch (XSECException &e) { cerr << "An error occured during signature verification\n Message: " << e.getMsg() << endl; errorsOccured = true; exit (1); } // Print out the result DOMPrintFormatTarget* formatTarget = new DOMPrintFormatTarget(); const XMLCh* encNameStr = XMLString::transcode("UTF-8"); DOMNode *aNode = doc->getFirstChild(); if (aNode->getNodeType() == DOMNode::ENTITY_NODE) { const XMLCh* aStr = ((DOMEntity *)aNode)->getEncoding(); if (!strEquals(aStr, "")) { encNameStr = aStr; } } unsigned int lent = XMLString::stringLen(encNameStr); gEncodingName = new XMLCh[lent + 1]; XMLString::copyNString(gEncodingName, encNameStr, lent); gEncodingName[lent] = 0; gFormatter = new XMLFormatter("UTF-8", formatTarget, XMLFormatter::NoEscapes, gUnRepFlags); cout << doc; prov.releaseSignature(sig); return 0; }
unsigned int DSIGReference::readHash(XMLByte *toFill, unsigned int maxToFill) { // Determine the hash value stored in the reference // First set up for input unsigned int size; DOMNode *tmpElt; //const XMLCh * stringHash; TXFMBase * nextInput; DOMDocument *d = mp_referenceNode->getOwnerDocument(); safeBuffer b64HashVal; // Find the hash value tmpElt = mp_referenceNode->getFirstChild(); while (tmpElt != 0 && !strEquals(getDSIGLocalName(tmpElt), "DigestValue")) tmpElt = tmpElt->getNextSibling(); if (tmpElt == NULL) // ERROR return 0; // Now read the DOMString of the hash tmpElt = tmpElt->getFirstChild(); while (tmpElt != NULL && tmpElt->getNodeType() != DOMNode::TEXT_NODE) tmpElt = tmpElt->getNextSibling(); if (tmpElt == NULL) // Something wrong with the underlying XML if no text was found throw XSECException(XSECException::NoHashFoundInDigestValue); b64HashVal << (*mp_formatter << tmpElt->getNodeValue()); // Now have the value of the string - create a transform around it XSECnew(nextInput, TXFMSB(d)); ((TXFMSB *) nextInput)->setInput(b64HashVal); // Create a transform chain (really as a janitor for the entire list) TXFMChain * chain; XSECnew(chain, TXFMChain(nextInput)); Janitor<TXFMChain> j_chain(chain); // Now create the base64 transform XSECnew(nextInput, TXFMBase64(d)); chain->appendTxfm(nextInput); // Now get the value size = chain->getLastTxfm()->readBytes(toFill, maxToFill); // Clear any documentat modifications chain->getLastTxfm()->deleteExpandedNameSpaces(); return size; }
list<ClsDataClientConfig> ClsDataClientConfigReader::getDataClientConfig(string strFileName) { #ifdef DEBUG_CLSDATACLIENTCONFIGREADER cout << "ClsDataClientConfigReader::getDataClientConfig()" << endl; #endif list<ClsDataClientConfig> lstConfigs; #ifdef DEBUG_CLSDATACLIENTCONFIGREADER cout << "reading settings from: " << strFileName << endl; #endif bool errorsOccured = false; static bool gDoNamespaces = false; if(!bXMLPlatformInitialized){ try { XMLPlatformUtils::Initialize(); } catch(const XMLException& toCatch) { cerr << "Error during Xerces-c Initialization.\n" << " Exception message:" << toCatch.getMessage() << endl; bXMLPlatformInitialized = false; errorsOccured = true; // return; } bXMLPlatformInitialized = true; errorsOccured = false; } //-------------------- if (!errorsOccured) { XercesDOMParser* parser = new XercesDOMParser(); parser->setValidationScheme(XercesDOMParser::Val_Never); /* XercesDOMParser::Val_Never; XercesDOMParser::Val_Auto; XercesDOMParser::Val_Always; */ parser->setDoNamespaces(gDoNamespaces); ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase(); parser->setErrorHandler(errHandler); try { parser->parse(strFileName.c_str()); int errorCount = parser->getErrorCount(); if (errorCount > 0){ errorsOccured = true; } } catch (const XMLException& e) { cerr << "An error occured during parsing (XMLException)\n NMessage: " << XMLString::transcode(e.getMessage()) << endl; ClsDataClientConfigReaderException clsDataClientConfigReaderException(XMLString::transcode(e.getMessage())); errorsOccured = true; throw clsDataClientConfigReaderException; } catch (const DOMException& e) { cerr << "An error occured during parsing (DOMException)\n DMessage: " << XMLString::transcode(e.msg) << endl; ClsDataClientConfigReaderException clsDataClientConfigReaderException(XMLString::transcode(e.msg)); errorsOccured = true; throw clsDataClientConfigReaderException; } catch (const SAXException& e) { cerr << "An error occured during parsing (SAXException)\n DMessage: " << XMLString::transcode(e.getMessage()) << endl; ClsDataClientConfigReaderException clsDataClientConfigReaderException(XMLString::transcode(e.getMessage())); errorsOccured = true; throw clsDataClientConfigReaderException; } catch (...) { cerr << "An error occured during parsing\n " << endl; errorsOccured = true; ClsDataClientConfigReaderException clsDataClientConfigReaderException(ClsDataClientConfigReaderException::PARSE_ERROR); throw clsDataClientConfigReaderException; } /* DOMNode* dnIqrConfig; */ DOMDocument *ddocConfig = parser->getDocument(); DOMNodeList* dnlstClients = ddocConfig->getElementsByTagName(XMLString::transcode(ConfigTagLibrary::DataClientTag())); try{ if(dnlstClients->getLength()>0){ DOMNode* dnValue = NULL; unsigned int ii = 0; while( ii< dnlstClients->getLength()){ DOMNode* dnClient = dnlstClients->item(ii); ii++; string strType = getAttributeValue(dnClient, ConfigTagLibrary::TypeTag(), true); string strID = getAttributeValue(dnClient, ConfigTagLibrary::IDTag(), false); ClsDataClientConfig clsDataClientConfig(strID, strType); DOMNodeList* dnlstClientChildren = dnClient->getChildNodes(); unsigned int i2 = 0; while( i2< dnlstClientChildren->getLength()){ DOMNode* dnClientChild = dnlstClientChildren->item(i2); if(dnClientChild->getNodeType() == 1){ string strName = XMLString::transcode(dnClientChild->getNodeName()); if(!strName.compare(ConfigTagLibrary::PositionTag())){ int iX = 0; int iY = 0; iX = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::PositionXTag(), true)); iY = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::PositionYTag(), true)); clsDataClientConfig.setPosition(iX, iY); } else if(!strName.compare(ConfigTagLibrary::Geometry())){ int iWidth = 0; int iHeight = 0; iWidth = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::GeometryWidthTag(), true)); iHeight = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::GeometryHeightTag(), true)); clsDataClientConfig.setGeometry(iWidth, iHeight); } else if(!strName.compare(ConfigTagLibrary::StateVariableDisplayTag())){ DOMNodeList* dnlstSVD = dnClientChild->getChildNodes(); unsigned int i3 = 0; while( i3< dnlstSVD->getLength()){ DOMNode* dnSVD = dnlstSVD->item(i3); if(dnSVD->getNodeType() == 1){ string strSVDID = getAttributeValue(dnSVD, ConfigTagLibrary::IDTag(), true); //-- string strItemType = getAttributeValue(dnSVD, ConfigTagLibrary::TypeTag(), true); string strItemID = getAttributeValue(dnSVD, ConfigTagLibrary::ItemIDTag(), true); string strSelectedIndices = getAttributeValue(dnSVD, ConfigTagLibrary::SelectedIndicesTag(), true); ClsStateVariableDisplayConfig clsStateVariableDisplayConfig(/*strItemType,*/ strSVDID, strItemID, strSelectedIndices); DOMNodeList* dnlstSVDParams = dnSVD->getChildNodes(); unsigned int i4 = 0; while( i4< dnlstSVDParams->getLength()){ DOMNode* dnSVDParam = dnlstSVDParams->item(i4); if(dnSVDParam->getNodeType() == 1){ string strParamName = XMLString::transcode(dnSVDParam->getNodeName()); dnValue = dnSVDParam->getFirstChild(); string strParamValue = ""; if(dnValue!=NULL){ strParamValue = XMLString::transcode(dnValue->getNodeValue()); } pair<string, string> pParam(strParamName, strParamValue); clsStateVariableDisplayConfig.addParameter(pParam); } i4++; } clsDataClientConfig.addStateVariableDisplayConfig(clsStateVariableDisplayConfig); } i3++; } } else { string strValue = ""; dnValue = dnClientChild->getFirstChild(); if(dnValue!=NULL){ strValue = XMLString::transcode(dnValue->getNodeValue()); } pair<string, string> pParam(strName, strValue); clsDataClientConfig.addParameter(pParam); } } i2++; } lstConfigs.push_back(clsDataClientConfig); } } } catch (...) { ClsDataClientConfigReaderException clsDataClientConfigReaderException(ClsDataClientConfigReaderException::PARSE_ERROR); throw clsDataClientConfigReaderException; } delete errHandler; } return lstConfigs; };
bool BitMaskImp::fromXml(DOMNode* document, unsigned int version) { string outsideVal(A(static_cast<DOMElement*>(document)->getAttribute(X("outside")))); string crcString(A(static_cast<DOMElement*>(document)->getAttribute(X("ecc")))); if (outsideVal == "1" || outsideVal == "t" || outsideVal == "true") { mOutside = true; } else { mOutside = false; } for (DOMNode* pChld = document->getFirstChild(); pChld != NULL; pChld = pChld->getNextSibling()) { if (XMLString::equals(pChld->getNodeName(), X("rectangle"))) { DOMNode* pGchld(pChld->getFirstChild()); double a; double b; double c; double d; XmlReader::StrToQuadCoord(pGchld->getNodeValue(), a, b, c, d); mx1 = static_cast<int>(a); my1 = static_cast<int>(b); mx2 = static_cast<int>(c); my2 = static_cast<int>(d); } else if (XMLString::equals(pChld->getNodeName(), X("boundingBox"))) { DOMNode* pGchld(pChld->getFirstChild()); double a; double b; double c; double d; XmlReader::StrToQuadCoord(pGchld->getNodeValue(), a, b, c, d); mbbx1 = static_cast<int>(a); mbby1 = static_cast<int>(b); mbbx2 = static_cast<int>(c); mbby2 = static_cast<int>(d); } else if (XMLString::equals(pChld->getNodeName(), X("size"))) { // we only need to read 3 coords by StrToQuadCoord still works well // as it handles cases where there are fewer than four coords (defaults them to 0.0) // so we just pass in a dummy that never actually gets read DOMNode* pGchld(pChld->getFirstChild()); double a; double b; double c; double dummy; XmlReader::StrToQuadCoord(pGchld->getNodeValue(), a, b, c, dummy); mxSize = static_cast<int>(a); mySize = static_cast<int>(b); mCount = static_cast<int>(c); mSize = mxSize * mySize; } else if (XMLString::equals(pChld->getNodeName(), X("mask"))) { mpMask = new (nothrow) unsigned int*[mySize]; if (mpMask == NULL) { throw XmlReader::DomParseException("Can't create a new unsigned int array", pChld); } std::string checksum; if (crcString.find("ccitt:") != string::npos) { checksum = crcString.substr(crcString.find(":") + 1); } DOMNode* pGchld(pChld->getFirstChild()); mpMask[0] = XmlBase::decodeBase64(reinterpret_cast<const XMLByte*>(A(pGchld->getNodeValue())), 0, checksum); if (mpMask[0] == NULL) { delete [] mpMask; mpMask = NULL; throw XmlReader::DomParseException("Can't decode the bitmask", pChld); } for (int i = 1; i < mySize; ++i) { mpMask[i] = mpMask[i - 1] + mxSize; } } } return true; }
int main() { try { XMLPlatformUtils::Initialize(); } catch (const XMLException& toCatch) { char *pMessage = XMLString::transcode(toCatch.getMessage()); fprintf(stderr, "Error during XMLPlatformUtils::Initialize(). \n" " Message is: %s\n", pMessage); XMLString::release(&pMessage); return -1; } /* Range tests include testing of createRange setStart, setStartBefore. setStartAfter, setEnd, setEndBefore. setEndAfter getStartContainer, getStartOffset getEndContainer, getEndOffset getCommonAncestorContainer selectNode selectNodeContents insertNode deleteContents collapse getCollapsed surroundContents compareBoundaryPoints cloneRange cloneContents extractContents toString detach removeChild */ { XMLCh tempStr[100]; XMLString::transcode("Range",tempStr,99); { DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(tempStr); DOMDocument* doc = impl->createDocument(); //Creating a root element DOMElement* root = doc->createElement(xBody); doc->appendChild(root); //Creating the siblings of root DOMElement* E11 = doc->createElement(xH1); root->appendChild(E11); DOMElement* E12 = doc->createElement(xP); root->appendChild(E12); //Attaching texts to siblings DOMText* textNode1 = doc->createTextNode(xTitle); E11->appendChild(textNode1); DOMText* textNode11 = doc->createTextNode(xAnotherText); E11->appendChild(textNode11); DOMText* textNode2 = doc->createTextNode(xBlahxyz); E12->appendChild(textNode2); DOMText* E210 = doc->createTextNode(xInsertedText); doc->release(); } { //DOM Tree and some usable node creation DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(tempStr); DOMDocument* doc = impl->createDocument(); //Creating a root element DOMElement* root = doc->createElement(xBody); doc->appendChild(root); //Creating the siblings of root DOMElement* E11 = doc->createElement(xH1); root->appendChild(E11); DOMElement* E12 = doc->createElement(xP); root->appendChild(E12); //Attaching texts to siblings DOMText* textNode1 = doc->createTextNode(xTitle); E11->appendChild(textNode1); DOMText* textNode11 = doc->createTextNode(xAnotherText); E11->appendChild(textNode11); DOMText* textNode2 = doc->createTextNode(xBlahxyz); E12->appendChild(textNode2); //experimental nodes DOMElement* E120 = doc->createElement(xElement1); DOMElement* E121 = doc->createElement(xElement2); DOMElement* E122 = doc->createElement(xElement3); DOMElement* E311 = doc->createElement(xSurroundNode1); DOMText* E210 = doc->createTextNode(xInsertedText); DOMNode* rt = doc->getDocumentElement(); DOMRange* range = ((DOMDocumentRange*)doc)->createRange(); //Tests start here // Initial dom tree looks like : // <Body><H1>TitleAnother Text</H1><P>Blah xyz</P></Body> //i.e., Body(rt) // _____________|________________ // | | // ___H1(E11)___ P(E12) // | | | // "Title" "Another Text" "Blah xyz" //test for start and end settings of a range range->setStart(rt->getFirstChild(), 0); TASSERT(range->getStartContainer() == rt->getFirstChild() ); TASSERT(range->getStartOffset() == 0); range->setEnd(rt->getFirstChild(), 1); TASSERT(range->getEndContainer() == rt->getFirstChild() ); TASSERT(range->getEndOffset() == 1); //DOMNode* node = range->getCommonAncestorContainer(); TASSERT(range->getCommonAncestorContainer() == rt->getFirstChild()); //selection related test range->selectNode(rt->getLastChild()); TASSERT(range->getStartContainer() == rt); TASSERT(range->getStartOffset() == 1); TASSERT(range->getEndContainer() == rt); TASSERT(range->getEndOffset() == 2); //insertion related tests range->insertNode(E120); //only end offset moves and new node gets into range as being inserted at boundary point TASSERT(range->getStartContainer() == rt); TASSERT(range->getStartOffset() == 1); TASSERT(range->getEndContainer() == rt); TASSERT(range->getEndOffset() == 3); range->insertNode(E121); //only end offset moves and new node gets into range as being inserted at boundary point TASSERT(range->getStartContainer() == rt); TASSERT(range->getStartOffset() == 1); TASSERT(range->getEndContainer() == rt); TASSERT(range->getEndOffset() == 4); rt->insertBefore(E122, rt->getFirstChild()); //both offsets move as new node is not part of the range TASSERT(range->getStartContainer() == rt); TASSERT(range->getStartOffset() == 2); TASSERT(range->getEndContainer() == rt); TASSERT(range->getEndOffset() == 5); //After above operations, now the tree looks like: // <Body><Element3/><H1>TitleAnother Text</H1><Element2/><Element1/><P>Blah xyz</P></Body> //i.e., Body(rt) // _____________|_______________________________________________________________ // | | | | | // Element3(E122) ___H1(E11)___ Element2(E121) Element1(E120) P(E12) // | | | // "Title" "Another Text" "Blah xyz" // // range has rt as start and end container, and 2 as start offset, 5 as end offset //changing selection range->selectNode(rt->getLastChild()->getPreviousSibling()); TASSERT(range->getStartContainer() == rt); TASSERT(range->getStartOffset() == 3); TASSERT(range->getEndContainer() == rt); TASSERT(range->getEndOffset() == 4); //deleting related tests range->deleteContents(); TASSERT(rt->getLastChild()->getPreviousSibling() == E121); range->setStart(rt->getFirstChild()->getNextSibling()->getFirstChild(), 2); TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild()); TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xTitle)); TASSERT(range->getStartOffset() == 2); range->setEnd(rt->getFirstChild()->getNextSibling()->getFirstChild(), 4); TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild()); TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xTitle)); TASSERT(range->getEndOffset() == 4); TASSERT(!XMLString::compareString(range->toString(),xtl)); //inserting text between a text node range->insertNode(E210); //only end offset moves and new node gets into range as being inserted at boundary point TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild()); TASSERT(range->getStartOffset() == 2); TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling()); TASSERT(range->getEndOffset() == 2); //inserting element node before the selected text node range->insertNode(E120); //only end offset moves and new node gets into range as being inserted at boundary point TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild()); TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xTi)); TASSERT(range->getStartOffset() == 2); TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling()); TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xtle)); TASSERT(range->getEndOffset() == 2); TASSERT(E11->getChildNodes()->getLength()==6); //checking the text replacment range->getStartContainer()->setNodeValue(xReplacedText); //only the start offset is impact TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild()); TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xReplacedText)); TASSERT(range->getStartOffset() == 0); TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling()); TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xtle)); TASSERT(range->getEndOffset() == 2); //After above operations, now the tree looks like: // <Body><Element3/><H1>ReplacedText<Element1/>InsertedTexttleAnother Text</H1><Element2/><P>Blah xyz</P></Body> //i.e., Body(rt) // _____________|_______________________________________________________________________________________________ // | | | | // Element3(E122) ___H1(E11)___________________________________________________________ Element2(E121) P(E12) // | | | | | | | // "ReplacedText" "" Element1(E120) "InsertedText"(E210) "tle" "Another Text" "Blah xyz" // // range has "ReplacedText" as start container and "tle" as end container // and 0 as start offset, 2 as end offset //changing the selection. Preparing for 'surround' range->setStart(range->getStartContainer()->getParentNode(), 2); range->setEnd(range->getStartContainer(), 5); TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeName(),xH1)); TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeName(),xH1)); TASSERT(!XMLString::compareString(range->toString(),xInsertedTexttle)); range->surroundContents(E311); TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeName(),xH1)); TASSERT(range->getStartOffset() == 2); TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeName(),xH1)); TASSERT(range->getEndOffset() == 3); TASSERT(E11->getChildNodes()->getLength()==4); TASSERT(E311->getChildNodes()->getLength()==3); TASSERT(!XMLString::compareString(range->toString(),xInsertedTexttle)); //After above operations, now the tree looks like: // <Body><Element3/><H1>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body> //i.e., Body(rt) // _____________|_________________________________________________________________________ // | | | | // Element3(E122) ___H1(E11)___________________________________ Element2(E121) P(E12) // | | | | | // "ReplacedText" "" SurroundNode1(E311) "Another Text" "Blah xyz" // ____________ |_____________________________ // | | | // Element1(E120) "InsertedText"(E210) "tle" // // range has H1 as start and end container and 2 as start offset, 3 as end offset //testing cloning DOMRange* aRange = range->cloneRange(); TASSERT(aRange->getStartContainer() == range->getStartContainer()); TASSERT(aRange->getEndContainer() == range->getEndContainer()); TASSERT(aRange->getStartOffset() == 2); TASSERT(aRange->getEndOffset() == 3); //changing the new ranges start aRange->setStart(aRange->getStartContainer()->getFirstChild(), 1); //comparing the ranges short compVal = range->compareBoundaryPoints(DOMRange::END_TO_END, aRange); TASSERT(compVal == 0); compVal = range->compareBoundaryPoints(DOMRange::START_TO_START, aRange); TASSERT(compVal == 1); compVal = range->compareBoundaryPoints(DOMRange::START_TO_END, aRange); TASSERT(compVal == 1); compVal = range->compareBoundaryPoints(DOMRange::END_TO_START, aRange); TASSERT(compVal == -1); //testing collapse //not collapsed TASSERT(range->getCollapsed() == false); TASSERT(range->getStartOffset() == 2); TASSERT(range->getEndOffset() == 3); //selectNodeContents range->selectNodeContents(rt->getLastChild()->getFirstChild()); TASSERT(range->getStartContainer() == rt->getLastChild()->getFirstChild()); TASSERT(range->getEndContainer() == rt->getLastChild()->getFirstChild()); TASSERT(range->getStartOffset() == 0); TASSERT(range->getEndOffset() == 8); TASSERT(!XMLString::compareString(range->toString(),xBlahxyz)); //testing collapse range->collapse(true); //collapse to start TASSERT(range->getCollapsed() == true); TASSERT(range->getStartOffset() == 0); TASSERT(range->getEndOffset() == 0); TASSERT(!XMLString::compareString(range->toString(),XMLUni::fgZeroLenString)); TASSERT(aRange->getEndOffset() == 3); //other range is unaffected TASSERT(!XMLString::compareString(aRange->toString(),xeplacedTextInsertedTexttle)); //After above operations, now the tree looks like: // <Body><Element3/><H1>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body> //i.e., Body(rt) // _____________|_________________________________________________________________________ // | | | | // Element3(E122) ___H1(E11)___________________________________ Element2(E121) P(E12) // | | | | | // "ReplacedText" "" SurroundNode1(E311) "Another Text" "Blah xyz" // ____________ |_____________________________ // | | | // Element1(E120) "InsertedText"(E210) "tle" // // range has "Blah xyz" as start and end container and 0 as start and end offset (collapsed) // aRange has "ReplacedText" as start container and H1 as end container // and 1 as start offset and 3 as end offset DOMDocumentFragment* docFrag = aRange->cloneContents(); TASSERT( docFrag != 0); range->selectNode(rt->getFirstChild()); TASSERT(range->getStartContainer() == rt); TASSERT(range->getEndContainer() == rt); TASSERT(range->getStartOffset() == 0); TASSERT(range->getEndOffset() == 1); //Testing toString() const XMLCh* str = aRange->toString(); TASSERT(!XMLString::compareString(str, xeplacedTextInsertedTexttle)); //start and end before and after tests range->setStartBefore(rt->getFirstChild()); TASSERT(range->getStartOffset() == 0); range->setEndBefore(rt->getFirstChild()); TASSERT(range->getEndOffset() == 0); range->setStartAfter(rt->getLastChild()); TASSERT(range->getStartOffset() == 4); range->setStartAfter(rt->getFirstChild()); TASSERT(range->getStartOffset() == 1); range->setEndBefore(rt->getLastChild()); TASSERT(range->getEndOffset() == 3); range->setEndAfter(rt->getLastChild()); TASSERT(range->getEndOffset() == 4); //testing extract() DOMDocumentFragment* frag2 = range->extractContents(); TASSERT( frag2 != 0); //After above operations, now the tree looks like: // <Body><Element3/></Body> //i.e., Body(rt) // | // Element3(E122) // // aRange has rt as start and end container, and 1 as start and end offset (collapsed) // range has rt as start and end container, and 1 as start and end offset (collapsed) // //and frag2 looks: // <Body>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body> //i.e., Body(rt) // ______________|________________________________________________________ // | | | // ___H1(E11)___________________________________ Element2(E121) P(E12) // | | | | | //"ReplacedText" "" SurroundNode1(E311) "Another Text" "Blah xyz" // ____________ |_____________________________ // | | | // Element1(E120) "InsertedText"(E210) "tle" // //the tree do not have those node anymore after extract //only Element3 left TASSERT(rt->getChildNodes()->getLength()==1); //aRange is collapsed TASSERT(aRange->getCollapsed() == true); TASSERT(aRange->getStartContainer() == rt); TASSERT(aRange->getStartOffset() == 1); TASSERT(aRange->getEndContainer() == rt); TASSERT(aRange->getEndOffset() == 1); //range is collapsed as well TASSERT(range->getCollapsed() == true); TASSERT(range->getStartContainer() == rt); TASSERT(range->getStartOffset() == 1); TASSERT(range->getEndContainer() == rt); TASSERT(range->getEndOffset() == 1); //test the document fragment frag2 TASSERT(frag2->getChildNodes()->getLength()==3); //detaching the other range aRange->detach(); range->detach(); //*************************************************************** //another set of test //TEST createRange, setStart and setEnd, insertnode //*************************************************************** DOMImplementation* impl2 = DOMImplementationRegistry::getDOMImplementation(tempStr); DOMDocument* doc2 = impl2->createDocument(); DOMElement* root2 = doc2->createElement(xroot2); doc2->appendChild(root2); //case 1: simple text node, start==end // <body>text1</body> DOMElement* body = doc2->createElement(xBody); DOMText* text1 = doc2->createTextNode(xtext1); body->appendChild(text1); root2->appendChild(body); //set range DOMRange* range1 = doc2->createRange(); range1->setStart(text1,1); range1->setEnd(text1,3); TASSERT(!XMLString::compareString(range1->toString(),xex)); TASSERT(range1->getStartOffset()==1); TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xtext1)); TASSERT(range1->getEndOffset()==3); TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xtext1)); //now insert a text node //<body>ttext2ext1</body> DOMText* text2 = doc2->createTextNode(xtext2); range1->insertNode(text2); TASSERT(!XMLString::compareString(range1->toString(),xtext2ex)); TASSERT(range1->getStartOffset()==1); TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xt)); TASSERT(range1->getEndOffset()==2); TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xext1)); //now insert a non-text node //<body>t<p1/>text2ext1</body> DOMElement* p1 = doc2->createElement(xp1); range1->insertNode(p1); TASSERT(!XMLString::compareString(range1->toString(),xtext2ex)); TASSERT(range1->getStartOffset()==1); TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xt)); TASSERT(range1->getEndOffset()==2); TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xext1)); //case 2: non-text node, start==end // <head><h1/></head> DOMElement* head = doc2->createElement(xhead); DOMElement* h1 = doc2->createElement(xH1); head->appendChild(h1); root2->appendChild(head); //set range DOMRange* range2 = doc2->createRange(); range2->setStart(head,0); range2->setEnd(head,1); TASSERT(!XMLString::compareString(range2->toString(),XMLUni::fgZeroLenString)); TASSERT(range2->getStartOffset()==0); TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead)); TASSERT(range2->getEndOffset()==1); TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead)); //now insert a non-text node //<head><h2/><h1/></head> DOMElement* h2 = doc2->createElement(xh2); range2->insertNode(h2); TASSERT(!XMLString::compareString(range2->toString(),XMLUni::fgZeroLenString)); TASSERT(range2->getStartOffset()==0); TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead)); TASSERT(range2->getEndOffset()==2); TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead)); //now insert a text node //<head>text5<h2/><h1/></head> DOMText* text5 = doc2->createTextNode(xtext5); range2->insertNode(text5); TASSERT(!XMLString::compareString(range2->toString(),xtext5)); TASSERT(range2->getStartOffset()==0); TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead)); TASSERT(range2->getEndOffset()==3); TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead)); //case 3: simple text node, start!=end // <body2>text3</body2> DOMElement* body2 = doc2->createElement(xbody2); DOMText* text3 = doc2->createTextNode(xtext3); body2->appendChild(text3); root2->appendChild(body2); //set range DOMRange* range3 = ((DOMDocumentRange*)doc2)->createRange(); range3->setStart(text3,1); range3->setEnd(body2,1); TASSERT(!XMLString::compareString(range3->toString(),xext3)); TASSERT(range3->getStartOffset()==1); TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xtext3)); TASSERT(range3->getEndOffset()==1); TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2)); //now insert a textnode //<body2>ttext4ext3</body2> DOMText* text4 = doc2->createTextNode(xtext4); range3->insertNode(text4); TASSERT(!XMLString::compareString(range3->toString(),XMLUni::fgZeroLenString)); TASSERT(range3->getStartOffset()==1); TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xt)); TASSERT(range3->getEndOffset()==1); TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2)); //now insert a non-text node //<body2>t<p2/>text4ext3</body2> DOMElement* p2 = doc2->createElement(xp2); range3->insertNode(p2); //extra empty node caused by splitting 't' TASSERT(!XMLString::compareString(range3->toString(),XMLUni::fgZeroLenString)); TASSERT(range3->getStartOffset()==1); TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xt)); TASSERT(range3->getEndOffset()==1); TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2)); //test toString a bit range3->setStart(body2,1); range3->setEnd(body2,5); TASSERT(!XMLString::compareString(range3->toString(),xtext4ext3)); range3->setStart(body2,0); range3->setEnd(body2,5); TASSERT(!XMLString::compareString(range3->toString(),xttext4ext3)); //case 4: non-text node, start!=end // <head2><h3/></head2> DOMElement* head2 = doc2->createElement(xhead2); DOMElement* h3 = doc2->createElement(xh3); head2->appendChild(h3); root2->appendChild(head2); //set range DOMRange* range4 = doc2->createRange(); range4->setStart(head2,0); range4->setEnd(h3,0); TASSERT(!XMLString::compareString(range4->toString(),XMLUni::fgZeroLenString)); TASSERT(range4->getStartOffset()==0); TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2)); TASSERT(range4->getEndOffset()==0); TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3)); //now insert a non-text node //<head2><h4/><h3/></head2> DOMElement* h4 = doc2->createElement(xh4); range4->insertNode(h4); TASSERT(!XMLString::compareString(range4->toString(),XMLUni::fgZeroLenString)); TASSERT(range4->getStartOffset()==0); TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2)); TASSERT(range4->getEndOffset()==0); TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3)); //now insert a text node //<head2>text6<h4/><h3/></head2> DOMText* text6 = doc2->createTextNode(xtext6); range4->insertNode(text6); TASSERT(!XMLString::compareString(range4->toString(),xtext6)); TASSERT(range4->getStartOffset()==0); TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2)); TASSERT(range4->getEndOffset()==0); TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3)); //*************************************************************** // quick test of updating //*************************************************************** // <upbody>text1</upbody> DOMElement* upbody = doc2->createElement(xupbody); DOMText* uptext1 = doc2->createTextNode(xuptext1); upbody->appendChild(uptext1); root2->appendChild(upbody); DOMRange* uprange = ((DOMDocumentRange*)doc2)->createRange(); uprange->setStart(upbody,0); uprange->setEnd(upbody,1); TASSERT(!XMLString::compareString(uprange->toString(),xuptext1)); TASSERT(uprange->getStartOffset()==0); TASSERT(!XMLString::compareString(uprange->getStartContainer()->getNodeName(),xupbody)); TASSERT(uprange->getEndOffset()==1); TASSERT(!XMLString::compareString(uprange->getEndContainer()->getNodeName(),xupbody)); // split text uptext1->splitText(1); TASSERT(!XMLString::compareString(uprange->toString(),xu)); TASSERT(uprange->getStartOffset()==0); TASSERT(!XMLString::compareString(uprange->getStartContainer()->getNodeName(),xupbody)); TASSERT(uprange->getEndOffset()==1); TASSERT(!XMLString::compareString(uprange->getEndContainer()->getNodeName(),xupbody)); //insert node DOMElement* upbody2 = doc2->createElement(xupbody2); DOMText* uptext2 = doc2->createTextNode(xuptext2); upbody2->appendChild(uptext2); root2->appendChild(upbody2); DOMRange* uprange2 = ((DOMDocumentRange*)doc2)->createRange(); uprange2->setStart(uptext2,1); uprange2->setEnd(upbody2,1); DOMRange* uprange3 = doc2->createRange(); uprange3->setStart(uptext2,1); uprange3->setEnd(upbody2,1); TASSERT(!XMLString::compareString(uprange2->toString(),xptext2)); TASSERT(uprange2->getStartOffset()==1); TASSERT(!XMLString::compareString(uprange2->getStartContainer()->getNodeValue(),xuptext2)); TASSERT(uprange2->getEndOffset()==1); TASSERT(!XMLString::compareString(uprange2->getEndContainer()->getNodeName(),xupbody2)); TASSERT(!XMLString::compareString(uprange3->toString(),xptext2)); TASSERT(uprange3->getStartOffset()==1); TASSERT(!XMLString::compareString(uprange3->getStartContainer()->getNodeValue(),xuptext2)); TASSERT(uprange3->getEndOffset()==1); TASSERT(!XMLString::compareString(uprange3->getEndContainer()->getNodeName(),xupbody2)); DOMElement* upp1 = doc2->createElement(xupp1); uprange2->insertNode(upp1); TASSERT(!XMLString::compareString(uprange2->toString(),XMLUni::fgZeroLenString)); TASSERT(uprange2->getStartOffset()==1); TASSERT(!XMLString::compareString(uprange2->getStartContainer()->getNodeValue(),xu)); TASSERT(uprange2->getEndOffset()==1); TASSERT(!XMLString::compareString(uprange2->getEndContainer()->getNodeName(),xupbody2)); TASSERT(!XMLString::compareString(uprange3->toString(),XMLUni::fgZeroLenString)); TASSERT(uprange3->getStartOffset()==1); TASSERT(!XMLString::compareString(uprange3->getStartContainer()->getNodeValue(),xu)); TASSERT(uprange3->getEndOffset()==1); TASSERT(!XMLString::compareString(uprange3->getEndContainer()->getNodeName(),xupbody2)); //*************************************************************** //another set of test //<foo><c/><moo><b/></moo>ab<a>Hello cd</a><cool>ef</cool></foo> // // ______________________foo_____________________ // | | | | | // c moo "ab" a cool // | | | // b "Hello cd" "ef" // DOMImplementation* impl3 = DOMImplementationRegistry::getDOMImplementation(tempStr); DOMDocument* doc3 = impl3->createDocument(); DOMElement* root3 = doc3->createElement(xroot); doc3->appendChild(root3); DOMElement* foo = doc3->createElement(xfoo); DOMElement* moo = doc3->createElement(xmoo); DOMElement* cool = doc3->createElement(xcool); DOMText* ab = doc3->createTextNode(xab); DOMText* cd = doc3->createTextNode(xHellocd); DOMText* ef = doc3->createTextNode(xef); DOMElement* a = doc3->createElement(xa); DOMElement* b = doc3->createElement(xb); DOMElement* c = doc3->createElement(xc); root3->appendChild(foo); foo->appendChild(c); foo->appendChild(moo); foo->appendChild(ab); foo->appendChild(a); foo->appendChild(cool); moo->appendChild(b); a->appendChild(cd); cool->appendChild(ef); //*************************************************************** //TEST toString //*************************************************************** DOMRange* newtestrange = ((DOMDocumentRange*)doc3)->createRange(); //case 1: //start container is text node // i) end container is also text node // a) start==end // b) start!=end // ii) end container is not text node // a) start==end => impossible // b) start!=end // //case 2: //start container is not text node // i) end container is text node // a) start==end => impossible // b) start!=end // ii) end container is not text node // a) start==end // b) start!=end //case 1, i, a newtestrange->setStart( cd, 1 ); newtestrange->setEnd( cd, 4 ); TASSERT(!XMLString::compareString(newtestrange->toString(),xell)); //case 1, i, b newtestrange->setStart( cd, 1 ); newtestrange->setEnd( ef, 2 ); TASSERT(!XMLString::compareString(newtestrange->toString(),xellocdef)); //case 1, ii, b newtestrange->setStart( cd, 1 ); newtestrange->setEnd( foo, 4 ); TASSERT(!XMLString::compareString(newtestrange->toString(),xellocd)); //case 2, i, b newtestrange->setStart( foo, 1 ); newtestrange->setEnd( cd, 5 ); TASSERT(!XMLString::compareString(newtestrange->toString(),xabHello)); //case 2, ii, a newtestrange->setStart( foo, 1 ); newtestrange->setEnd( foo, 4 ); TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd)); //case 2, ii, b newtestrange->setStart( moo, 1 ); newtestrange->setEnd( foo, 4 ); TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd)); //*************************************************************** //test removeChild //*************************************************************** DOMRange* newrange = doc3->createRange(); newrange->setStart( moo, 0 ); newrange->setEnd( foo, 4 ); TASSERT(newrange->getStartOffset()==0); TASSERT(!XMLString::compareString(newrange->getStartContainer()->getNodeName(),xmoo)); TASSERT(newrange->getEndOffset()==4); TASSERT(!XMLString::compareString(newrange->getEndContainer()->getNodeName(),xfoo)); TASSERT(!XMLString::compareString(newrange->toString(),xabHellocd)); DOMNode* n = newrange->cloneContents(); DOMNodeList* nol = foo->getChildNodes(); //removing moo DOMNode* rem = foo->removeChild(nol->item(1)); rem->release(); TASSERT(newrange->getStartOffset()==1); TASSERT(!XMLString::compareString(newrange->getStartContainer()->getNodeName(),xfoo)); TASSERT(newrange->getEndOffset()==3); TASSERT(!XMLString::compareString(newrange->getEndContainer()->getNodeName(),xfoo)); TASSERT(!XMLString::compareString(newrange->toString(),xabHellocd)); TASSERT(newtestrange->getStartOffset()==1); TASSERT(!XMLString::compareString(newtestrange->getStartContainer()->getNodeName(),xfoo)); TASSERT(newtestrange->getEndOffset()==3); TASSERT(!XMLString::compareString(newtestrange->getEndContainer()->getNodeName(),xfoo)); TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd)); // Now do some exception test newrange->detach(); EXCEPTION_TEST(newrange->setStart( moo, 0 ), DOMException::INVALID_STATE_ERR); EXCEPTION_TEST(newtestrange->setStartBefore(moo), DOMRangeException::INVALID_NODE_TYPE_ERR); doc->release(); doc2->release(); doc3->release(); } } //creating the dom tree and tests // And call the termination method XMLPlatformUtils::Terminate(); if (errorOccurred) { printf("Test Failed\n"); return 4; } printf("Test Run Successfully\n"); return 0; };
void ConfigManager::Initialize() { bool failed = false; m_configTopNode = NULL; try { char* cfgFilename = NULL; char* cfgEnvPath = ""; int cfgAlloc = 0; cfgEnvPath = ACE_OS::getenv("ORKAUDIO_CONFIG_PATH"); if(cfgEnvPath) { ACE_DIR* dir = ACE_OS::opendir(cfgEnvPath); if(dir) { int len = 0; ACE_OS::closedir(dir); len = strlen(cfgEnvPath)+1+strlen(CONFIG_FILE_NAME)+1; cfgFilename = (char*)malloc(len); if(cfgFilename) { cfgAlloc = 1; snprintf(cfgFilename, len, "%s/%s", cfgEnvPath, CONFIG_FILE_NAME); } } } if(!cfgFilename) { FILE* file = ACE_OS::fopen(CONFIG_FILE_NAME, "r"); if(file) { // config.xml exists in the current directory cfgFilename = (char*)CONFIG_FILE_NAME; fclose(file); } else { // config.xml could not be found in the current // directory, try to find it in system configuration directory cfgFilename = (char*)ETC_CONFIG_FILE_NAME; } } XMLPlatformUtils::Initialize(); // By default, the DOM document generated by the parser will be free() by the parser. // If we ever need to free the parser and the document separately, we need to do this: // DOMNode *doc = parser->getDocument(); // ... // parser->adoptDocument(); // doc->release(); // ... // delete parser; XercesDOMParser *m_parser = new XercesDOMParser; XmlErrorHandler errhandler; m_parser->setErrorHandler(&errhandler); m_parser->parse(cfgFilename); DOMNode *doc = NULL; doc = m_parser->getDocument(); // XXX is it okay to free here? if(cfgAlloc) { free(cfgFilename); } if (doc) { DOMNode *firstChild = doc->getFirstChild(); if (firstChild) { m_configTopNode = firstChild; m_config.DeSerializeDom(firstChild); /* // Write out config to a file DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(XStr("Core").unicodeForm()); XERCES_CPP_NAMESPACE::DOMDocument* myDoc; myDoc = impl->createDocument( 0, // root element namespace URI. XStr("root").unicodeForm(), // root element name 0); // document type object (DTD). m_config.SerializeDom(myDoc); CStdString toto = DomSerializer::DomNodeToString(myDoc); FILE* file = fopen("zzz.xml", "w"); fwrite((PCSTR)toto,1,toto.GetLength(),file); fclose(file); */ } else { LOG4CXX_ERROR(LOG.configLog, CStdString("Could not parse config file:") + CONFIG_FILE_NAME); failed = true; } } else { LOG4CXX_WARN(LOG.configLog, CStdString("Could not find config file:") + CONFIG_FILE_NAME); } } catch (const CStdString& e) { LOG4CXX_ERROR(LOG.configLog, e); failed = true; } catch(const XMLException& e) { LOG4CXX_ERROR(LOG.configLog, e.getMessage()); failed = true; } catch(const SAXParseException& e) { CStdString logMsg; logMsg.Format("config.xml error at line:%d, column:%d. (Use xmllint or xml editor to check the configuration)", e.getLineNumber(), e.getColumnNumber()); LOG4CXX_ERROR(LOG.configLog, logMsg); failed = true; } if (failed) { exit(0); } }