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;
}
