void CSDReader::propertyfile (DOMElement* element) throw(CSDReadException) { DOMNodeList* nodeList; unsigned int len = 0; unsigned int i = 0; // // fileinarchive // nodeList = element->getElementsByTagName(X("fileinarchive")); len = nodeList->getLength(); for (i = 0; i < len; ++i) { fileinarchive((DOMElement*)(nodeList->item(i))); } // // link // nodeList = element->getElementsByTagName(X("link")); len = nodeList->getLength(); for (i = 0; i < len; ++i) { link((DOMElement*)(nodeList->item(i))); } }
int GameLoop::loadStates(LoadXML* loader) { int status = -1; if(loader != NULL && loader->getDocument() != NULL) { XMLCh nodeName[100]; XMLString::copyString(nodeName, newString("state").c_str()); DOMNodeList* nodeList = loader->getDocument()->getElementsByTagName(nodeName); if(nodeList != NULL && nodeList->getLength() > 0) { for(int i = 0; i < nodeList->getLength(); i++) { String type = loader->getTagContent(newString("type"), (DOMElement*)nodeList->item(i)); String name = loader->getTagContent(newString("name"), (DOMElement*)nodeList->item(i)); BaseState* state = this->newState(name, type); String camera = loader->getTagContent(newString("camera"), (DOMElement*)nodeList->item(i)); String resources = loader->getTagContent(newString("resources"), (DOMElement*)nodeList->item(i)); if(state != NULL) { state->setName(name); state->setResourceXML(resources); state->setCamera(camera); } } } } return status; }
bool FDPLoader::parse() { m_bindings.clear(); m_morphTargetsMeshInfos.clear(); m_faceEntityMeshInfo.clear(); // get the header DOMNodeList* nodes = m_pDoc->getElementsByTagName(XercesString("head")); if(!nodes || nodes->getLength() != 1) // sth wrong return false; if(!parseHeader(nodes->item(0)) ) return false; // get the source info nodes = m_pDoc->getElementsByTagName(XercesString("source")); if(!nodes || nodes->getLength() != 1) // sth wrong return false; parseSource(nodes->item(0)); // process fdp's now nodes = m_pDoc->getElementsByTagName(XercesString("fdp")); XMLSize_t sz = nodes->getLength(); for(XMLSize_t i = 0; i < sz; ++i) loadFDPItem(nodes->item(i)); return true; }
void Generation::GenerationImpl::getGeneration(DOMElement *node) { XMLCh tempStr[20]; XMLString::transcode("id", tempStr, 19); DOMNode *p = node->getAttributes()->getNamedItem(tempStr); if (p) { m_id = getStringNodeValue(p); } XMLString::transcode("name", tempStr, 19); DOMNodeList *list = node->getElementsByTagName(tempStr); if (list->getLength() != 0) { m_name = getTextFromElement((DOMElement *)list->item(0)); } XMLString::transcode("metagames", tempStr, 19); list = node->getElementsByTagName(tempStr); if (list->getLength() != 0) { DOMElement *metagames = (DOMElement *)list->item(0); XMLString::transcode("metagame", tempStr, 19); list = metagames->getElementsByTagName(tempStr); const int length = list->getLength(); for (int i = 0; i < length; ++i) { DOMElement *item = (DOMElement *)list->item(i); MetagamePtr metagame(new Metagame()); metagame.get()->m_impl->getMetagame(item); metagame.get()->m_impl->m_idx = i; metagame.get()->m_impl->m_generation = m_owner; m_metagames.push_back(metagame); } } }
string ClsSettingsReader::getEntity (string strEntityName ) { if(iSysSettingReaderState != PARSER_BUFFER_PARSED){ ClsSettingsReaderException clsSettingsReaderException(ClsSettingsReaderException::BUFFER_NOT_PARSED); throw clsSettingsReaderException; } DOMNode* dnTemp=NULL; DOMNodeList* dnlstTemp = ddocIqrSetting->getElementsByTagName(XMLString::transcode(strEntityName.c_str())); if ( dnlstTemp->getLength() == 1){ dnTemp = dnlstTemp->item(0); } else if ( dnlstTemp->getLength() < 1) { ClsSettingsReaderException clsSettingsReaderException(ClsSettingsReaderException::ENTITY_NOT_FOUND); throw clsSettingsReaderException; } string strValue = ""; DOMNode* dnValue = dnTemp->getFirstChild(); if(dnValue!=NULL){ strValue = XMLString::transcode(dnValue->getNodeValue()); } return strValue; };
void SC_XMLNodeConfig::load() { TRY(SC_XMLNodeConfig::load()); mNodeMap->clear(); createTreeFromFile(mDocPath); RPMS_TRACE(XML_NOD_LOG, "Extracting RPMS node listing"); XMLCh * nodelist = XMLString::transcode( SS_Ini::instance()->getString("xml_elemnames", "hostlist").c_str() ); DOMNodeList *list = getDoc()->getDocumentElement()->getElementsByTagName( nodelist ); if( 1 < list->getLength() ) { throw SX_XMLUtil("More than one node list defined in [" + mDocPath + "]"); } // get the items in the group DOMNodeList *nodes = list->item(0)->getChildNodes(); for( int i = 0; i < nodes->getLength(); ++i ) { // we are only interested in elements DOMElement * cfgNode = dynamic_cast<DOMElement*>( nodes->item(i) ); if( cfgNode ) { ST_SPointer<SC_NodeConfig> c = SC_NodeConfig::build(cfgNode); add( c->getHostName(), c ); } } //clean up XMLString::release(&nodelist); CATCH; }
// 2006/12/16 void stampDocument(DOMElement* root) { DOMElement* meta = NULL; DOMElement* macastamps = NULL; DOMElement* stamp = NULL; stamp = (root->getOwnerDocument())->createElement(XMLString::transcode("maca_stamp")); stamp->setAttribute(XMLString::transcode("module"), XMLString::transcode(_INSTALLED_NAME_)); stamp->setAttribute(XMLString::transcode("version"), XMLString::transcode(_VERSION_)); stamp->setAttribute(XMLString::transcode("timestamp"), XMLString::transcode(getTimestamp().c_str())); DOMNodeList* metaList = root->getElementsByTagName(XMLString::transcode("meta")); if (metaList->getLength() == 0) { // NO meta Element meta = (root->getOwnerDocument())->createElement(XMLString::transcode("meta")); macastamps = (root->getOwnerDocument())->createElement(XMLString::transcode("maca_stamps")); meta->appendChild(macastamps); root->insertBefore(meta,root->getFirstChild()); } else { // meta Element meta = (DOMElement*)metaList->item(0); DOMNodeList* macastampsList = meta->getElementsByTagName(XMLString::transcode("maca_stamps")); if (macastampsList->getLength() == 0) { // NO macastamps Element macastamps = (root->getOwnerDocument())->createElement(XMLString::transcode("maca_stamps")); meta->appendChild(macastamps); } else { // macastamps Element macastamps = (DOMElement*)macastampsList->item(0); } } macastamps->appendChild(stamp); }
/** * Create PerfPart element */ PerfPart::PerfPart( PMLDocument *doc, DOMElement *element ){ m_doc = doc; m_element = element; DOMDocument *domdoc = m_element->getOwnerDocument(); const XMLCh *partID = m_element->getAttribute( XS("part") ); DOMElement *root = m_element->getOwnerDocument()->getDocumentElement(); DOMNodeList *parts = root->getElementsByTagName(XS("part")); for( unsigned int i=0; i<parts->getLength(); i++ ){ DOMElement *e = (DOMElement*)parts->item(i); cout << " perf " << XS( m_element->getAttribute(XS("id"))) << " score " << XS( e->getAttribute(XS("part")) ) << endl; if( !strcmp(XS( m_element->getAttribute(XS("id")) ), XS( e->getAttribute(XS("part")) )) ){ m_scorePart = new ScorePart( m_doc, e ); } } DOMNodeList *nl = m_element->getElementsByTagName(XS(PNote::Tag)); for( int i=0; i<nl->getLength(); i++ ){ m_notes.push_back( new PNote( m_doc, (DOMElement*)nl->item(i) ) ); } }
map<string, DatasetSpecification> Specifications::readDatasetIndex(string str){ map<string, DatasetSpecification> result; XERCES_CPP_NAMESPACE_USE XMLPlatformUtils::Initialize(); XercesDOMParser parser; parser.setValidationScheme(XercesDOMParser::Val_Always); HandlerBase errHandler;// = (ErrorHandler*) new HandlerBase(); parser.setErrorHandler(&errHandler); parser.parse(str.c_str()); DOMDocument * doc = parser.getDocument(); DOMElement* elementRoot = doc->getDocumentElement(); DOMNodeList *entries = elementRoot->getElementsByTagName(XMLString::transcode("dataset")); cout << "Databases in index:\n"; for(size_t i = 0; i < entries->getLength(); ++i){ DOMNode *current = entries->item(i); DatasetSpecification dss; dss.name = XMLString::transcode(current->getAttributes()-> getNamedItem(XMLString::transcode("name"))-> getNodeValue()); dss.root = XMLString::transcode(current->getAttributes()-> getNamedItem(XMLString::transcode("root"))-> getNodeValue()); cout << " name: " << dss.name << " root: " << dss.root << endl; DOMNodeList *categories = current->getChildNodes(); for(size_t j = 0; j < categories->getLength(); ++j) if((string) XMLString::transcode(categories->item(j)->getNodeName()) == "category") dss.categories.push_back(XMLString::transcode(categories->item(j)->getTextContent())); result[dss.name] = dss; } return result; }
void TimeSourceManager::readData(SaveGameFileReader* reader) { reader->initializeXml(); DOMNodeList* rootNodeList = reader->getDocument()->getDocumentElement()->getElementsByTagName(AutoXMLCh(getXmlNodeIdentifier().c_str()).data()); if(rootNodeList->getLength()) { DOMNodeList* xmlTimeSources = static_cast<DOMElement*>(rootNodeList->item(0))->getElementsByTagName(AutoXMLCh("gameobject").data()); //there should be only one "gameobjects" node if(xmlTimeSources->getLength()) { for(XMLSize_t childIdx = 0; childIdx < xmlTimeSources->getLength(); childIdx++) { DOMNode* xmlTimeSource = xmlTimeSources->item(childIdx); if(xmlTimeSource->getNodeType() == DOMNode::ELEMENT_NODE) { TimeSource::TimeSourceType ID = (TimeSource::TimeSourceType)reader->getAttributeValueAsInteger( static_cast<DOMElement*>(xmlTimeSource), "ID"); PropertyRecordPtr properties = reader->getPropertiesAsRecord(static_cast<DOMElement*>(xmlTimeSource)); std::map<TimeSource::TimeSourceType, TimeSource*>::const_iterator it_time_sources = mTimeSources.find(ID); if(it_time_sources != mTimeSources.end()) it_time_sources->second->setClock(properties->toPropertyMap()["time"].toInt()); } } } } reader->shutdownXml(); }
void CSDReader::implementation (DOMElement* element) throw(CSDReadException) { DOMNodeList* nodeList; unsigned int len = 0; unsigned int i = 0; // // dependency // nodeList = element->getElementsByTagName(X("dependency")); len = nodeList->getLength(); for (i = 0; i < len; ++i) { dependency((DOMElement*)(nodeList->item(i))); } // // descriptor // nodeList = element->getElementsByTagName(X("descriptor")); len = nodeList->getLength(); if(len == 1) { ccd_file_ = descriptor((DOMElement*)(nodeList->item(0))); } else if(len > 1) { NORMAL_ERR( "CSDReader: multiple descriptors" ); } // // code // nodeList = element->getElementsByTagName(X("code")); len = nodeList->getLength(); if(len == 0) { NORMAL_ERR2( "CSDReader: missing code for ", data_->uuid ); throw CSDReadException(); } for (i = 0; i < len; ++i) { code((DOMElement*)(nodeList->item(i))); } // // os // nodeList = element->getElementsByTagName(X("os")); len = nodeList->getLength(); for (i = 0; i < len; ++i) { os((DOMElement*)(nodeList->item(i))); } // more todo }
bool CConfigParser::ParseDeviceContexts(DOMNodeList* deviceContextNodes, ADeviceListener& configClass) { ASSERT(deviceContextNodes->getLength() == 1); DOMNode* deviceContextNode = deviceContextNodes->item(0); DOMNodeList* deviceContexts = deviceContextNode->getChildNodes(); for(unsigned long idx = 0; idx < deviceContexts->getLength(); idx++) { DOMNode* currentDeviceContext = deviceContexts->item(idx); wstring deviceContextNodeName = currentDeviceContext->getNodeName(); if(deviceContextNodeName.compare(L"#text") == 0) continue; if(deviceContextNodeName.compare(L"#comment") == 0) continue; wstring deviceContextName = currentDeviceContext->getAttributes()->getNamedItem(L"name")->getNodeValue(); wstring deviceName = currentDeviceContext->getAttributes()->getNamedItem(L"device")->getNodeValue(); bool gestures = false; if(currentDeviceContext->getAttributes()->getNamedItem(L"gestures") != NULL) gestures = true; // Create the device context to add CDeviceContext* deviceContextToAdd = NULL; if(configClass.GetDevices()[deviceName]->GetType().compare("mouse") == 0) deviceContextToAdd = new CMouseDeviceContext(gestures, deviceName); else deviceContextToAdd = new CDeviceContext(gestures, deviceName); // Get the device contexts axis and buttons added if(currentDeviceContext->hasChildNodes()) { unsigned char axeIdx = 0; DOMNodeList* children = currentDeviceContext->getChildNodes(); unsigned long childCount = children->getLength(); for(unsigned long idx = 0; idx < childCount; idx++) { DOMNode* childNode = children->item(idx); wstring nodeName = childNode->getNodeName(); if(nodeName.compare(L"axe") == 0) { ParseAxe(childNode, configClass.GetActions(), deviceContextToAdd, axeIdx); axeIdx++; } if(nodeName.compare(L"buttons") == 0) ParseButtons(childNode, configClass.GetActions(), deviceContextToAdd); if(nodeName.compare(L"gesture") == 0) ParseGesture(childNode, configClass.GetActions(), deviceContextToAdd); } } configClass.AddDeviceContext(deviceContextName, deviceContextToAdd); TRACE("Device Context <%S> is 0x%X\r\n", deviceContextName.c_str(), deviceContextToAdd); } return true; }
void SPDImplementation::parsePropertyDependencies(DOMElement * _elem) { DEBUG(4, SPDImplementation, "In parsePropertyDependencies."); std::vector <DOMNode*> _list; tmpXMLStr = XMLString::transcode("dependency"); DOMNodeList *nodeList = _elem->getElementsByTagName(tmpXMLStr); sweetd(tmpXMLStr); unsigned int len; DOMElement *_tmpElement; for (unsigned int i = 0; i < nodeList->getLength (); i++) { tmpXMLStr = XMLString::transcode("propertyref"); DOMNodeList *childNodeList = ((DOMElement *) nodeList->item (i))->getElementsByTagName(tmpXMLStr); sweetd(tmpXMLStr); len = childNodeList->getLength(); if (len > 0) { for (unsigned int i = 0; i < len; i++) _list.push_back (childNodeList->item (i)); } } len = _list.size(); const XMLCh *_tmp; const XMLCh *_tmp2; char *_id; char *_val; if (len > 0) { propDep.length (len); for (unsigned int i = 0; i < len; i++) { _tmpElement = (DOMElement *) _list[i]; tmpXMLStr = XMLString::transcode("refid"); _tmp = _tmpElement->getAttribute(tmpXMLStr); sweetd(tmpXMLStr); _id = XMLString::transcode (_tmp); propDep[i].id = CORBA::string_dup(_id); tmpXMLStr = XMLString::transcode("value"); _tmp2 = _tmpElement->getAttribute(tmpXMLStr); _val = XMLString::transcode(_tmp2); propDep[i].value <<= _val; } } }
string core::xml::getAllTextNodes(DOMNode *const node) throw () { stringstream result; DOMNodeList *children = node->getChildNodes(); if (children->getLength() > 1) { for (unsigned int i = 0 ; i < children->getLength() ; i++) { result << getAllTextNodes(children->item(i)); } } else { // Trim result << xts(node->getTextContent(), true).asString(); } return result.str(); }
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; }
set<string>* EpiMCMCConfig::getParameterNames() { /** Returns a pointer to an STL set of parameter names. Throws a ConfigException if duplicate names are found in the DOM **/ XMLCh* buff; // Character buffer. Used to delete objects mainly. buff = XMLString::transcode("parameter"); DOMNodeList* parmList = doc->getElementsByTagName(buff); XMLString::release(&buff); set<string>* parmNames = new set<string>; pair<set<string>::iterator,bool> isInserted; for(size_t i = 0; i<parmList->getLength(); ++i) { DOMNode* parm = parmList->item(i); buff = XMLString::transcode("id"); DOMNode* idAttr = parm->getAttributes()->getNamedItem(buff); XMLString::release(&buff); char* id = XMLString::transcode(idAttr->getNodeValue()) ; isInserted = parmNames->insert(id); if(isInserted.second == false) { string msg("Duplicate string inserted: "); msg += id; XMLString::release(&id); throw ConfigException(msg.c_str()); } XMLString::release(&id); } return parmNames; }
bool LayerImporter::removeGeoNodes(DOMNode* pNode) const { if (NULL != pNode) { if (XMLString::equals(pNode->getNodeName(), X("geoVertices")) || XMLString::equals(pNode->getNodeName(), X("geoBox"))) { DOMNode* pParentNode = pNode->getParentNode(); if (NULL != pParentNode) { pParentNode->removeChild(pNode); } } else if (pNode->hasChildNodes()) { DOMNodeList* pChildren = pNode->getChildNodes(); for (unsigned int i = 0; i < pChildren->getLength(); ++i) { DOMNode* pChildNode = pChildren->item(i); removeGeoNodes(pChildNode); } } } return true; }
void *NclPresentationControlParser::posCompileSwitch( DOMElement *parentElement, void *parentObject) { wclog << "posCompileSwitch" << endl; DOMNodeList *elementNodeList; int i, size; DOMNode *node; void *elementObject; elementNodeList = parentElement->getChildNodes(); size = elementNodeList->getLength(); for (i = 0; i < size; i++) { node = elementNodeList->item(i); if (node->getNodeType() == DOMNode::ELEMENT_NODE && XMLString::compareIString( ((DOMElement*)node)->getTagName(), XMLString::transcode("switchPort")) == 0) { elementObject = getInterfacesParser()->parseSwitchPort( (DOMElement*)node, parentObject); if (elementObject != NULL) { addSwitchPortToSwitch(parentObject, elementObject); } } } return parentObject; }
void XMLAAPImpl::init() { NDC ndc("XMLAAPImpl"); Category& log=Category::getInstance(XMLPROVIDERS_LOGCAT".XMLAAPImpl"); try { if (!saml::XML::isElementNamed(m_root,::XML::SHIB_NS,SHIB_L(AttributeAcceptancePolicy))) { log.error("Construction requires a valid AAP file: (shib:AttributeAcceptancePolicy as root element)"); throw MalformedException("Construction requires a valid AAP file: (shib:AttributeAcceptancePolicy as root element)"); } // Check for AnyAttribute element. DOMElement* anyAttr = saml::XML::getFirstChildElement(m_root,::XML::SHIB_NS,SHIB_L(AnyAttribute)); if (anyAttr) anyAttribute = true; // Loop over the AttributeRule elements. DOMNodeList* nlist = m_root->getElementsByTagNameNS(::XML::SHIB_NS,SHIB_L(AttributeRule)); for (int i=0; nlist && i<nlist->getLength(); i++) { AttributeRule* rule=new AttributeRule(static_cast<DOMElement*>(nlist->item(i))); #ifdef HAVE_GOOD_STL xstring key=rule->getName(); key=key + chBang + chBang + (rule->getNamespace() ? rule->getNamespace() : Constants::SHIB_ATTRIBUTE_NAMESPACE_URI); #else auto_ptr_char aname(rule->getName()); string key(aname.get()); key+="!!"; if (rule->getNamespace()) { auto_ptr_char ans(rule->getNamespace()); key+=ans.get(); } else key+="urn:mace:shibboleth:1.0:attributeNamespace:uri"; #endif m_attrMap[key]=rule; m_attrs.push_back(rule); if (rule->getAlias()) m_aliasMap[rule->getAlias()]=rule; } } catch (SAMLException& e) { log.errorStream() << "Error while parsing AAP: " << e.what() << CategoryStream::ENDLINE; for (attrmap_t::iterator i=m_attrMap.begin(); i!=m_attrMap.end(); i++) delete i->second; throw; } catch (...) { log.error("Unexpected error while parsing AAP"); for (attrmap_t::iterator i=m_attrMap.begin(); i!=m_attrMap.end(); i++) delete i->second; throw; } }
void XMLparser::parseConfigFile(std::string& configFile) { DOMElement *currentElement; DOMElement *elementRoot; DOMNode *currentNode; DOMNodeList *children; XMLSize_t nodeCount; DOMDocument *xmlDoc; this->ConfigFileParser_->parse(configFile.c_str()); xmlDoc = this->ConfigFileParser_->getDocument(); elementRoot = xmlDoc->getDocumentElement(); if (!elementRoot) std::cerr << "empty XML document" << std::endl; children = elementRoot->getChildNodes(); nodeCount = children->getLength(); for(XMLSize_t xx = 0; xx < nodeCount; ++xx) { currentNode = children->item(xx); if(currentNode->getNodeType() && currentNode->getNodeType() == DOMNode::ELEMENT_NODE) { currentElement = dynamic_cast< xercesc::DOMElement* >(currentNode); this->getAttributes(currentElement); } } if (conf["port"].mValue.empty() || conf["thread-number"].mValue.empty() || conf["root-dir"].mValue.empty()) { this->putDefaultValues(); } }
int CApp::loadXercesDataFamille( dlgAmonSoft &amon ) { try { XERCES_CPP_NAMESPACE::DOMDocument *pDoc = g_ParserFamille->getDocument(); XERCES_CPP_NAMESPACE::DOMElement *pElem = pDoc->getDocumentElement(); CheckDataFileVersion( pElem, amon ); DOMNodeList *pNodeList = pElem->getChildNodes (); uint size = pNodeList->getLength(); for( uint i = 0; i < size; i++ ) { DOMNode *pNode = pNodeList->item( i ); if( XMLString::equals( XMLString::transcode( pNode->getNodeName() ), "Famille" ) ) { Datas::CFamille *pFamille = new Datas::CFamille( 0 ); DOMElement *elmt = static_cast< DOMElement* >( pNode ); mAssert( elmt != 0, "elmt != 0" ); // loadFromXML has to link with correct CPersonne, this means // that all CPersonne *must* be loaded before ! int iRet = pFamille->loadFromXML( elmt ); if( iRet == -1 ) delete pFamille; } } } catch( DOMException &e ) { qDebug( XMLString::transcode( e.getMessage() ) ); } return 0; }
void AcsAlarmTestCase::verifyUserTimestampElement(DOMDocument * doc) { // Verify the user-timestamp element DOMNodeList * userTimestampNodes = doc->getElementsByTagName(USER_TIMESTAMP_TAG_NAME); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; no user-properties element found", (NULL != userTimestampNodes && userTimestampNodes->getLength() == 1)); // verify that there are 2 attributes DOMNamedNodeMap * attributesMap = userTimestampNodes->item(0)->getAttributes(); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; user-timestamp element does not contain 2 attributes", (NULL!= attributesMap && attributesMap->getLength() == 2)); // check for seconds attribute DOMNode * secondsValueNode = attributesMap->getNamedItem(SECONDS_TAG_NAME); const XMLCh * secondsValue = secondsValueNode->getNodeValue(); char *secondsCharValue = XMLString::transcode(secondsValue); int secondsIntValue = atoi(secondsCharValue); XMLString::release(&secondsCharValue); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; user-timestamp element, 'seconds' attribute value is not correct", (NULL!= secondsValue && secondsIntValue == SECONDS_VALUE)); // check for microseconds attribute DOMNode * microsecondsValueNode = attributesMap->getNamedItem(MICROSECONDS_TAG_NAME); const XMLCh * microsecondsValue = microsecondsValueNode->getNodeValue(); char *microsecondsCharValue = XMLString::transcode(microsecondsValue); int microsecondsIntValue = atoi(microsecondsCharValue); XMLString::release(µsecondsCharValue); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; user-timestamp element, 'microseconds' attribute value is not correct", (NULL!= microsecondsValue && microsecondsIntValue == MICROSECONDS_VALUE)); }
void browseTree(DOMNode* root) { static int indent = 1; indent++; DOMNodeList* list = root->getChildNodes(); for( int i = 0; i < list->getLength(); i++ ) { DOMNode* node = list->item(i); DOMString name = node->getLocalName(); if( name.isNull() ) { name = node->getNodeName(); } if( name.isNull() ) { continue; } if ( name.equals("#text") ) continue; printDash(indent); cout<<name<<endl; browseTree(node); } indent--; }
void OptionValueParser::parse_boolean_option(BooleanOption* option, DOMNode* node) { std::string node_value = ""; DOMNodeList* children = node->getChildNodes(); for (size_t i = 0; i < children->getLength(); ++i) { if (children->item(i)->getNodeType() == DOMNode::TEXT_NODE) { XMLUnicodeString value = children->item(i)->getNodeValue(); node_value = value.str(); } } node_value = delete_begin_end_spaces(node_value); if (node_value == std::string("true")) { option->set(true); } else { option->set(false); } }
EppAuthInfo * EppAuthInfo::fromXML( const DOMNode& root ) { DOMNodeList* list = root.getChildNodes(); for( unsigned int i = 0; i < list->getLength(); i++ ) { DOMNode* node = list->item(i); DOMString name = node->getLocalName(); if( name.isNull() ) { name = node->getNodeName(); } if( name.isNull() ) { continue; } // if( name.equals("pw") ) if( name.equals("pw") || name.equals("contact:pw") || name.equals("domain:pw") || name.equals("svcsub:pw") || name.equals("xriAU:pw") || name.equals("xriINU:pw") || name.equals("xriINA:pw") || name.equals("xriISV:pw") /* Uncomment for CodeString || name.equals("xriCS:pw")*/ ) { DOMElement * elm = (DOMElement *) node; DOMString roid = elm->getAttribute(XS("roid")); DOMString value = EppUtil::getText(*node); return new EppAuthInfo(XS(TYPE_PW), value, roid); } // else if( name.equals("ext") ) else if( name.equals("ext") || name.equals("contact:ext") || name.equals("domain:ext") || name.equals("svcsub:ext") || name.equals("xriAU:ext") || name.equals("xriINU:ext") || name.equals("xriINA:ext") || name.equals("xriISV:ext") ) { return new EppAuthInfo(XS(TYPE_EXT), NULLXS); } } return null; }
// http://thelastpcbender.blogspot.com/2008/11/introduction-to-xerces-c-domparser.html std::string CXercesUtils::GetSubElementValues(DOMElement* e , std::vector<std::string> &excludes) { std::string value; DOMNodeList * Child = e-> getChildNodes(); const XMLSize_t nc = Child->getLength(); //now we traverse the tree, note that we use XMLSize_t instead of int // for(XMLSize_t i=0; i< nc; i++) { DOMNode* currentNode = Child->item(i); if(currentNode && currentNode->getNodeType() && currentNode->getNodeType() == DOMNode::ELEMENT_NODE ) { DOMElement* currentElem = (DOMElement*) currentNode; std::string elemname = GetElementName(currentElem ); if(std::find(excludes.begin(), excludes.end(), elemname) != excludes.end()) continue; if(currentElem->getChildElementCount() == (XMLSize_t) 0) { value+=GetElementName(currentElem ); value+="="; value+=GetElementValue(currentElem ); value+="<br>"; } // recursively add items else { value+=GetSubElementValues(currentElem , excludes) ; } } } return value; }
// // get_element_value // void Utils:: get_element_value (const xercesc::DOMElement * e, const std::string & element, std::string & value) { using namespace xercesc; // There should be only 1 <name> tag in the list. DOMNodeList * list = e->getElementsByTagName (GAME::Xml::String (element)); size_t len = list->getLength (); assert (len <= 1); if (len == 0) { value = ""; } else if (len == 1) { // Get text content of the one and only node in listing. DOMNode * node = list->item (0); GAME::Xml::String content (node->getTextContent (), false); // Save the value in C string format. value = content.to_string (); } }
DOMElement *NclImportParser::parseImportedDocumentBase( DOMElement *parentElement ) { DOMNodeList *elementNodeList; DOMElement *element; DOMNode *node; string elementTagName; //pre-compile attributes if (parentElement == NULL) { return NULL; } elementNodeList = parentElement->getChildNodes(); for (int i = 0; i < (int) elementNodeList->getLength(); i++) { node = elementNodeList->item( i ); if (node->getNodeType() == DOMNode::ELEMENT_NODE) { element = (DOMElement*) node; elementTagName = getXmlHandler()->getStr( element->getTagName() ); if (elementTagName.compare( "importNCL" ) == 0) { if (!addImportNCLToImportedDocumentBase(element)){ return NULL; } } } } return parentElement; }
//============================================================================= // METHOD: SPELLxmlConfigReaderXC::convertToNode //============================================================================= SPELLxmlNode* SPELLxmlConfigReaderXC::convertToNode( DOMElement* element ) { // Create an abstract node with this name SPELLxmlNode* node = new SPELLxmlNode( XMLString::transcode(element->getNodeName()) ); // Get any possible attributes DOMNamedNodeMap* attrs = element->getAttributes(); XMLSize_t numAttrs = attrs->getLength(); for( XMLSize_t idx = 0; idx < numAttrs; idx++) { // Get the attribute node DOMNode* attrNode = attrs->item(idx); // Get name and value const XMLCh* aname = attrNode->getNodeName(); const XMLCh* avalue = attrNode->getNodeValue(); // Convert name and value to strings std::string name = "<?>"; if (aname != NULL) { name = XMLString::transcode(aname); } std::string value = "<?>"; if (avalue != NULL) { value = XMLString::transcode(avalue); } node->addAttribute( name, value ); } // Get any possible children DOMNodeList* children = element->getChildNodes(); XMLSize_t numChildren = children->getLength(); for( XMLSize_t idx = 0; idx < numChildren; idx++) { // Get the children node DOMNode* childNode = children->item(idx); // Process only ELEMENTs and TEXTs if (childNode->getNodeType() && // true is not NULL childNode->getNodeType() == DOMNode::ELEMENT_NODE) // is element { // For elements, recursively add children SPELLxmlNode* child = convertToNode( dynamic_cast<xercesc::DOMElement*>(childNode) ); node->addChild(child); } else if (childNode->getNodeType() == DOMNode::TEXT_NODE) { // For text values, add the value. This code will just ignore // carriage-return values const XMLCh* nvalue = childNode->getNodeValue(); if (nvalue != NULL) { std::string thevalue = XMLString::transcode(nvalue); SPELLutils::trim(thevalue, " \n\r\t"); node->setValue( thevalue ); } } } return node; }
EppCredsOptions * EppCredsOptions::fromXML( const DOMNode& root ) { DOMString version; DOMString lang; DOMNodeList* list = root.getChildNodes(); for( unsigned int i = 0; i < list->getLength(); i++ ) { DOMNode* node = list->item(i); DOMString name = node->getLocalName(); if( name.isNull() ) { name = node->getNodeName(); } if( name.isNull() ) { continue; } if( name.equals("version") ) { version = EppUtil::getText(*node); } else if( name.equals("lang") ) { lang = EppUtil::getText(*node); } } if( (version.isNotNull()) && (lang.isNotNull()) ) { return new EppCredsOptions(version, lang); } return null; }