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

//read high scores XML ===============================
std::string loadScores ( int player )
{
	int counter=0;
	XMLDocument* doc = new XMLDocument();
	doc->LoadFile ( "highscore.xml" );
	int errorID = doc->ErrorID();
	std::string err = doc->ErrorName();
	std::string playerString[20][3];
	XMLPrinter printer;
	//std::cout << "Test file loaded. ErrorID = "<<errorID<<" "<<err<<std::endl;
	if ( errorID!=0 )
		return "";
	XMLNode* root = doc->FirstChildElement ( "players" );
	if ( root == NULL ) {
		std::cout<<"error xml root"<<std::endl;
		return "";
	}
	XMLElement* node = root->FirstChildElement ( "player" )->ToElement();
	if ( node == NULL ) {
		std::cout<<"error xml"<<std::endl;
		return "";
	}
	while ( node->NextSiblingElement() !=NULL && counter<=player ) {
		XMLElement* element = node->FirstChildElement ( "name" )->ToElement();
		if ( element == NULL ) {
			std::cout<<"error xml"<<std::endl;
			return "";
		}
		playerString[counter][0] = element->GetText();
		//std::cout <<"playerstring="<<playerString[counter][0]<<std::endl;
		element = element->NextSiblingElement ( "score" )->ToElement();
		if ( element == NULL ) {
			std::cout<<"error xml"<<std::endl;
			return "";
		}
		playerString[counter][1] = element->GetText();
		element = element->NextSiblingElement ( "mode" )->ToElement();
		if ( element == NULL ) {
			std::cout<<"error xml"<<std::endl;
			return "";
		}
		playerString[counter][2] = element->GetText();
		node = node->NextSiblingElement ( "player" )->ToElement();
		if ( node == NULL ) {
			std::cout<<"error xml"<<std::endl;
			return "";
		}
		counter++;
	}
	return playerString[player][0]+", "+playerString[player][1]+", "
		+playerString[player][2];
}

DecompositionPtr GraphMl::decompose(const Instance& instance) const
{
	using namespace tinyxml2;
	XMLDocument doc;
	if(doc.LoadFile(optFile.getValue().c_str()))
		error(doc.ErrorName());

	XMLElement* graphml = doc.RootElement();
	if(!graphml)
		error("No root element");

	XMLElement* graph = graphml->FirstChildElement("graph");
	if(!graph)
		error("No graph element");

	// XXX We assume the GraphML file has nodes and edges ordered as in a post-order traversal
	std::stack<DecompositionPtr> nodes;
	XMLElement* rootNode = graph->FirstChildElement("node");

	nodes.emplace(new Decomposition(bagOfNode(rootNode), app.getSolverFactory()));

	const XMLElement* element = rootNode;
	while((element = element->NextSiblingElement()) != nullptr) {
		if(strcmp(element->Name(), "node") == 0)
			nodes.emplace(new Decomposition(bagOfNode(element), app.getSolverFactory()));
		else if(strcmp(element->Name(), "edge") == 0) {
			if(nodes.size() < 2)
				error("Not enough nodes declared before edges");
			const DecompositionPtr to = nodes.top();
			nodes.pop();
			const DecompositionPtr& from = nodes.top();
			from->addChild(std::move(to));
		}
		else
			error("Unexpected element");
	}
	if(nodes.size() != 1)
		error("Not all non-root nodes connected to parents");

	DecompositionPtr root = nodes.top();

	if(optAddEmptyLeaves.isUsed())
		addEmptyLeaves(*root, app);
	if(optAddEmptyRoot.isUsed())
		root = addEmptyRoot(std::move(root), app);

	root->setRoot();
	return root;
}

//.........这里部分代码省略.........
	{
		const char* xml = "<element>    </element>";
		XMLDocument doc( true, COLLAPSE_WHITESPACE );
		doc.Parse( xml );
		XMLTest( "Whitespace  all space", true, 0 == doc.FirstChildElement()->FirstChild() );
	}

	{
		// An assert should not fire.
		const char* xml = "<element/>";
		XMLDocument doc;
		doc.Parse( xml );
		XMLElement* ele = doc.NewElement( "unused" );		// This will get cleaned up with the 'doc' going out of scope.
		XMLTest( "Tracking unused elements", true, ele != 0, false );
	}


	{
		const char* xml = "<parent><child>abc</child></parent>";
		XMLDocument doc;
		doc.Parse( xml );
		XMLElement* ele = doc.FirstChildElement( "parent")->FirstChildElement( "child");

		XMLPrinter printer;
		ele->Accept( &printer );
		XMLTest( "Printing of sub-element", "<child>abc</child>\n", printer.CStr(), false );
	}


	{
		XMLDocument doc;
		XMLError error = doc.LoadFile( "resources/empty.xml" );
		XMLTest( "Loading an empty file", XML_ERROR_EMPTY_DOCUMENT, error );
		XMLTest( "Loading an empty file and ErrorName as string", "XML_ERROR_EMPTY_DOCUMENT", doc.ErrorName() );
		doc.PrintError();
	}

	{
        // BOM preservation
        static const char* xml_bom_preservation  = "\xef\xbb\xbf<element/>\n";
        {
			XMLDocument doc;
			XMLTest( "BOM preservation (parse)", XML_SUCCESS, doc.Parse( xml_bom_preservation ), false );
            XMLPrinter printer;
            doc.Print( &printer );

            XMLTest( "BOM preservation (compare)", xml_bom_preservation, printer.CStr(), false, true );
			doc.SaveFile( "resources/bomtest.xml" );
        }
		{
			XMLDocument doc;
			doc.LoadFile( "resources/bomtest.xml" );
			XMLTest( "BOM preservation (load)", true, doc.HasBOM(), false );

            XMLPrinter printer;
            doc.Print( &printer );
            XMLTest( "BOM preservation (compare)", xml_bom_preservation, printer.CStr(), false, true );
		}
	}

	{
		// Insertion with Removal
		const char* xml = "<?xml version=\"1.0\" ?>"
			"<root>"
			"<one>"
			"<subtree>"

int main()
{
//    CURL* curl; //our curl object
//
//    struct BufferStruct output; // Create an instance of out BufferStruct to accept LCs output
//    output.buffer = NULL;
//    output.size = 0;
//
//    curl_global_init(CURL_GLOBAL_ALL); //pretty obvious
//    curl = curl_easy_init();
//
//    curl_easy_setopt(curl, CURLOPT_URL, "http://www.findyourfate.com/rss/horoscope-astrology-feed.asp?mode=view&todate=8/20/2015");
//    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &WriteMemoryCallback);
//    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&output);
//    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); //tell curl to output its progress
//
//    curl_easy_perform(curl);
//    curl_easy_cleanup(curl);
//
//    FILE * fp;
//    fp = fopen( "example.xml","w");
//    cout<<"HEILL!";
//    if( !fp )
//    	return 1;
//    fprintf(fp, output.buffer );
//    fclose( fp );
//
//    if( output.buffer )
//    {
//    	free ( output.buffer );
//    	output.buffer = 0;
//    	output.size = 0;
//    }
//
//    cin.get();
    XMLDocument doc;
    doc.LoadFile("example.xml");
    cout<< "ERROR ID: "<<doc.ErrorName()<<endl;

    XMLNode * pRoot = doc.FirstChild();
    if (pRoot ==NULL)
    	cout<<"ERROR!!!"<<endl;

   XMLNode* SiblingNode = pRoot->NextSibling();
   XMLNode* ChildNode = SiblingNode->FirstChild();

   XMLElement *ChildElmt = ChildNode->ToElement();
   string strTagName = ChildElmt->Name();
   cout<<strTagName<<endl;

   XMLNode* Child_2_Node = ChildNode->FirstChild();
   XMLElement *Child_2_NodeElmt = Child_2_Node->ToElement();

   strTagName = Child_2_NodeElmt->Name();
   cout<<strTagName<<endl;

   strTagName = Child_2_NodeElmt->GetText();
   cout<<strTagName<<endl;

   XMLNode* secSibling = Child_2_Node->NextSibling();
   XMLElement *Sib_2_NodeElmt = secSibling->ToElement();

  strTagName = Sib_2_NodeElmt->Name();
  cout<<strTagName<<endl;

  strTagName = Sib_2_NodeElmt->GetText();
     cout<<strTagName<<endl;

   //XMLElement* pElement = pRoot->ToElement();
   //if (pElement ==NULL)
    //      	cout<<"ERROR"<<endl;

//  XMLElement * pElement = pRoot->FirstChildElement("rss")->FirstChildElement("channel");
//  if (pElement ==NULL)
//       	cout<<"ERROR"<<endl;


//    if (pElement ==NULL)
//     	cout<<"ERROR"<<endl;
//    const char* title = pElement->GetText();
//	printf( "Name of play (1): %s\n", title );


//    cout << endl <<  pElement->GetText() << endl;
    //cin.get();







    //curl_global_cleanup();

    return 0;
}

bool LevelParser::writeLevel(const Level &level, std::string name)
{
	XMLDocument tmxFile;

	// Insert root element and its attributes
	XMLNode *pRoot = tmxFile.NewElement("map");
	tmxFile.InsertFirstChild(pRoot);

	XMLElement * pElement = tmxFile.RootElement();

	// Another option here would be taking the biggest width, height and tilewidth from level's tilelayers
	// width
	pElement->SetAttribute("width", level.getWidth());
	// height
	pElement->SetAttribute("height", level.getHeight());
	// tilewidth
	pElement->SetAttribute("tilewidth", level.getTileSize());
	// tileheight
	pElement->SetAttribute("tileheight", level.getTileSize());
	// musicID
	pElement->SetAttribute("musicID", level.getMusic().c_str());

	// write level layers
	int tileLayers = 1, objLayers = 1, bckLayers = 1;
	for (auto pLayer : level.m_layers)
	{
		std::string layerID = pLayer->getLayerID();
		if (layerID == "OBJECT")// && (dynamic_cast<ObjectLayer*>(pLayer)->getGameObjects()->size() != 0))
		{
			pElement = tmxFile.NewElement("objectgroup");
			writeObjectLayer(pElement, dynamic_cast<ObjectLayer*>(pLayer), "Object Layer " + to_string(objLayers));
			objLayers++;
			// Insert object layer node
			pRoot->InsertEndChild(pElement);
		}
		else if (layerID == "TILE")
		{
			pElement = tmxFile.NewElement("layer");
			writeTileLayer(pElement, dynamic_cast<TileLayer*>(pLayer), "Tile Layer " + to_string(tileLayers));
			tileLayers++;
			// Insert tile layer node
			pRoot->InsertEndChild(pElement);
		}
		else if (layerID == "BACKGROUND")
		{
			pElement = tmxFile.NewElement("background");
			writeObjectLayer(pElement, dynamic_cast<BckLayer*>(pLayer), "Background Layer " + to_string(bckLayers));
			bckLayers++;
			pRoot->InsertEndChild(pElement);
		}
	}

	if (tmxFile.SaveFile(name.c_str()) == XML_NO_ERROR)
	{
		return true;
	}
	else
	{
		std::cout << "An error has ocurred writing file " << name << ". TinyXML error: " << tmxFile.ErrorName() << std::endl;
		return false;
	}
}

const Material MaterialLoader::loadFromXML(const std::string &path) {
  std::string dir = path.substr(0, path.find_last_of("/\\"));
  XMLDocument doc;
  XMLError error = doc.LoadFile((Environment::getDataDir() + "/textures/" + path + ".gmd").c_str());

  if (error != XML_NO_ERROR) {
    System::Log(Error, "MaterialLoader") << "XML Error " << doc.ErrorID() << ": " <<
      doc.ErrorName() << " in " << path;
  }

  XMLHandle docHandle(&doc);
  XMLElement *root = docHandle.FirstChildElement().ToElement();
  XMLHandle rootH(root);

  std::string name = root->Attribute("name");
  std::string fancyname = root->Attribute("fancyname");

  Material mat;

  mat.name = name;
  mat.fancyname = fancyname;

  XMLElement *diffE = rootH.FirstChildElement("diffuse").ToElement();
  if (diffE) {
    std::string diffP = diffE->Attribute("path");
    if (diffP.length() > 0) {
      diffP = dir + "/" + diffP;
      System::Log(Debug, "MaterialLoader") << mat.name << ": load " << diffP;
      mat.diffuse = TextureLoader::getTexture(diffP);
    }
  } else {
    mat.diffuse = TextureLoader::getEmptyDiffuse();
  }

  XMLElement *normE = rootH.FirstChildElement("normal").ToElement();
  if (normE) {
    std::string normP = normE->Attribute("path");
    if (normP.length() > 0) {
      normP = dir + "/" + normP;
      System::Log(Debug, "MaterialLoader") << mat.name << ": load " << normP;
      mat.normal = TextureLoader::getTexture(normP);
    }
  } else {
    mat.normal = TextureLoader::getEmptyNormal();
  }

  XMLElement *specE = rootH.FirstChildElement("specular").ToElement();
  if (specE) {
    std::string specP = specE->Attribute("path");
    if (specP.length() > 0) {
      specP = dir + "/" + specP;
      System::Log(Debug, "MaterialLoader") << mat.name << ": load " << specP;
      mat.specular = TextureLoader::getTexture(specP);
    }
    specE->QueryFloatAttribute("shininess", &mat.shininess);
  } else {
    mat.specular = TextureLoader::getEmptySpecular();
  }

  XMLElement *surfaceE = rootH.FirstChildElement("surface").ToElement();
  mat.portalable = false;
  if (surfaceE) {
    surfaceE->QueryBoolAttribute("portalable", &mat.portalable);
  }

  XMLElement *scaleE = rootH.FirstChildElement("scale").ToElement();
  if (scaleE) {
    scaleE->QueryFloatAttribute("u", &mat.scaleU);
    scaleE->QueryFloatAttribute("v", &mat.scaleV);
  }

  XMLElement *kindE = rootH.FirstChildElement("kind").ToElement();
  if (kindE) {
    mat.kind = std::string(kindE->GetText());
  }

  XMLElement *tagsE = rootH.FirstChildElement("tags").ToElement();
  if (tagsE) {
    std::string tagStr(tagsE->GetText());
    size_t start = 0;
    size_t index = tagStr.find(",", start);
    while (index != std::string::npos) {
      mat.tags.push_back(tagStr.substr(start, index - start));
      start = index + 1;
      index = tagStr.find(",", start);
    }
    if (start != std::string::npos) {
      mat.tags.push_back(tagStr.substr(start));
    }
  }

  // TODO

  return mat;
}