C++ XMLNode::InsertEndChild方法代码示例

void DividendTuningOptFileRoutines::generateTuningNodes(const std::vector<LWSKernelPar> macroVecs)
{

	XMLNode * tnode = doc.NewElement( "DIVIDEND" );  
	XMLNode * lnode = doc.NewElement( "LWGS" );  

	doc.InsertFirstChild(tnode);
	tnode->InsertFirstChild(lnode);

	for (unsigned i=0; i<macroVecs.size(); i++)
	{
		std::stringstream kernelStr;
		kernelStr << KERNEL_STR << "_" << KernelToken++;

		XMLElement *kElement = doc.NewElement( "Kernel" );
		XMLNode * kNode = tnode->InsertFirstChild( kElement ); 

		std::stringstream cstr; 
		cstr << " Tuning parameters for " << kernelStr.str(); 
		kElement->SetAttribute("identifier", macroVecs[i].getIdentifier().c_str());
		kElement->SetAttribute("kernelid", macroVecs[i].getKernelId());
		kElement->SetAttribute("dim", macroVecs[i].getDim());
		XMLNode *cNode = kNode->InsertFirstChild(doc.NewComment(cstr.str().c_str()));

		//Dump dimention information
		XMLNode *pNode = cNode;
		const vector<LWSMacro> lwsM = macroVecs[i].getLWSMacros();

		for (unsigned j=0; j< lwsM.size(); j++)
		{
			XMLElement *dElement = doc.NewElement("Dim");
			dElement->SetAttribute("index", j);
			dElement->SetAttribute("macro", lwsM[j].getMacroName().c_str());
			dElement->SetAttribute("start", lwsM[j].getStart());
			dElement->SetAttribute("end", lwsM[j].getEnd());
			dElement->SetAttribute("step", lwsM[j].getStep());
			dElement->SetAttribute("default", lwsM[j].getDefault());

			XMLNode *tmp = kNode->InsertAfterChild(pNode, dElement);
			pNode = tmp;
		}

		lnode->InsertEndChild( kElement ); 
	}

	tnode->InsertEndChild(lnode);
	doc.InsertEndChild(tnode);
}

void example_5()
{
    printf( "XML Example 5\n" );
    
    // Test: Programmatic DOM
    // Build:
    //		<element>
    //			<!--comment-->
    //			<sub attrib="1" />
    //			<sub attrib="2" />
    //			<sub attrib="3" >& Text!</sub>
    //		<element>
    
    XMLDocument* doc = new XMLDocument();
    XMLNode* element = doc->InsertEndChild( doc->NewElement( "element" ) );
    
    XMLElement* sub[3] = { doc->NewElement( "sub" ), doc->NewElement( "sub" ), doc->NewElement( "sub" ) };
    for( int i=0; i<3; ++i ) {
        sub[i]->SetAttribute( "attrib", i );
    }
    element->InsertEndChild( sub[2] );
    XMLNode* comment = element->InsertFirstChild( doc->NewComment( "comment" ) );
    element->InsertAfterChild( comment, sub[0] );
    element->InsertAfterChild( sub[0], sub[1] );
    sub[2]->InsertFirstChild( doc->NewText( "& Text!" ));
    doc->Print();
    
    doc->SaveFile( "pretty.xml" );
    doc->SaveFile( "compact.xml", true );
    delete doc;
}

/**
 * Write the current object 
 */
void MetadataTranslator::OnWrite( const Object * pObject, pcstr pszName, Context & ctxt, XMLNode & elem )
{
	const Metadata* pmetadata = dynamic_cast< const Metadata*>(pObject);
	if( pmetadata == NULL) 
		throw TranslationException("MetadataTranslator cannot cast Metadata object");

	XMLElement* pelemc = elem.GetDocument()->NewElement( pszName);

	//Set the namespace for the Metadata.
	pelemc->SetAttribute( "xmlns", METADATA_NAMESPACE);

	//Fill out id, artifacts, and comments last in accordance
	//with schema.
	WriteAttributedObject( *pmetadata, ctxt, *pelemc);

	WriteList<AnyUri>( pmetadata->Includes(), "include", ctxt, *pelemc);
	WriteList<Band>(   pmetadata->Bands(), "band", ctxt, *pelemc);
	WriteList<IonStream>( pmetadata->Streams(), "stream", ctxt, *pelemc);
	WriteList<Lump>( pmetadata->Lumps(), "lump", ctxt, *pelemc);
	WriteList<Chunk>( pmetadata->Chunks(), "chunks", ctxt, *pelemc);
	WriteList<Block>( pmetadata->Blocks(), "blocks", ctxt, *pelemc);
	WriteList<Lane>( pmetadata->Lanes(), "lane", ctxt, *pelemc);
	WriteList<System>( pmetadata->Systems(), "system", ctxt, *pelemc);
	WriteList<Session>( pmetadata->Sessions(), "session", ctxt, *pelemc);
	WriteList<File>( pmetadata->Files(), "file", ctxt, *pelemc);
	WriteList<FileSet>( pmetadata->FileSets(), "fileset", ctxt, *pelemc);
	
	elem.InsertEndChild( pelemc);
}

void emu::Settings::CreateDefaultXml(char const * filename)
{
    cpumode = "interpeter-slow";
    gerenderer = "pspe4all-hal.video.OGL4";

    XMLDocument xmlDoc;

    XMLNode * pRoot = xmlDoc.NewElement("pspe4all");
    xmlDoc.InsertFirstChild(pRoot);
    XMLElement * pElement = xmlDoc.NewElement("GeneralSettings");

    XMLElement * pListElement = xmlDoc.NewElement("CpuMode");
    pListElement->SetText(cpumode.c_str());

    pElement->InsertEndChild(pListElement);

    XMLElement * pListElement2 = xmlDoc.NewElement("GeRenderer");
    pListElement2->SetText(gerenderer.c_str());

    pElement->InsertEndChild(pListElement2);

    pRoot->InsertEndChild(pElement);

    xmlDoc.SaveFile(filename);
}

bool CGBFile<GeomType, ValueType>::save(const std::string& directoryname, const std::string& fn, const Volume3d<GeomType, ValueType>& volume)
{	
	const std::string& filename = directoryname + "/" + fn;
	XMLDocument xml;
	XMLDeclaration* decl = xml.NewDeclaration();
	xml.InsertEndChild(decl);
	XMLNode* root = xml.NewElement("root");
	xml.InsertEndChild(root);

	{
		XMLElement* res = xml.NewElement(resStr.c_str());

		res->SetAttribute("x", volume.getResolutions()[0]);
		res->SetAttribute("y", volume.getResolutions()[1]);
		res->SetAttribute("z", volume.getResolutions()[2]);

		root->InsertEndChild(res);
	}

	root->InsertEndChild( create(xml, originStr, volume.getStart()) );
	root->InsertEndChild( create(xml, "length", volume.getSpace().getLengths()));

	imageFileNames.clear();
	{
		XMLElement* e = xml.NewElement("volume");

		e->SetAttribute("type", "unsigned char");
		e->SetAttribute("format", "png");

		VolumeFile vFile(directoryname);
		for (size_t i = 0; i < volume.getResolutions()[2]; ++i) {
			const auto iFile = vFile.toImageFile( "image", i, ImageFile::Type::PNG);
			XMLElement* elem = xml.NewElement("image");
			const auto& str = iFile.getFileNameIncludingPath();
			elem->SetAttribute("path", str.c_str());
			e->InsertEndChild(elem);
			imageFileNames.push_back(str);
		}

		root->InsertEndChild(e);
	}

	//for (size_t i = 0; i < )
	
	xml.SaveFile(filename.c_str());
	return true;
}

static void DumpProfilingInfo()
{
	XMLDocument doc;
	XMLDeclaration *d = doc.NewDeclaration();

	DIVIDEND_EXIT_ERROR_ON(d== NULL, -1, "Invalid XML Declaratio");
	doc.InsertEndChild(d);

	XMLNode * tnode = doc.NewElement( "DIVIDEND" );  
	XMLNode * lnode = doc.NewElement( "LWGS" );  

	DIVIDEND_EXIT_ERROR_ON(tnode == NULL, -1, "Failed to crate a node");
	DIVIDEND_EXIT_ERROR_ON(lnode == NULL, -1, "Failed to crate a node");

	doc.InsertFirstChild(tnode);
	tnode->InsertFirstChild(lnode);

	for (unsigned i=0; i<profEventIndex; i++)
	{
		XMLElement *kElement = doc.NewElement( "Kernel" );
		XMLNode * kNode = tnode->InsertFirstChild( kElement ); 
		
		kElement->SetAttribute("id",KPI[i].kernel_id);
		
		float time = 0.0;
		
		for (unsigned j=0; j<KPI[i].idx; j++)
		{
			//clGetEventProfilingInfo(KPI[i].event[j], CL_PROFILING_COMMAND_START, sizeof(KPI[i].time_starti[j]), &(KPI[i].time_start[j]), NULL);
			//clGetEventProfilingInfo(KPI[i].event[j], CL_PROFILING_COMMAND_END, sizeof(KPI[i].time_end[j]), &(KPI[i].time_end[j]), NULL);
			time = time + (KPI[i].time_end[j] - KPI[i].time_start[j])/1000000.0;
		}

		time = time / (float) KPI[i].idx;
		
		kElement->SetAttribute("time", time);
		lnode->InsertEndChild( kElement ); 
	}

	tnode->InsertEndChild(lnode);
	doc.InsertEndChild(tnode);
	doc.SaveFile(DIVIDEND_PROF_FILE_NAME);
}

void OutputWriter::WriteInitOutput(ResponseMsg response){
	std::string path = CommandManager::getPathOut();
	tinyxml2::XMLDocument* doc = CommandManager::getDocOut();

	doc->Clear(); //Clear all text
	XMLNode *root = doc->NewElement("init");
	
	XMLText* textCode = doc->NewText((Utils::convertInt(response.getCode()).c_str()));
	XMLText* textMessage = doc->NewText(response.getMessage());

	XMLElement* codeElement = doc->NewElement("code");
	root->InsertEndChild(codeElement);
	XMLElement* messageElement = doc->NewElement("message");
	root->InsertEndChild(messageElement);

	codeElement->InsertEndChild(textCode);
	messageElement->InsertEndChild(textMessage);

	doc->InsertEndChild(root);
	doc->SaveFile(path.c_str());
}

void OutputWriter::WriteCommandNotFormat(){
	std::string path = CommandManager::getPathOut();
	tinyxml2::XMLDocument* doc = CommandManager::getDocOut();

	XMLNode *root = doc->NewElement("command");

	XMLText* textCode = doc->NewText((Utils::convertInt(CAMERROR_VALUE_UNKNOWN)).c_str());

	XMLElement* codeElement = doc->NewElement("code");
	root->InsertEndChild(codeElement);

	codeElement->InsertEndChild(textCode);

	XMLElement* commandsElement = doc->FirstChildElement("commands");
	commandsElement->InsertEndChild(root);
}

//.........这里部分代码省略.........
										"<element><b></b></element>",
										"<element>Text inside and <b>bolded</b> in the element.</element>",
										"<outer><element>Text inside and <b>bolded</b> in the element.</element></outer>",
										"<element>This &amp; That.</element>",
										"<element attrib='This&lt;That' />",
										0
		};
		for( int i=0; test[i]; ++i ) {
			XMLDocument doc;
			doc.Parse( test[i] );
			doc.Print();
			printf( "----------------------------------------------\n" );
		}
	}
#if 1
	{
		static const char* test = "<!--hello world\n"
								  "          line 2\r"
								  "          line 3\r\n"
								  "          line 4\n\r"
								  "          line 5\r-->";

		XMLDocument doc;
		doc.Parse( test );
		doc.Print();
	}

	{
		static const char* test = "<element>Text before.</element>";
		XMLDocument doc;
		doc.Parse( test );
		XMLElement* root = doc.FirstChildElement();
		XMLElement* newElement = doc.NewElement( "Subelement" );
		root->InsertEndChild( newElement );
		doc.Print();
	}
	{
		XMLDocument* doc = new XMLDocument();
		static const char* test = "<element><sub/></element>";
		doc->Parse( test );
		delete doc;
	}
	{
		// Test: Programmatic DOM
		// Build:
		//		<element>
		//			<!--comment-->
		//			<sub attrib="1" />
		//			<sub attrib="2" />
		//			<sub attrib="3" >& Text!</sub>
		//		<element>

		XMLDocument* doc = new XMLDocument();
		XMLNode* element = doc->InsertEndChild( doc->NewElement( "element" ) );

		XMLElement* sub[3] = { doc->NewElement( "sub" ), doc->NewElement( "sub" ), doc->NewElement( "sub" ) };
		for( int i=0; i<3; ++i ) {
			sub[i]->SetAttribute( "attrib", i );
		}
		element->InsertEndChild( sub[2] );
		XMLNode* comment = element->InsertFirstChild( doc->NewComment( "comment" ) );
		element->InsertAfterChild( comment, sub[0] );
		element->InsertAfterChild( sub[0], sub[1] );
		sub[2]->InsertFirstChild( doc->NewText( "& Text!" ));
		doc->Print();
		XMLTest( "Programmatic DOM", "comment", doc->FirstChildElement( "element" )->FirstChild()->Value() );

int main( int /*argc*/, const char ** /*argv*/ )
{
	#if defined( _MSC_VER ) && defined( DEBUG )
		_CrtMemCheckpoint( &startMemState );
	#endif	

	#if defined(_MSC_VER)
	#pragma warning ( push )
	#pragma warning ( disable : 4996 )		// Fail to see a compelling reason why this should be deprecated.
	#endif

	FILE* fp = fopen( "dream.xml", "r" );
	if ( !fp ) {
		printf( "Error opening test file 'dream.xml'.\n"
				"Is your working directory the same as where \n"
				"the xmltest.cpp and dream.xml file are?\n\n"
	#if defined( _MSC_VER )
				"In windows Visual Studio you may need to set\n"
				"Properties->Debugging->Working Directory to '..'\n"
	#endif
			  );
		exit( 1 );
	}
	fclose( fp );

	#if defined(_MSC_VER)
	#pragma warning ( pop )
	#endif

	/* ------ Example 1: Load and parse an XML file. ---- */	
	{
		XMLDocument doc;
		doc.LoadFile( "dream.xml" );
	}
	
	/* ------ Example 2: Lookup information. ---- */	
	{
		XMLDocument doc;
		doc.LoadFile( "dream.xml" );

		// Structure of the XML file:
		// - Element "PLAY"			the root Element
		// - - Element "TITLE"		child of the root PLAY Element
		// - - - Text				child of the TITLE Element
		
		// Navigate to the title, using the convenience function, with a dangerous lack of error checking.
		const char* title = doc.FirstChildElement( "PLAY" )->FirstChildElement( "TITLE" )->GetText();
		printf( "Name of play (1): %s\n", title );
		
		// Text is just another Node to TinyXML-2. The more general way to get to the XMLText:
		XMLText* textNode = doc.FirstChildElement( "PLAY" )->FirstChildElement( "TITLE" )->FirstChild()->ToText();
		title = textNode->Value();
		printf( "Name of play (2): %s\n", title );
	}

	{
		static const char* test[] = {	"<element />",
									    "<element></element>",
										"<element><subelement/></element>",
									    "<element><subelement></subelement></element>",
									    "<element><subelement><subsub/></subelement></element>",
									    "<!--comment beside elements--><element><subelement></subelement></element>",
									    "<!--comment beside elements, this time with spaces-->  \n <element>  <subelement> \n </subelement> </element>",
									    "<element attrib1='foo' attrib2=\"bar\" ></element>",
									    "<element attrib1='foo' attrib2=\"bar\" ><subelement attrib3='yeehaa' /></element>",
										"<element>Text inside element.</element>",
										"<element><b></b></element>",
										"<element>Text inside and <b>bolded</b> in the element.</element>",
										"<outer><element>Text inside and <b>bolded</b> in the element.</element></outer>",
										"<element>This &amp; That.</element>",
										"<element attrib='This&lt;That' />",
										0
		};
		for( int i=0; test[i]; ++i ) {
			XMLDocument doc;
			doc.Parse( test[i] );
			doc.Print();
			printf( "----------------------------------------------\n" );
		}
	}
#if 1
	{
		static const char* test = "<!--hello world\n"
			                      "          line 2\r"
			                      "          line 3\r\n"
			                      "          line 4\n\r"
			                      "          line 5\r-->";

		XMLDocument doc;
		doc.Parse( test );
		doc.Print();
	}

	{
		static const char* test = "<element>Text before.</element>";
		XMLDocument doc;
		doc.Parse( test );
		XMLElement* root = doc.FirstChildElement();
		XMLElement* newElement = doc.NewElement( "Subelement" );
		root->InsertEndChild( newElement );
//.........这里部分代码省略.........

int Effect::saveEffect(char* filepath)
{
	XMLDocument doc;
	XMLNode* effect = doc.NewElement("Effect");
	doc.InsertFirstChild(effect);
	for (auto emitter : emitterVec)
	{
	/****Constructor stuff****/
		XMLNode* emitterNode = doc.NewElement("Emitter");
		effect->InsertEndChild(emitterNode);

		XMLElement* element = doc.NewElement("OutputType");
		element->SetText(emitter->getOutputType());
		emitterNode->InsertEndChild(element);

		element = doc.NewElement("Position");
		glm::vec3 position = emitter->getLocalPosition();
		element->SetAttribute("x", position.x);
		element->SetAttribute("y", position.y);
		element->SetAttribute("z", position.z);
		emitterNode->InsertEndChild(element);

		element = doc.NewElement("EmitterLifetime");
		element->SetText(emitter->getEmitterLifetime());
		emitterNode->InsertEndChild(element);

		element = doc.NewElement("EmitFrequency");
		element->SetText(emitter->getEmitFrequency());
		emitterNode->InsertEndChild(element);

		element = doc.NewElement("ParticlesPerEmit");
		element->SetText(emitter->getParticlesPerEmit());
		emitterNode->InsertEndChild(element);

		element = doc.NewElement("ParticleLiftime");
		element->SetText(emitter->getParticleLifetime());
		emitterNode->InsertEndChild(element);

		element = doc.NewElement("ParticleMortal");
		element->SetText(emitter->getParticleMortality());
		emitterNode->InsertEndChild(element);

	/****other necessary stuff****/
		//Geometry Shader
		element = doc.NewElement("UseGeometryShader");
		element->SetText(emitter->getUseGeometryShader());
		emitterNode->InsertEndChild(element);

		//Movable
		element = doc.NewElement("Movable");
		element->SetText(emitter->getMovable());
		emitterNode->InsertEndChild(element);

		//Start time
		element = doc.NewElement("StartTime");
		element->SetText(emitter->getStartTime());
		emitterNode->InsertEndChild(element);
		
		//Velocity
		element = doc.NewElement("Velocity");
		element->SetText(emitter->getVelocityType());
		emitterNode->InsertEndChild(element);

		//Physic
		element = doc.NewElement("Physic");
		if (emitter->getPhysicTrajectory()){
			XMLElement* physic = doc.NewElement("Trajectory");
			XMLElement* gravity = doc.NewElement("Gravity");
			glm::vec4 gravityVec = emitter->getGravity();
			gravity->SetAttribute("x", gravityVec.x);
			gravity->SetAttribute("y", gravityVec.y);
			gravity->SetAttribute("z", gravityVec.z);
			gravity->SetAttribute("w", gravityVec.w);
			physic->InsertEndChild(gravity);

			XMLElement* speed = doc.NewElement("Speed");
			speed->SetText(emitter->getSpeed());
			physic->InsertEndChild(speed);
			element->InsertEndChild(physic);
		}
		else if (emitter->getPhysicDirectionGravity()){
			XMLElement* physic = doc.NewElement("DirectionGravity");
			XMLElement* temp = doc.NewElement("Gravity");
			glm::vec4 gravityVec = emitter->getGravity();
			temp->SetAttribute("x", gravityVec.x);
			temp->SetAttribute("y", gravityVec.y);
			temp->SetAttribute("z", gravityVec.z);
			temp->SetAttribute("w", gravityVec.w);
			physic->InsertEndChild(temp);

			temp = doc.NewElement("Speed");
			temp->SetText(emitter->getSpeed());
			physic->InsertEndChild(temp);
			element->InsertEndChild(physic);
		}
		else if (emitter->getPhysicPointGravity()){
			XMLElement* physic = doc.NewElement("PointGravity");
			XMLElement* temp = doc.NewElement("Point");
			glm::vec4 gravityVec = emitter->getGravity();
			temp->SetAttribute("x", gravityVec.x);
//.........这里部分代码省略.........

bool DividendTuningOptFileRoutines::dumpSearchResult(const std::vector<DividendLWSKernelConf> confs, string& fname)
{
	fname = DIVIDEND_LWS_TUNING_RESULT_PREFIX;

	time_t rawtime;
	struct tm *info;
	char buffer[80];

	time( &rawtime );
	info = localtime( &rawtime );

	strftime(buffer,80,"-%Y%m%dT%H%M%S%z", info);
	fname = fname + buffer;
	fname = fname + ".xml";

	XMLDocument doc;
	doc.InsertEndChild (doc.NewDeclaration() );

	XMLNode *tnode = doc.NewElement( "DIVIDEND" );  
	XMLNode *lnode = doc.NewElement( "LWGS" );  
	XMLNode *kkNode = NULL;

	for (unsigned i=0; i<confs.size(); i++)
	{
		const DividendLWSKernelConf& c = confs[i];
		XMLElement * knode = doc.NewElement( "kernel" );  
		knode->SetAttribute("id", c.kernel_id);
		knode->SetAttribute("dim", c.best.dim);
		knode->SetAttribute("rsize", (unsigned int)c.confs.size());

		XMLNode *pcNode = NULL;

		for (unsigned j=0; j<c.confs.size(); j++)
		{
			const DividendLWSConf& CC = c.confs[j];
			XMLElement * ccnode = doc.NewElement( "config" );
			ccnode->SetAttribute("id", j);
			ccnode->SetAttribute("runtime", (double)CC.time);
			ccnode->SetAttribute("speedup", CC.defaultT / CC.time);
			ccnode->SetAttribute("ci", CC.ci);

			if (pcNode)
			{
				knode->InsertAfterChild(pcNode, ccnode);
			}
			else
			{
				knode->InsertFirstChild(ccnode);
			}

			pcNode = ccnode; 

			XMLElement *ppNode = NULL;
			for (unsigned k=0; k<CC.dim; k++)
			{
				XMLElement *mnode = doc.NewElement ("paramter");
				mnode->SetAttribute("macroname", CC.macroName[k].c_str());
				mnode->SetAttribute("val", CC.val[k]);

				if (ppNode)
				{
					ccnode->InsertAfterChild(ppNode, mnode);
				}
				else
				{
					ccnode->InsertFirstChild(mnode);
				}

				ppNode = mnode; 
			}

		}

		if (kkNode)
		{
			lnode->InsertAfterChild(kkNode, knode);
		}
		else
		{
			lnode->InsertFirstChild(knode);
		}

		kkNode = knode; 
	}
	
	tnode->InsertEndChild(lnode);
	doc.InsertEndChild(tnode);
	
	
	return doc.SaveFile(fname.c_str()) ==  XML_NO_ERROR;
}

int testWriteDoc(string fileName)
{
	//https://shilohjames.wordpress.com/2014/04/27/tinyxml2-tutorial/#XML-CreateXMLDocument

	tinyxml2::XMLDocument temp;
	XMLNode * root = temp.NewElement("Root");
	temp.InsertFirstChild(root);
	XMLElement * element = temp.NewElement("tuixml");
	element->SetAttribute("background", "black");
	{
			XMLElement * rectangle = temp.NewElement("rectangle");
			rectangle->SetAttribute("text", "");
			rectangle->SetAttribute("x", 0);
			rectangle->SetAttribute("y", 0);
			rectangle->SetAttribute("width", "30");
			rectangle->SetAttribute("height", "35");
			rectangle->SetAttribute("foreground", "yellow");
			rectangle->SetAttribute("background", "red");
			XMLElement * text = temp.NewElement("text");
			rectangle->InsertEndChild(text);
			element->InsertEndChild(rectangle);
	}
	for(int counter = 0, y = 0; counter < 6; counter++, y+=6)
	{
		srand (time(NULL));
		for(int counter1 = 0, x = 31; counter1 < 9; x+=6, counter1++ )
		{
			string colours[] = {"black", "red", "green", "blue", "magenta", "cyan", "white"};
			int background = rand() % 6 + 1;
			int foreground = rand() % 6 + 1;
			char yString[5] = {'\0'};
			char xString[5] = {'\0'};
			sprintf(yString,"%d", y);
			sprintf(xString,"%d", x);
			XMLElement * rectangle = temp.NewElement("rectangle");
			rectangle->SetAttribute("text", "");
			rectangle->SetAttribute("x", xString);
			rectangle->SetAttribute("y", yString);
			rectangle->SetAttribute("width", "5");
			rectangle->SetAttribute("height", "5");
			rectangle->SetAttribute("foreground", colours[foreground].c_str());
			rectangle->SetAttribute("background", colours[background].c_str());
			XMLElement * text = temp.NewElement("text");
			rectangle->InsertEndChild(text);
			element->InsertEndChild(rectangle);
		}
	}
	for(int counter = 0, y = 0; counter < 6; counter++, y+=6)
	{
		srand (time(NULL));
		for(int counter1 = 0, x = 85; counter1 < 9; x+=6, counter1++ )
		{
			string colours[] = {"black", "red", "green", "blue", "magenta", "cyan", "white"};
			int background = rand() % 5 + 1;
			int foreground = rand() % 5 + 1;
			char yString[5] = {'\0'};
			char xString[5] = {'\0'};
			sprintf(yString,"%d", y);
			sprintf(xString,"%d", x);
			XMLElement * rectangle = temp.NewElement("rectangle");
			rectangle->SetAttribute("text", "");
			rectangle->SetAttribute("x", xString);
			rectangle->SetAttribute("y", yString);
			rectangle->SetAttribute("width", "5");
			rectangle->SetAttribute("height", "5");
			rectangle->SetAttribute("foreground", colours[foreground].c_str());
			rectangle->SetAttribute("background", colours[background].c_str());
			XMLElement * text = temp.NewElement("text");
			rectangle->InsertEndChild(text);
			element->InsertEndChild(rectangle);
		}
	}
	for(int counter = 0, y = 0; counter < 6; counter++, y+=6)
	{
		char textString[10][100] = {"first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth"};
		char yString[5] = {'\0'};
		sprintf(yString,"%d", y);
		XMLElement * text = temp.NewElement("text");
		text->SetAttribute("text", textString[counter]);
		text->SetAttribute("x", "100");
		text->SetAttribute("y", yString);
		text->SetAttribute("width", "10");
		text->SetAttribute("height", "5");
		text->SetAttribute("foreground", "blue");
		text->SetAttribute("background", "white");
		element->InsertEndChild(text);
	}
	root->InsertEndChild(element);


	return temp.SaveFile(fileName.c_str());

}

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

bool saveOutputXML(OutputXML *xml, string path) {
	cout << "Salvando..." << endl;
	XMLDocument doc;

	// root node
	XMLNode * testInput = doc.NewElement("testinput");

	// cabe�alho
	XMLElement * dataset = doc.NewElement("dataset");
	dataset->SetAttribute("id", xml->id.c_str());
	testInput->InsertFirstChild(dataset);

	// tempos
	XMLElement * times = doc.NewElement("execution_time");
	for (auto _t : xml->all_times) {
		// ignora esse elemento
		if (_t.first == Task::ALL) continue;

		// calcula a media e desvio padrao
		double m, d;
		Helper::mediaDesvioDouble(_t.second, m, d);

		// adiciona no xml
		XMLElement * time = doc.NewElement("time");
		time->SetAttribute("name", Task::getName(_t.first).c_str());
		time->SetAttribute("mean", m);
		time->SetAttribute("stddev", d);
		times->InsertEndChild(time);
	}
	testInput->InsertEndChild(times);
	
	// frames
	XMLElement * frames = doc.NewElement("frames");
	frames->SetAttribute("n", xml->nFrames);
	for (int i = 0; i < (int)xml->frameNumber.size(); i++) {
		XMLElement * frame = doc.NewElement("frame");

		frame->SetAttribute("id", xml->frameNumber[i]);
		frame->SetAttribute("laneCenter", xml->laneCenter[i]);
		frame->SetAttribute("laneChange", xml->laneChange[i]);
		frame->SetAttribute("laneLeft", xml->multipleLanes.left[i]);
		frame->SetAttribute("laneRight", xml->multipleLanes.right[i]);
		frame->SetAttribute("lmtLeft", xml->lmt.left[i]);
		frame->SetAttribute("lmtRight", xml->lmt.right[i]);
		string roadSigns = "";
		for (unsigned int j = 0; j < xml->roadSigns[i].size(); j++) {
			roadSigns += to_string(xml->roadSigns[i][j]);
			if (j != xml->roadSigns[i].size() - 1) roadSigns += ";";
		}
		frame->SetAttribute("roadSigns", roadSigns.c_str());
		frame->SetAttribute("time", xml->time[i]);

		XMLElement * position = doc.NewElement("position");
		XMLElement * posLeft = doc.NewElement("left");
		XMLElement * p1left = doc.NewElement("p1");
		XMLElement * p2left = doc.NewElement("p2");
		XMLElement * p3left = doc.NewElement("p3");
		XMLElement * p4left = doc.NewElement("p4");
		if (std::isnan(xml->position.left[i][0])) p1left->SetText("nan");
		else p1left->SetText(xml->position.left[i][0]);
		if (std::isnan(xml->position.left[i][1])) p2left->SetText("nan");
		else p2left->SetText(xml->position.left[i][1]);
		if (std::isnan(xml->position.left[i][2])) p3left->SetText("nan");
		else p3left->SetText(xml->position.left[i][2]);
		if (std::isnan(xml->position.left[i][3])) p4left->SetText("nan");
		else p4left->SetText(xml->position.left[i][3]);

		XMLElement * posRight = doc.NewElement("right");
		XMLElement * p1right = doc.NewElement("p1");
		XMLElement * p2right = doc.NewElement("p2");
		XMLElement * p3right = doc.NewElement("p3");
		XMLElement * p4right = doc.NewElement("p4");
		if (std::isnan(xml->position.right[i][0])) p1right->SetText("nan");
		else p1right->SetText(xml->position.right[i][0]);
		if (std::isnan(xml->position.right[i][1])) p2right->SetText("nan");
		else p2right->SetText(xml->position.right[i][1]);
		if (std::isnan(xml->position.right[i][2])) p3right->SetText("nan");
		else p3right->SetText(xml->position.right[i][2]);
		if (std::isnan(xml->position.right[i][3])) p4right->SetText("nan");
		else p4right->SetText(xml->position.right[i][3]);

		// insert the elements
		posLeft->InsertEndChild(p1left);
		posLeft->InsertEndChild(p2left);
		posLeft->InsertEndChild(p3left);
		posLeft->InsertEndChild(p4left);

		posRight->InsertEndChild(p1right);
		posRight->InsertEndChild(p2right);
		posRight->InsertEndChild(p3right);
		posRight->InsertEndChild(p4right);

		position->InsertFirstChild(posLeft);
		position->InsertEndChild(posRight);

		frame->InsertFirstChild(position);

		frames->InsertEndChild(frame);
	}
	testInput->InsertEndChild(frames);
//.........这里部分代码省略.........