C++ TiXmlHandle类代码示例

//---------------------------------------------------------
bool ofxXmlSettings::pushTag(string  tag, int which){

	int pos = tag.find(":");

	if(pos > 0){
		tag = tag.substr(0,pos);
	}

	//we only allow to push one tag at a time.
	TiXmlHandle isRealHandle = storedHandle->ChildElement(tag, which);

	if( isRealHandle.Node() ){
		*storedHandle = isRealHandle;
		level++;
		return true;
	}else{
		printf("pushTag - tag not found\n");
	}

	return false;
}

//---------------------------------------------------------
bool ofxXmlSettings::attributeExists(const string& tag, const string& attribute, int which){
	vector<string> tokens = tokenize(tag,":");
	TiXmlHandle tagHandle = storedHandle;
	for (int x = 0; x < (int)tokens.size(); x++) {
		if (x == 0)
			tagHandle = tagHandle.ChildElement(tokens.at(x), which);
		else
			tagHandle = tagHandle.FirstChildElement(tokens.at(x));
	}

	if (tagHandle.ToElement()) {
		TiXmlElement* elem = tagHandle.ToElement();
		
		// Do stuff with the element here
		for (TiXmlAttribute* a = elem->FirstAttribute(); a; a = a->Next()) {
			if (a->Name() == attribute)
				return true;
		}
	}
	return false;
}

//---------------------------------------------------------
void ofXMLSettings::removeTag(string  tag, int which){
	
	vector<string> tokens = tokenize(tag,":");
	
	//no tags so we return
	if( tokens.size() == 0 ) return;
		
	//grab the handle from the level we are at
	//normally this is the doc but could be a pushed node
	TiXmlHandle tagHandle = *storedHandle;
	
	if(which < 0) which = 0;
	
	for(int x=0;x<tokens.size();x++){
	
		//we only support multi tags
		//with same name at root level
		if(x > 0) which = 0;
			
		TiXmlHandle isRealHandle = tagHandle.ChildElement( tokens.at(x), which);
		
		if ( !isRealHandle.Node() ) break;
		else{
			if (x == tokens.size()-1){
				//if we are at the last tag and it exists 
				//we use its parent to remove it - haha
				tagHandle.ToNode()->RemoveChild( isRealHandle.ToNode() );
			}
			tagHandle = isRealHandle;
		}
	}
	
	tokens.clear();
}

bool OutputFile::getIt(ParamQt * p)
{
  int deb=0;
  currentIteration++;
  p->setRho(0);
  p->setTheta(0);
  p->setLL(0);
  TiXmlHandle root(&mDoc);
  TiXmlHandle h = root.FirstChild("outputFile");
  TiXmlHandle hIter = h.Child("Iteration", currentIteration);

  TiXmlElement* t;
  // <Tree>
  t = hIter.FirstChild("Tree").ToElement();
  if (t == NULL) // Can I use hIter to return false?
    return false;
  string s(t->GetText());
  while (s.at(0)==10 || s.at(0)==13) s=s.substr(1,s.length()-1);
  while (s.at(s.size()-1)==10 || s.at(s.size()-1)==13) s=s.substr(0,s.length()-1);
  p->setTreeData(new RecTree(getL(),s,false,false),blocks);

  // <number>, <theta>, <delta>, <rho>, <ll>.
  t = hIter.FirstChild("number").ToElement(); p->setNumber(atol(t->GetText()));
  t = hIter.FirstChild("theta").ToElement();  p->setTheta(p->getTheta() + atof(t->GetText()));
  t = hIter.FirstChild("delta").ToElement();  p->setDelta(atof(t->GetText()));
  t = hIter.FirstChild("rho").ToElement();    p->setRho(p->getRho() + atof(t->GetText()));
  t = hIter.FirstChild("ll").ToElement();     p->setLL(p->getLL() + atof(t->GetText()));

  // <recedge>
  TiXmlElement* parent = hIter.ToElement(); 
  TiXmlElement* child = 0;
  while (child = (TiXmlElement*) parent->IterateChildren("recedge", child))
    {
      int start=0,end=0,efrom=0,eto=0;
      double ato=0,afrom=0;
      t = child->FirstChildElement("start"); start = deb + atoi(t->GetText());
      t = child->FirstChildElement("end"); end = deb + atoi(t->GetText());
      t = child->FirstChildElement("efrom"); efrom = atoi(t->GetText());
      t = child->FirstChildElement("eto"); eto = atoi(t->GetText());
      t = child->FirstChildElement("afrom"); afrom = atof(t->GetText());
      t = child->FirstChildElement("ato"); ato = atof(t->GetText());
      p->getTree()->addRecEdge(afrom,ato,start,end,efrom,eto);
    }
  return true;
}

int MetaConfig::flushNodeSrvs(TiXmlHandle *meta)
{
	std::vector<NodeService> tmp;
	TiXmlHandle srvs = meta->FirstChildElement("services");
	if(srvs.Element()){
		TiXmlHandle srv = srvs.FirstChildElement("service");
		while(srv.Element()){
			NodeService ns;
			loadInt(&srv, "gid", ns.gid, -1);
			loadString(&srv, "name", ns.service, "");
			loadString(&srv, "ip", ns.ip, "");
			loadInt(&srv, "port", ns.port, -1);

			if(!(ns.gid != -1 && !ns.service.empty() && !ns.ip.empty() && ns.port != -1)){
				std::cerr << "load service error name:" << ns.service << " ip:" << ns.ip << " port:" << ns.port << " node:" << ns.gid<< std::endl;
				return -1;
			}

			tmp.push_back(ns);
			srv = srv.Element()->NextSibling("service");
		}
		std::sort(tmp.begin(), tmp.end());
		std::unique(tmp.begin(), tmp.end());
	}
	boost::mutex::scoped_lock lock(mtx);
	ndSrvs.swap(tmp);
	return 0;
}

void TinyXmlServerConfigImp::load(FILE *fp){
	loaded = true;
	TiXmlDocument doc;
	doc.LoadFile(fp);

	TiXmlHandle docH( &doc );
	TiXmlHandle servers = docH.FirstChildElement( "conf" ).FirstChildElement( "servers" );
	if(servers.Element()){
		
		TiXmlHandle server = servers.FirstChildElement(serverElem.data());
		if(server.Element()){
			loadServer(server);
		}else{
			log(Fatal, "%s config not found", serverElem.data());
			exit(-1);
		}
	}else{
		log(Error, "servers element is NULL");
	}

	forEachWatcher0(&IServerConfigWatcher::onConfigRefresh);
}

bool userCheck(std::string createdAtStr, TiXmlHandle timelineRootHandle, TiXmlHandle userRootHandle)
{
  std::string weekday, month, day, time, year, tmpStr;
  long utcOffset, utcLower, utcHigher;
  std::stringstream ss, utcStrstream;
  std::stringstream strstream;
  boost::posix_time::ptime ptime, pt, currentTime, mostRecentTweetTime;
  boost::posix_time::time_duration hourDiff;
  int userCount = 0;

  ///// Checks to see if the UTC Offset of the user is in the Americas ///////////
  if(userRootHandle.FirstChild("user").FirstChild("utc_offset").ToNode())
    {
      utcStrstream << userRootHandle.FirstChild("user").FirstChild("utc_offset").ToElement()->GetText();
      utcStrstream >> utcOffset;
      utcLower = 60*60*(-10);  // This is the time zone for Hawaii
      utcHigher = 60*60*(-5);  // This is the time zone for the Eastern most US
      if(utcOffset >= utcLower && utcOffset <= utcHigher)
	{
	  userCount++;
	}
    }

//---------------------------------------------------------
bool ofxXmlSettings::pushTag(const string&  tag, int which){

	int pos = tag.find(":");

    // Either find the tag specified, or the first tag if colon-seperated.
    string tagToFind((pos > 0) ? tag.substr(0,pos) :tag);
    
	//we only allow to push one tag at a time.
	TiXmlHandle isRealHandle = storedHandle.ChildElement(tagToFind, which);

	if( isRealHandle.ToNode() ){
		storedHandle = isRealHandle;
		level++;
		return true;
	}else{
		printf("pushTag - <");
		printf("%s",tag.c_str());
		printf("> tag not found\n");
	}

	return false;
}

bool statusCheck(TiXmlHandle rootHandle)
{
  std::string status;
  status = rootHandle.FirstChild("text").ToElement()->GetText();

  for(int i = 0; i < status.size(); i++)
    {
      if(!isascii(status[i]))
	return false;
    }


  return true;
}

void PointLumiere::initFromXML(TiXmlHandle hObj){
	double x,y,z;
	TiXmlElement* pElem=hObj.Element();
	Lumiere::initFromXML(hObj);
	pElem->QueryDoubleAttribute("x", &x);
	pElem->QueryDoubleAttribute("y", &y);
	pElem->QueryDoubleAttribute("z", &z);

	this->position.Set(x,y,z);
	this->falloff[0]=1.0;
	this->falloff[1]=0.0;
	this->falloff[2]=0.0;

}

    bool TinyDemarshaller::deserialize( PropertyBag &v )
    {
        Logger::In in("TinyDemarshaller");

        if ( !d->loadOkay )
            return false;

		TiXmlHandle docHandle( &d->doc );
		TiXmlHandle propHandle = docHandle.FirstChildElement( "properties" );

        if ( ! propHandle.Node() ) {
            log(Error) << "No <properties> element found in document!"<< endlog();
            return false;
        }

        detail::Tiny2CPFHandler proc( v );

        if ( proc.populateBag( propHandle.Node() ) == false) {
            deleteProperties( v );
            return false;
        }
        return true;
    }

bool sGang::LoadGangXML( TiXmlHandle hGang )
{
    TiXmlElement* pGang = hGang.ToElement();
    
    if( pGang == nullptr )
    {
        return false;
    }
    
    if( pGang->Attribute( "Name" ) )
    {
        m_Name = pGang->Attribute( "Name" );
    }
    
    // load their skills
    LoadSkillsXML( hGang.FirstChild( "Skills" ), m_Skills );
    
    // load their stats
    LoadStatsXML( hGang.FirstChild( "Stats" ), m_Stats );
    
    pGang->QueryIntAttribute( "Num", &m_Num );
    
    //these may not have been saved
    //if not, the query just does not set the value
    //so the default is used, assuming the gang was properly init
    {
        pGang->QueryValueAttribute<u_int>( "MissionID", &m_MissionID );
        pGang->QueryIntAttribute( "LastMissID", &m_LastMissID );
        
        // load the combat boolean
        pGang->QueryValueAttribute<bool>( "Combat", &m_Combat );
        
        // load the auto recruit boolean
        pGang->QueryValueAttribute<bool>( "AutoRecruit", &m_AutoRecruit );
    }
    return true;
}

bool LoadStatsXML(TiXmlHandle hStats, int stats[], int statMods[], int tempStats[])
{
	TiXmlElement* pStats = hStats.ToElement();
	if (pStats == 0) return false;

	for (int i = 0; i < NUM_STATS; i++)
	{
		TiXmlElement* pStat = pStats->FirstChildElement(XMLifyString(sGirl::stat_names[i]));
		if (pStat)
		{
			int tempInt = 0;
			if (pStat->Attribute("Value"))	pStat->QueryIntAttribute("Value", &tempInt);

			int min = 0, max = 100;
			switch (i)
			{
			case STAT_AGE:
				if (tempInt > 99)		tempInt = 100;
				else if (tempInt > 80)		tempInt = 80;
				else if (tempInt < 18)		tempInt = 18;	// `J` Legal Note: 18 is the Legal Age of Majority for the USA where I live 
				break;
			case STAT_EXP:		max = 32000;	break;
			case STAT_LEVEL:	max = 255;		break;
			case STAT_PCFEAR:		case STAT_PCHATE:	case STAT_PCLOVE:	case STAT_MORALITY:
			case STAT_REFINEMENT:	case STAT_DIGNITY:	case STAT_LACTATION:
				min = -100;		break;
			default:	break;
			}
			if (tempInt < -1000)	tempInt = -1;	// test for null stats and set them to 0
			if (tempInt > max) tempInt = max;
			else if (tempInt < min) tempInt = min;
			stats[i] = tempInt;

			if (statMods)
			{
				tempInt = 0;
				if (pStat->Attribute("Mod"))	pStat->QueryIntAttribute("Mod", &tempInt);
				statMods[i] = tempInt;
			}
			if (tempStats)
			{
				tempInt = 0;
				if (pStat->Attribute("Temp"))	pStat->QueryIntAttribute("Temp", &tempInt);
				tempStats[i] = tempInt;
			}
		}
	}
	return true;
}

int MetaConfig::reload()
{
	
	FILE *fp = fopen(fname.c_str(), "r");
	if(!fp){
		log(Warn, "reload file %s error", fname.c_str());
		return -1;
	}

	TiXmlDocument doc;
	doc.LoadFile(fp);

	TiXmlHandle docH( &doc );
	TiXmlHandle meta = docH.FirstChildElement( "conf" ).FirstChildElement( "servers" ).FirstChildElement("meta");
	if(meta.Element()){
		loadBool(&meta, "sync", bsync, false);
		TiXmlHandle daemon = meta.FirstChildElement("daemon");
		int ret = flushNodeSrvs(&daemon);
		return ret;
	}else{
		fclose(fp);
		return -1;
	}
}

//---------------------------------------------------------
int ofxXmlSettings::getNumAttributes(const string& tag, int which){
	vector<string> tokens = tokenize(tag,":");
	TiXmlHandle tagHandle = storedHandle;
	for (int x = 0; x < (int)tokens.size(); x++) {
		if (x == 0)
			tagHandle = tagHandle.ChildElement(tokens.at(x), which);
		else
			tagHandle = tagHandle.FirstChildElement(tokens.at(x));
	}

	if (tagHandle.ToElement()) {
		TiXmlElement* elem = tagHandle.ToElement();

		// Do stuff with the element here
		TiXmlAttribute* first = elem->FirstAttribute();
		if (first) {
			int count = 1;
			for (TiXmlAttribute* curr = first; curr != elem->LastAttribute(); curr = curr->Next())
				count++;
			return count;
		}
	}
	return 0;
}