C++ XMLDocument::LoadFile方法代码示例

TestData readXMLDoc() {

    XMLDocument doc;
#ifdef WIN32
    XMLCheckResult(doc.LoadFile("../../test/mpw_tests.xml"));
#else
    XMLCheckResult(doc.LoadFile("mpw_tests.xml"));
#endif

    TestData data;
    XMLNode * pRoot = doc.FirstChild();
    if (pRoot == 0) return data;

    XMLElement * pListElement = pRoot->FirstChildElement("case");
    TestData testData;

    while (pListElement != 0) {
        //We have a test case. Allocate memory for it.
        TestCase testCase;

        //Get the ID of this case
        std::string id = pListElement->Attribute("id");
        std::cout << "ID: " << id << std::endl;

        //Now check if we have a parent.
        const char* pParent = pListElement->Attribute("parent");
        if (pParent) {
            testCase = testData.at(pParent);
        }

        //Now fill in the data from this node.
        XMLElement * pNodeListElement = pListElement->FirstChildElement();
        while (pNodeListElement != 0) {
            const char* name = pNodeListElement->Name();
            const char* value = pNodeListElement->GetText();
            if (value != 0) {
                testCase[name] = value;
                std::cout << name << ": " << testCase[name] << std::endl;
            }
            else {
                testCase[name] = "";
                std::cout << name << ": " << "null" << std::endl;
            }
            pNodeListElement = pNodeListElement->NextSiblingElement();
        }

        testData[id] = testCase;

        pListElement = pListElement->NextSiblingElement("case");
    }

    return testData;
}

std::shared_ptr<RoadPatch::PatchArray> RoadPatch::loadPatches(const std::string& filename)
{
  XMLDocument doc;
  doc.LoadFile(filename.c_str());

  if (doc.Error())
    return nullptr;

  std::shared_ptr<PatchArray> arr = std::make_shared<PatchArray>();

  for (XMLElement* titleElement = doc.FirstChildElement(XML_TITLE_ELEMENT);
       titleElement != nullptr;
       titleElement = titleElement->NextSiblingElement(XML_TITLE_ELEMENT))
  {
    // Create new
    ConstPtr tmp = std::make_shared<RoadPatch>(titleElement);

    // Check for XML/Read error
    if (!tmp->good())
      return nullptr;

    // Save according to ID
    (*arr)[tmp->getPatchTypeInt()] = tmp;
  }

  return arr;
}

int readFile(string file)
{
	XMLDocument doc;
	doc.LoadFile(file.data());
	cout <<  file << "\n";
	if(!doc.ErrorID())
	{
		int raio_circulo;
		
		XMLElement* janela = doc.FirstChildElement("aplicacao")->FirstChildElement("janela");
		const char *titulo = janela->FirstChildElement("titulo")->GetText();
		janela->FirstChildElement( "largura" )->QueryIntText( &width );
		janela->FirstChildElement( "altura" )->QueryIntText( &height );
		janela->FirstChildElement("fundo")->QueryIntAttribute("corR",&corR_fundo);
		janela->FirstChildElement("fundo")->QueryIntAttribute("corG",&corG_fundo);
		janela->FirstChildElement("fundo")->QueryIntAttribute("corB",&corB_fundo);
		
		XMLElement* circulo = doc.FirstChildElement("aplicacao")->FirstChildElement("circulo");
		circulo->QueryIntAttribute( "raio", &raio_circulo);
		circulo->QueryIntAttribute("corR",&corR_circulo);
		circulo->QueryIntAttribute("corG",&corG_circulo);
		circulo->QueryIntAttribute("corB",&corB_circulo);
		

		title = std::string(titulo);
		radius = raio_circulo/(double)width;
	}else
	{
		cout << "Erro ao abrir o arquivo XML "<< file << "\n";
	}	
	return doc.ErrorID();
}

void TMXSceneEncoder::write(const EncoderArguments& arguments)
{
    XMLDocument xmlDoc;
    XMLError err;
    if ((err = xmlDoc.LoadFile(arguments.getFilePath().c_str())) != XML_NO_ERROR)
    {
        LOG(1, "Call to XMLDocument::LoadFile() failed.\n");
        LOG(1, "Error returned: %d\n\n", err);
        return;
    }
    
    // Parse the Tiled map
    TMXMap map;
    string inputDirectory = arguments.getFileDirPath();

    LOG(2, "Parsing .tmx file.\n");
    if (!parseTmx(xmlDoc, map, inputDirectory))
    {
        return;
    }

    // Apply a gutter, or skirt, around the tiles to prevent gaps
    if (arguments.generateTextureGutter())
    {
        LOG(2, "Bulding gutter tilesets.\n");
        buildTileGutter(map, inputDirectory, arguments.getOutputDirPath());
    }

    // Write the tile map
    string fileName = arguments.getFileName();
    int pos = fileName.find_last_of('.');

    LOG(2, "Writing .scene file.\n");
    writeScene(map, arguments.getOutputFilePath(), (pos == -1 ? fileName : fileName.substr(0, pos)));
}

string XMLHandler::LoadLink(string name)
{
    XMLDocument doc;
    doc.LoadFile("links.xml");
    if( doc.Error() )
    {
        cout << "\nERROR:" << doc.ErrorID() << endl;
        return "ERROR";
    }

    XMLElement* rootNode = doc.FirstChildElement("Links");
    if (!rootNode) std::cout << "No Links element" << std::endl;

    XMLElement* linkNode = rootNode->FirstChildElement("Link");
    if(!linkNode) std::cout << "No link elements" << std::endl;

    // Loop through XML
    for( ; linkNode != NULL; linkNode = linkNode->NextSiblingElement() )
    {
        if( name == linkNode->Attribute("name") )
        {
            return linkNode->Attribute("url");
        }
    }

    return "NOTFOUND";
}

void XmlReader::xmlReadContactInfo(void)
{
    XMLDocument doc;
    doc.LoadFile(m_filename);
    if (doc.ErrorID() != 0) {
        printf("read xml error!\n");
        return;
    }
    XMLElement *root = doc.FirstChildElement("root");

    XMLElement *contacts = root->FirstChildElement("contacts");
    for (XMLElement *contact = contacts->FirstChildElement("contact");
         contact;
         contact = contact->NextSiblingElement("contact")) {
        XMLElement *user2_id = contact->FirstChildElement("user_id");
        XMLElement *user2_account = contact->FirstChildElement("user_acount");
        XMLElement *user2_name = contact->FirstChildElement("user_name");

        printf("user_id: %s\n", user2_id->GetText());
        printf("user_account: %s\n",  user2_account->GetText());
        printf("user_name: %s\n", user2_name->GetText());
        printf("\n");
    }

}

bool TileMap::load(const char * file)
{
	this->clear();

	XMLDocument document;
	document.LoadFile(file);
	XMLElement * root = document.FirstChildElement("map");
	if(root != 0)
	{
		// base path
		strcpy(_basePath, file);
		char* p = &_basePath[strlen(file)-1];
		while(p != _basePath && *p != '/')
			p--;

		if(*p == '/')
			*p = 0;

		analyzeMapInfo(root);
		for(XMLElement* e = root->FirstChildElement(); e != 0; e = e->NextSiblingElement())
		{
			if(e->Value() == std::string("tileset"))
				this->analyzeTileset(e);
			else if(e->Value() == std::string("layer"))
				this->anylyzeLayers(e);
			else if(e->Value() == std::string("imagelayer"))
				this->anylyzeImageLayer(e);
		}
		return true;
	}
	return false;
}

bool ReverbsXml::LoadXml(string file)
{
    XMLDocument doc;
    XMLError e = doc.LoadFile(file.c_str());
    if (e != XML_SUCCESS)  return false;

    XMLElement* root = doc.RootElement();
    if (!root)  return false;

    //  clear
    revs.clear();
    revmap.clear();


    //  base
    XMLElement* b = root->FirstChildElement("base");
    if (b)
        GetParams(b, base);

    ///  revs
    int i=1;  //0 = none
    XMLElement* n = root->FirstChildElement("rev");
    while (n)
    {
        ReverbSet r;
        GetParams(n, r);

        revs.push_back(r);
        revmap[r.name] = i++;
        n = n->NextSiblingElement("rev");
    }
    return true;
}

bool FractalConfiguration::readFractalID(string filename, string *id, string *error)
{
	XMLDocument doc;

	// Parse file
	doc.LoadFile(filename.c_str());

	if(doc.Error())
	{
		*error = doc.GetErrorStr1();
		return true;
	}

	// Get ID
	XMLElement *root = doc.RootElement();
	string name = string(root->Name());

	if(name != "fractal")
	{
		*error = "Configuration file is invalid!";
		return true;
	}

	const char* id_tmp = root->Attribute("id");

	if(id_tmp == NULL)
	{
		*error = "Configuration file is invalid!";
		return true;
	}

	*id = string(id_tmp);
	return false;
}

COscillator::COscillator ( string* sParamsFile , int nID ){ 
	m_nID       = nID;
	// Configuration from XML
	XMLDocument conf;
    	conf.LoadFile( sParamsFile->c_str() );
	XMLElement* root = conf.FirstChildElement();
	string elemName , attr;	
	for( XMLElement* elem = root->FirstChildElement() ; elem != NULL ; elem = elem->NextSiblingElement() ){
		elemName = elem->Value();
		if ( elemName == "Oscilators" ){
			attr       = elem->Attribute("distribution");
			m_nIniDist = atoi( attr.c_str() );
			attr       = elem->Attribute("N");
			m_fN       = atof( attr.c_str() );
			attr       = elem->Attribute("offset");
			m_fOffset  = atof( attr.c_str() );
			for( XMLElement* e = elem->FirstChildElement() ; e != NULL ; e = e->NextSiblingElement() ){
				elemName = e->Value();
				if ( elemName == "coupling" ){
					attr     = e->Attribute("type");
					m_nKType = atoi( attr.c_str() );
					attr     = e->Attribute("K");
					m_fK     = atof( attr.c_str() );
				}
				else if ( elemName == "switching" ){
					attr     = e->Attribute("type");
					m_nPType = atoi( attr.c_str() );
					attr     = e->Attribute("P");
					m_fP     = atof( attr.c_str() );										
				}
			}							
		}
	}
	return;
};

/**
 * Get a scene from a map file in XML format.
 */
Scene* MapLoader::getScene(const std::string &path) {
  scene = new Scene();
  // FIXME: shall we init player here? Probably not, and do it ONCE.
  scene->player.addComponent<Transform>();
  scene->player.addComponent<PlayerMotion>();
  scene->player.addComponent<Health>();
  scene->player.addComponent<SoundSource>();
  scene->player.addComponent<SoundListener>();

  XMLDocument doc;
  XMLError error = doc.LoadFile((Environment::getDataDir() + "/maps/" + path + ".xml").c_str());

  if (error == XML_NO_ERROR) {
    XMLHandle docHandle(&doc);
    XMLElement *element = docHandle.FirstChildElement().ToElement();
    rootHandle = XMLHandle(element);

    extractMaterials();
    extractSpawn();
    extractDoor();
    extractModels();
    extractLights();
    extractWalls();
    extractAcids();
    extractTriggers();
    System::Log(Info) << "Map " << path << " loaded";
  } else {
    System::Log(Error) << "Failed to load map " << Environment::getDataDir() << "/" << path << ".xml";
  }
  return scene;
}

void CEnvironment::_configureSinusoidal ( void ){ 	
	/* Read components from XML file */
	XMLDocument conf;
    	conf.LoadFile( m_sSourceFile.c_str() );
	XMLElement* root = conf.FirstChildElement();
	string   elemName, attr;
	SFreqCmp tmp_FC;
	for( XMLElement* elem = root->FirstChildElement() ; elem != NULL ; elem = elem->NextSiblingElement() ){
		elemName = elem->Value();
		if ( elemName == "Cmp" ){
			attr          = elem->Attribute("period");
			tmp_FC.period = atof( attr.c_str() ) / float ( m_nSampling );
			attr          = elem->Attribute("phase");
			tmp_FC.phs    = atof( attr.c_str() );
			attr          = elem->Attribute("amplitude");
			tmp_FC.amp    = m_fAmplitude * atof( attr.c_str() );
			if ( tmp_FC.period > 0.0 ){
				m_vInputSignal [ int ( float( m_nFFTsize  ) / tmp_FC.period ) ] = tmp_FC;
				m_vNCAmp       [ int ( float( m_nFFTsize  ) / tmp_FC.period ) ] = tmp_FC.amp;
			}
			else{
				m_vInputSignal [ 0 ] = tmp_FC;
				m_vNCAmp       [ 0 ] = tmp_FC.amp;

			}
		}
	}
	return;
};

std::shared_ptr<Screen> XMLScreenLoader::loadScreen(const std::string &path) {
  std::shared_ptr<Screen> screen = std::make_shared<Screen>(); //setup screen pointer

  XMLDocument doc;
  XMLError error = doc.LoadFile(path.c_str()); //load in XML document

  if (error == 0){
    XMLHandle docHandle(&doc);
    XMLElement *element = docHandle.FirstChildElement("screen").ToElement();
    XMLHandle rootHandle = XMLHandle(element);

    //screen->textColor = loadTextColor(rootHandle);
    //screen->bgColor = loadbgColor(rootHandle);

    if (!loadText(rootHandle, &screen->text)) Util::Log(Error, "XMLScreenLoader") << "Failed to load text in " << path;
    if (!extractColor(element, &screen->color)) Util::Log(Error, "XMLScreenLoader") << "Failed to load color in " << path;
    //if (screen->bgColor.x == 0) Util::Log(Error, "XMLScreenLoader") << "Failed to find background color element in " << path;

    Util::Log(Debug, "XMLScreenLoader") << "Screen " << path << " loaded";

    return screen;
  } else {
    Util::Log(Error, "XMLScreenLoader") << "Failed to load screen " << path;
    return nullptr;
  }
}

Parser::MetaParserStatus Parser::load_xml(const char *file_path){
	using namespace tinyxml2;
	XMLDocument doc;
	{
		switch (doc.LoadFile(file_path)){
			case XML_SUCCESS:
				break;
			case XML_ERROR_FILE_NOT_FOUND:
				return MetaParserStatus::FILE_NOT_FOUND;
			case XML_ERROR_FILE_COULD_NOT_BE_OPENED:
			case XML_ERROR_FILE_READ_ERROR:
				return MetaParserStatus::FILE_ERROR;
			default:
				return MetaParserStatus::UNKNOWN_XML_ERROR;
		}
	}
	auto spec = doc.FirstChildElement();
	if (strcmp(spec->Name(), "spec"))
		return MetaParserStatus::MALFORMED_XML_STRUCTURE;

	try{
		this->parse(spec, this->state);
	}catch (const XmlAttributeNotFoundException &){
		return MetaParserStatus::MALFORMED_XML_STRUCTURE;
	}catch (const Parser::MetaParserStatus &status){
		return status;
	}
	return MetaParserStatus::SUCCESS;
}

	void Config::loadFile(const string& path)
	{
		XMLDocument document;
		if (document.LoadFile(path.c_str()) == XML_NO_ERROR) {
			XMLElement* file = document.FirstChildElement("file");
			if (file) {
				XMLElement* config = file->FirstChildElement("config");
				
				while (config) {
					const char* name = config->Attribute("name");
					if (name) {
						     if (strcmp(name, "DefaultGravity") == 0)       config->QueryDoubleAttribute("value", &Config::DefaultGravity);
						else if (strcmp(name, "PlayerMoveSpeed") == 0)      config->QueryDoubleAttribute("value", &Config::PlayerMoveSpeed);
						else if (strcmp(name, "PlayerJumpSpeed") == 0)      config->QueryDoubleAttribute("value", &Config::PlayerJumpSpeed);
						else if (strcmp(name, "MaxCrosshairDistance") == 0) config->QueryDoubleAttribute("value", &Config::MaxCrosshairDistance);
						else if (strcmp(name, "MaxGibsOnScreen") == 0)      config->QueryUnsignedAttribute("value", &Config::MaxGibsOnScreen);
						else if (strcmp(name, "GibsMin") == 0)              config->QueryIntAttribute("value", &Config::GibsMin);
						else if (strcmp(name, "GibsMax") == 0)              config->QueryIntAttribute("value", &Config::GibsMax);
						else if (strcmp(name, "BloodParticles") == 0)       config->QueryIntAttribute("value", &Config::BloodParticles);
						else if (strcmp(name, "GibMaxSpeedX") == 0)         config->QueryIntAttribute("value", &Config::GibMaxSpeedX);
						else if (strcmp(name, "GibMaxSpeedY") == 0)         config->QueryIntAttribute("value", &Config::GibMaxSpeedY);
						else if (strcmp(name, "BloodMaxSpeedX") == 0)       config->QueryIntAttribute("value", &Config::BloodMaxSpeedX);
						else if (strcmp(name, "BloodMaxSpeedY") == 0)       config->QueryIntAttribute("value", &Config::BloodMaxSpeedY);
					}
					
					config = config->NextSiblingElement("config");
				}
			}
		} else {
			cout << document.GetErrorStr1() << endl;
			cout << document.GetErrorStr2() << endl;
		}
	}